Coverage Report

 /*
  * 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();
       }
    }
 }

1		/*
2		* Copyright 2002-2009 the original author or authors.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17		package net.sf.json.util;
18
19		import net.sf.json.JSONException;
20
21		import org.apache.commons.lang.StringUtils;
22
23		/**
24		* Transforms a string into a valid Java identifier.<br>
25		* There are five predefined strategies:
26		* <ul>
27		* <li>NOOP: does not perform transformation.</li>
28		* <li>CAMEL_CASE: follows the camel case convention, deletes non
29		* JavaIndentifierPart chars.</li>
30		* <li>UNDERSCORE: transform whitespace and non JavaIdentifierPart chars to
31		* '_'.</li>
32		* <li>WHITESPACE: deletes whitespace and non JavaIdentifierPart chars.</li>
33		* <li>STRICT: always throws a JSONException, does not perform transformation.</li>
34		* </ul>
35		*
36		* @author Andres Almiray <aalmiray@users.sourceforge.net>
37		*/
38	0	public abstract class JavaIdentifierTransformer {
39		/** CamelCase transformer 'camel case' => 'camelCase' */
40	0	public static final JavaIdentifierTransformer CAMEL_CASE = new CamelCaseJavaIdentifierTransformer();
41		/** Noop transformer '@invalid' => '@invalid' */
42	0	public static final JavaIdentifierTransformer NOOP = new NoopJavaIdentifierTransformer();
43		/** Strict transformer '@invalid' => JSONException */
44	0	public static final JavaIdentifierTransformer STRICT = new StrictJavaIdentifierTransformer();
45		/** Underscore transformer 'under score' => 'under_score' */
46	0	public static final JavaIdentifierTransformer UNDERSCORE = new UnderscoreJavaIdentifierTransformer();
47		/** Whitespace transformer 'white space' => 'whitespace' */
48	0	public static final JavaIdentifierTransformer WHITESPACE = new WhiteSpaceJavaIdentifierTransformer();
49
50		public abstract String transformToJavaIdentifier( String str );
51
52		/**
53		* Removes all non JavaIdentifier chars from the start of the string.
54		*
55		* @throws JSONException if the resulting string has zero length.
56		*/
57		protected final String shaveOffNonJavaIdentifierStartChars( String str ) {
58	0	String str2 = str;
59		// shave off first char if not valid
60	0	boolean ready = false;
61	0	while( !ready ){
62	0	if( !Character.isJavaIdentifierStart( str2.charAt( 0 ) ) ){
63	0	str2 = str2.substring( 1 );
64	0	if( str2.length() == 0 ){
65	0	throw new JSONException( "Can't convert '" + str + "' to a valid Java identifier" );
66		}
67		}else{
68	0	ready = true;
69		}
70		}
71	0	return str2;
72		}
73
74	0	private static final class CamelCaseJavaIdentifierTransformer extends JavaIdentifierTransformer {
75		public String transformToJavaIdentifier( String str ) {
76	0	if( str == null ){
77	0	return null;
78		}
79
80	0	String str2 = shaveOffNonJavaIdentifierStartChars( str );
81
82	0	char[] chars = str2.toCharArray();
83	0	int pos = 0;
84	0	StringBuffer buf = new StringBuffer();
85	0	boolean toUpperCaseNextChar = false;
86	0	while( pos < chars.length ){
87	0	if( !Character.isJavaIdentifierPart( chars[pos] )
88		\|\| Character.isWhitespace( chars[pos] ) ){
89	0	toUpperCaseNextChar = true;
90		}else{
91	0	if( toUpperCaseNextChar ){
92	0	buf.append( Character.toUpperCase( chars[pos] ) );
93	0	toUpperCaseNextChar = false;
94		}else{
95	0	buf.append( chars[pos] );
96		}
97		}
98	0	pos++;
99		}
100	0	return buf.toString();
101		}
102		}
103
104	0	private static final class NoopJavaIdentifierTransformer extends JavaIdentifierTransformer {
105		public String transformToJavaIdentifier( String str ) {
106	0	return str;
107		}
108		}
109
110	0	private static final class StrictJavaIdentifierTransformer extends JavaIdentifierTransformer {
111		public String transformToJavaIdentifier( String str ) {
112	0	throw new JSONException( "'" + str + "' is not a valid Java identifier." );
113		}
114		}
115	0	private static final class UnderscoreJavaIdentifierTransformer extends JavaIdentifierTransformer {
116		public String transformToJavaIdentifier( String str ) {
117	0	if( str == null ){
118	0	return null;
119		}
120	0	String str2 = shaveOffNonJavaIdentifierStartChars( str );
121
122	0	char[] chars = str2.toCharArray();
123	0	int pos = 0;
124	0	StringBuffer buf = new StringBuffer();
125	0	boolean toUnderScorePreviousChar = false;
126	0	while( pos < chars.length ){
127	0	if( !Character.isJavaIdentifierPart( chars[pos] )
128		\|\| Character.isWhitespace( chars[pos] ) ){
129	0	toUnderScorePreviousChar = true;
130		}else{
131	0	if( toUnderScorePreviousChar ){
132	0	buf.append( "_" );
133	0	toUnderScorePreviousChar = false;
134		}
135	0	buf.append( chars[pos] );
136		}
137	0	pos++;
138		}
139	0	if( buf.charAt( buf.length() - 1 ) == '_' ){
140	0	buf.deleteCharAt( buf.length() - 1 );
141		}
142	0	return buf.toString();
143		}
144		}
145	0	private static final class WhiteSpaceJavaIdentifierTransformer extends JavaIdentifierTransformer {
146		public String transformToJavaIdentifier( String str ) {
147	0	if( str == null ){
148	0	return null;
149		}
150	0	String str2 = shaveOffNonJavaIdentifierStartChars( str );
151	0	str2 = StringUtils.deleteWhitespace( str2 );
152	0	char[] chars = str2.toCharArray();
153	0	int pos = 0;
154	0	StringBuffer buf = new StringBuffer();
155	0	while( pos < chars.length ){
156	0	if( Character.isJavaIdentifierPart( chars[pos] ) ){
157	0	buf.append( chars[pos] );
158		}
159	0	pos++;
160		}
161	0	return buf.toString();
162		}
163		}
164		}