JavaIdentifierTransformer.java

/*
 * Copyright 2002-2009 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.sf.json.util;

import net.sf.json.JSONException;

import org.apache.commons.lang.StringUtils;

/**
 * Transforms a string into a valid Java identifier.<br>
 * There are five predefined strategies:
 * <ul>
 * <li>NOOP: does not perform transformation.</li>
 * <li>CAMEL_CASE: follows the camel case convention, deletes non
 * JavaIndentifierPart chars.</li>
 * <li>UNDERSCORE: transform whitespace and non JavaIdentifierPart chars to
 * '_'.</li>
 * <li>WHITESPACE: deletes whitespace and non JavaIdentifierPart chars.</li>
 * <li>STRICT: always throws a JSONException, does not perform transformation.</li>
 * </ul>
 * 
 * @author Andres Almiray <aalmiray@users.sourceforge.net>
 */
public abstract class JavaIdentifierTransformer {
   /** CamelCase transformer 'camel case' => 'camelCase' */
   public static final JavaIdentifierTransformer CAMEL_CASE = new CamelCaseJavaIdentifierTransformer();
   /** Noop transformer '@invalid' => '@invalid' */
   public static final JavaIdentifierTransformer NOOP = new NoopJavaIdentifierTransformer();
   /** Strict transformer '@invalid' => JSONException */
   public static final JavaIdentifierTransformer STRICT = new StrictJavaIdentifierTransformer();
   /** Underscore transformer 'under score' => 'under_score' */
   public static final JavaIdentifierTransformer UNDERSCORE = new UnderscoreJavaIdentifierTransformer();
   /** Whitespace transformer 'white space' => 'whitespace' */
   public static final JavaIdentifierTransformer WHITESPACE = new WhiteSpaceJavaIdentifierTransformer();

   public abstract String transformToJavaIdentifier( String str );

   /**
    * Removes all non JavaIdentifier chars from the start of the string.
    * 
    * @throws JSONException if the resulting string has zero length.
    */
   protected final String shaveOffNonJavaIdentifierStartChars( String str ) {
      String str2 = str;
      // shave off first char if not valid
      boolean ready = false;
      while( !ready ){
         if( !Character.isJavaIdentifierStart( str2.charAt( 0 ) ) ){
            str2 = str2.substring( 1 );
            if( str2.length() == 0 ){
               throw new JSONException( "Can't convert '" + str + "' to a valid Java identifier" );
            }
         }else{
            ready = true;
         }
      }
      return str2;
   }

   private static final class CamelCaseJavaIdentifierTransformer extends JavaIdentifierTransformer {
      public String transformToJavaIdentifier( String str ) {
         if( str == null ){
            return null;
         }

         String str2 = shaveOffNonJavaIdentifierStartChars( str );

         char[] chars = str2.toCharArray();
         int pos = 0;
         StringBuffer buf = new StringBuffer();
         boolean toUpperCaseNextChar = false;
         while( pos < chars.length ){
            if( !Character.isJavaIdentifierPart( chars[pos] )
                  || Character.isWhitespace( chars[pos] ) ){
               toUpperCaseNextChar = true;
            }else{
               if( toUpperCaseNextChar ){
                  buf.append( Character.toUpperCase( chars[pos] ) );
                  toUpperCaseNextChar = false;
               }else{
                  buf.append( chars[pos] );
               }
            }
            pos++;
         }
         return buf.toString();
      }
   }

   private static final class NoopJavaIdentifierTransformer extends JavaIdentifierTransformer {
      public String transformToJavaIdentifier( String str ) {
         return str;
      }
   }

   private static final class StrictJavaIdentifierTransformer extends JavaIdentifierTransformer {
      public String transformToJavaIdentifier( String str ) {
         throw new JSONException( "'" + str + "' is not a valid Java identifier." );
      }
   }
   private static final class UnderscoreJavaIdentifierTransformer extends JavaIdentifierTransformer {
      public String transformToJavaIdentifier( String str ) {
         if( str == null ){
            return null;
         }
         String str2 = shaveOffNonJavaIdentifierStartChars( str );

         char[] chars = str2.toCharArray();
         int pos = 0;
         StringBuffer buf = new StringBuffer();
         boolean toUnderScorePreviousChar = false;
         while( pos < chars.length ){
            if( !Character.isJavaIdentifierPart( chars[pos] )
                  || Character.isWhitespace( chars[pos] ) ){
               toUnderScorePreviousChar = true;
            }else{
               if( toUnderScorePreviousChar ){
                  buf.append( "_" );
                  toUnderScorePreviousChar = false;
               }
               buf.append( chars[pos] );
            }
            pos++;
         }
         if( buf.charAt( buf.length() - 1 ) == '_' ){
            buf.deleteCharAt( buf.length() - 1 );
         }
         return buf.toString();
      }
   }
   private static final class WhiteSpaceJavaIdentifierTransformer extends JavaIdentifierTransformer {
      public String transformToJavaIdentifier( String str ) {
         if( str == null ){
            return null;
         }
         String str2 = shaveOffNonJavaIdentifierStartChars( str );
         str2 = StringUtils.deleteWhitespace( str2 );
         char[] chars = str2.toCharArray();
         int pos = 0;
         StringBuffer buf = new StringBuffer();
         while( pos < chars.length ){
            if( Character.isJavaIdentifierPart( chars[pos] ) ){
               buf.append( chars[pos] );
            }
            pos++;
         }
         return buf.toString();
      }
   }
}