org.eclipse.scout.sdk.util/src/org/eclipse/scout/sdk/util/NamingUtility.java

/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.scout.sdk.util;

import java.text.ParseException;
import java.util.regex.Pattern;

import org.eclipse.scout.commons.CompareUtility;
import org.eclipse.scout.commons.StringUtility;

/**
 * <h3>{@link NamingUtility}</h3> ...
 * 
 * @author Andreas Hoegger
 * @since 1.0.8 24.11.2010
 */
public final class NamingUtility {

  private final static Pattern CAMEL_CASE_PATTERN = Pattern.compile("[^abcdefghijklmnopqrstuvwxyz0123456789]");

  private NamingUtility() {
  }

  public static String getSimpleName(String qualifiedName) {
    int i = qualifiedName.lastIndexOf('.');
    if (i >= 0) {
      return qualifiedName.substring(i + 1);
    }
    else {
      return qualifiedName;
    }
  }

  public static String getPackage(String qualifiedClassName) {
    int i = qualifiedClassName.lastIndexOf('.');
    if (i >= 0) {
      return qualifiedClassName.substring(0, i);
    }
    else {
      return qualifiedClassName;
    }
  }

  public static String parseJavaTypeName(String name, String text, String[] discouragedSuffixes) throws ParseException {
    if (text == null) text = "";
    if (text.length() <= 1) {
      return null;
    }
    else if (!Character.isJavaIdentifierStart(text.charAt(0))) {
      throw new ParseException(name + " must start with upper case A-Z", 0);
    }
    else if (!Character.isUpperCase(text.charAt(0))) {
      text = Character.toUpperCase(text.charAt(0)) + text.substring(1);
    }
    else {
      String textLow = text.toLowerCase();
      if (discouragedSuffixes != null) {
        for (int i = 0; i < discouragedSuffixes.length; i++) {
          if (textLow.endsWith(discouragedSuffixes[i].toLowerCase())) {
            throw new ParseException(name + " must not end with '" + discouragedSuffixes[i] + "'", 0);
          }
        }
      }
      for (int i = 1; i < text.length(); i++) {
        if (!Character.isJavaIdentifierPart(text.charAt(i))) {
          throw new ParseException("'" + text + "' is not a valid java name", 0);
        }
      }
    }
    // all checks ok
    return text;
  }

  public static String removeSuffixes(String s, String... suffixes) {
    return StringUtility.removeSuffixes(s, suffixes);
  }

  /**
   * lowercase java-bean name
   */
  public static String toVariableName(String javaName) {
    if (javaName == null || javaName.length() == 0) return null;
    return Character.toLowerCase(javaName.charAt(0)) + javaName.substring(1);
  }

  /**
   * uppercase java-bean name
   */
  public static String toBeanName(String javaName) {
    if (javaName == null || javaName.length() == 0) return null;
    return Character.toUpperCase(javaName.charAt(0)) + javaName.substring(1);
  }

  public static String toJavaCamelCase(String input) {
    return toJavaCamelCase(input, true);
  }

  /**
   * Method calculates the levenshtein distance, also known as string edit distance.
   * 
   * @param s1
   *          The first string.
   * @param s2
   *          The second string.
   * @return Amount of edit operations to transform s1 into s2.
   */
  public static int stringDistance(String s1, String s2) {
    if (s1 == null || s2 == null || CompareUtility.equals(s1, s2)) {
      return 0;
    }

    int l1 = s1.length();
    int l2 = s2.length();

    if (l1 == 0) {
      return l2;
    }
    else if (l2 == 0) {
      return l1;
    }

    int col0[] = new int[l1 + 1];
    int col1[] = new int[l1 + 1];
    int col[];

    // indexes into strings s1 and s2
    int i;
    int j;
    char jth;
    int cost;

    for (i = 0; i <= l1; i++) {
      col0[i] = i;
    }

    for (j = 1; j <= l2; j++) {
      jth = s2.charAt(j - 1);
      col1[0] = j;

      for (i = 1; i <= l1; i++) {
        cost = s1.charAt(i - 1) == jth ? 0 : 1;
        col1[i] = Math.min(Math.min(col1[i - 1] + 1, col0[i] + 1), col0[i - 1] + cost);
      }

      col = col0;
      col0 = col1;
      col1 = col;
    }

    return col0[l1];
  }

  /**
   * converts the given input string into a valid java camel case name.<br>
   * 
   * @param input
   * @param lowerCaseFirstToken
   *          if true, the first token uses lower case as e.g. used for method names.
   * @return the camel case string.
   */
  public static String toJavaCamelCase(String input, boolean lowerCaseFirstToken) {
    if (!StringUtility.hasText(input)) {
      return null;
    }
    StringBuilder camel = new StringBuilder(input.length());
    String[] tokens = CAMEL_CASE_PATTERN.split(input.toLowerCase());
    for (int i = 0; i < tokens.length; i++) {
      String t = tokens[i];
      if (StringUtility.hasText(t)) {
        if (i == 0 && lowerCaseFirstToken) {
          camel.append(t);
        }
        else {
          camel.append(Character.toUpperCase(t.charAt(0)));
          camel.append(t.substring(1));
        }
      }
    }
    return camel.toString();
  }
}