| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 org.apache.myfaces.buildtools.maven2.plugin.faces.util; |
| |
| import org.apache.myfaces.buildtools.maven2.plugin.faces.parse.PropertyBean; |
| |
| import java.io.File; |
| import java.util.Collections; |
| import java.util.Set; |
| import java.util.TreeSet; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| public class Util |
| { |
| static public String convertClassToSourcePath( |
| String className, |
| String fileExtension) |
| { |
| return (className.replace('.', File.separatorChar) + fileExtension); |
| } |
| |
| static public boolean isFullClass( |
| String className) |
| { |
| return (className != null && className.indexOf('.') != -1); |
| } |
| |
| public static String getGenericsFromProperty(PropertyBean property){ |
| String gen = ""; |
| for (int i = 0; i < property.getAttributeClassParameters().length; i++) { |
| if (i>0){ |
| gen += ","; |
| } |
| gen += getClassFromFullClass(property.getAttributeClassParameters()[i]); |
| } |
| return (gen.length() > 0?"<"+gen+">":gen); |
| } |
| |
| static public String getClassFromFullClass( |
| String fullClass) |
| { |
| if (fullClass == null) |
| return null; |
| |
| int lastSep = fullClass.lastIndexOf('.'); |
| // Note: this code also works for the empty package |
| return (fullClass.substring(lastSep + 1)); |
| } |
| |
| static public String getPackageFromFullClass( |
| String fullClass) |
| { |
| if (fullClass == null) |
| return null; |
| |
| int lastSep = fullClass.lastIndexOf('.'); |
| |
| // detect the empty package |
| if (lastSep == -1) |
| return ""; |
| |
| return (fullClass.substring(0, lastSep)); |
| } |
| |
| static public String getConstantNameFromProperty( |
| String propertyName) |
| { |
| return getConstantNameFromProperty(propertyName, null); |
| } |
| |
| static public String getConstantNameFromProperty( |
| String propertyName, |
| String constantSuffix) |
| { |
| StringBuffer constantName = new StringBuffer(); |
| |
| for (int i=0; i < propertyName.length(); i++) |
| { |
| char ch = propertyName.charAt(i); |
| if (i > 0 && |
| Character.isUpperCase(ch) && |
| Character.isLowerCase(propertyName.charAt(i-1))) |
| { |
| constantName.append('_'); |
| } |
| ch = Character.toUpperCase(ch); |
| constantName.append(ch); |
| } |
| |
| if (constantSuffix != null) |
| constantName.append(constantSuffix); |
| |
| return constantName.toString(); |
| } |
| |
| static public String getPrefixedPropertyName( |
| String prefix, |
| String propertyName) |
| { |
| return prefix + Character.toUpperCase(propertyName.charAt(0)) + |
| propertyName.substring(1); |
| } |
| |
| static public String getPropertyClass(PropertyBean property) |
| { |
| String propertyFullClass = property.getPropertyClass(); |
| String propertyClass = Util.getClassFromFullClass(propertyFullClass); |
| String[] genericTypes = property.getPropertyClassParameters(); |
| if(genericTypes != null && genericTypes.length > 0) |
| { |
| StringBuffer buffer = new StringBuffer(60); |
| buffer.append(propertyClass); |
| buffer.append('<'); |
| int max = genericTypes.length - 1; |
| for(int i = 0; i <= max; i++) |
| { |
| _buildPropertyClass(buffer, genericTypes[i]); |
| if(i < max) |
| { |
| buffer.append(", "); |
| } |
| } |
| buffer.append('>'); |
| |
| propertyClass = buffer.toString(); |
| } |
| |
| return propertyClass; |
| } |
| |
| static public String getMethodNameFromEvent( |
| String methodPrefix, |
| String eventName, |
| String methodSuffix) |
| { |
| return methodPrefix + |
| Character.toUpperCase(eventName.charAt(0)) + |
| eventName.substring(1) + |
| methodSuffix; |
| } |
| |
| static public String getMethodReaderFromProperty( |
| String propertyName, |
| String propertyClass) |
| { |
| String methodPrefix = ("boolean".equals(propertyClass) ? "is" : "get"); |
| return getPrefixedPropertyName(methodPrefix, propertyName); |
| } |
| |
| static public String getEventNameFromEventType( |
| String eventFullClass) |
| { |
| String eventName = getClassFromFullClass(eventFullClass); |
| return Character.toLowerCase(eventName.charAt(0)) + |
| eventName.substring(1, eventName.length()); |
| } |
| |
| static public boolean isPrimitiveClass( |
| String className) |
| { |
| return "boolean".equals(className) || |
| "byte".equals(className) || |
| "char".equals(className) || |
| "double".equals(className) || |
| "float".equals(className) || |
| "int".equals(className) || |
| "long".equals(className) || |
| "short".equals(className); |
| } |
| |
| static public String getAlternatePropertyClass(PropertyBean property) |
| { |
| StringBuffer buffer = new StringBuffer(60); |
| _buildPropertyClass(buffer, property.getAlternateClass()); |
| |
| return buffer.toString(); |
| } |
| |
| static public String getPrimitiveType(String className){ |
| if (className.startsWith("java.lang.")) |
| { |
| className = className.replace("java.lang.", ""); |
| } |
| |
| if (className.endsWith("eger")) |
| { |
| className = className.replace("eger", ""); |
| } |
| |
| if (Util.isPrimitiveClass(className.toLowerCase())) |
| { |
| return className.toLowerCase(); |
| }else |
| { |
| return null; |
| } |
| |
| } |
| |
| static public String getBoxedClass( |
| String className) |
| { |
| if ("boolean".equals(className)) |
| return "Boolean"; |
| else if ("byte".equals(className)) |
| return "Byte"; |
| else if ("char".equals(className)) |
| return "Character"; |
| else if ("double".equals(className)) |
| return "Double"; |
| else if ("float".equals(className)) |
| return "Float"; |
| else if ("int".equals(className)) |
| return "Integer"; |
| else if ("long".equals(className)) |
| return "Long"; |
| else if ("short".equals(className)) |
| return "Short"; |
| else |
| return className; |
| } |
| |
| static public String primitiveDefaultValue(String className) |
| { |
| if ("boolean".equals(className)) |
| return "false"; |
| else if ("byte".equals(className)) |
| return "0"; |
| else if ("char".equals(className)) |
| return "''"; |
| else if ("double".equals(className)) |
| return "0.0d"; |
| else if ("float".equals(className)) |
| return "0.0f"; |
| else if ("int".equals(className)) |
| return "0"; |
| else if ("long".equals(className)) |
| return "0L"; |
| else if ("short".equals(className)) |
| return "0"; |
| else |
| return className; |
| } |
| |
| static public String fill( |
| String base, |
| int length) |
| { |
| if (base == null || base.length() > length) |
| return base; |
| |
| StringBuffer filled = new StringBuffer(base); |
| for (int i=base.length(); i < length; i++) |
| { |
| filled.append(' '); |
| } |
| return filled.toString(); |
| } |
| |
| static public String getVariableFromClass( |
| String className) |
| { |
| if (className == null) |
| return null; |
| |
| for (int i=0; i < className.length(); i++) |
| { |
| char ch = className.charAt(i); |
| if (Character.isLowerCase(ch)) |
| { |
| if (i > 0) |
| { |
| return Character.toLowerCase(className.charAt(i - 1)) + |
| className.substring(i); |
| } |
| break; |
| } |
| } |
| |
| throw new IllegalStateException("Class name \"" + className + |
| "\" does not use initcaps"); |
| } |
| |
| static public String getVariableFromName( |
| String name) |
| { |
| if (name == null) |
| return null; |
| |
| if (RESERVED_WORDS.contains(name)) |
| name = name + "Param"; |
| |
| return name; |
| } |
| |
| static public String convertStringToLiteral(String value) |
| { |
| return convertStringToLiteral("String", value); |
| } |
| |
| static public String convertStringToLiteral(String className, String value) |
| { |
| if (value == null) |
| { |
| return null; |
| } |
| else if ("String".equals(className)) |
| { |
| return "\"" + value.replaceAll("\'", "\\'") + "\""; |
| } |
| else if ("Number".equals(className)) |
| { |
| // Double vs. Integer. |
| if(value.indexOf(".") == -1) |
| { |
| return "Integer.valueOf(" + value + ")"; |
| } |
| else |
| { |
| return "Double.valueOf(" + value + ")"; |
| } |
| } |
| else |
| { |
| return value; |
| } |
| } |
| |
| static public String getDefaultValue(PropertyBean property){ |
| String propertyFullClass = property.getPropertyClass(); |
| String def = property.getDefaultValue(); |
| if (def == null || def.length() == 0){ |
| return null; |
| } |
| if (isPrimitiveClass(propertyFullClass)){ |
| return def; |
| } else if ("java.lang.String".equals(propertyFullClass)){ |
| if (def.startsWith("\"") && def.endsWith("\"")){ |
| return def; |
| } else { |
| return "\""+def+"\""; |
| } |
| }else{ |
| //Any other class, so we return the default value |
| return def; |
| } |
| } |
| |
| static private void _buildPropertyClass(StringBuffer buffer, String type) |
| { |
| Matcher matcher = _GENERIC_TYPE.matcher(type); |
| if(matcher.matches()) |
| { |
| // Generic type |
| buffer.append(Util.getClassFromFullClass(matcher.group(1))); |
| buffer.append('<'); |
| String[] types = matcher.group(2).split(","); |
| int max = types.length - 1; |
| for(int i = 0; i <= max; i++) |
| { |
| _buildPropertyClass(buffer, types[i]); |
| if(i < max) |
| { |
| buffer.append(", "); |
| } |
| } |
| buffer.append('>'); |
| } |
| else |
| { |
| // Non-generic type |
| buffer.append(Util.getClassFromFullClass(type)); |
| } |
| } |
| |
| static private Set _createPrimitiveTypesSet() |
| { |
| Set primitives = new TreeSet(); |
| for (int i=0; i < _PRIMITIVE_TYPES.length; i++) |
| { |
| String type = _PRIMITIVE_TYPES[i]; |
| primitives.add(type); |
| primitives.add(type + "[]"); |
| } |
| return Collections.unmodifiableSet(primitives); |
| } |
| |
| static private Set _createReservedWordsSet() |
| { |
| Set reserved = new TreeSet(); |
| for (int i=0; i < _RESERVED_WORDS.length; i++) |
| { |
| String keyword = _RESERVED_WORDS[i]; |
| reserved.add(keyword); |
| } |
| return Collections.unmodifiableSet(reserved); |
| } |
| |
| static private final String[] _PRIMITIVE_TYPES = new String[] |
| {// TODO: Shouldn't java.lang.* be specified in that list as well? |
| "boolean", |
| "byte", |
| "char", |
| "float", |
| "double", |
| "int", |
| "short", |
| "long", |
| }; |
| |
| static private final String[] _RESERVED_WORDS = new String[] |
| { |
| "abstract", |
| "assert", |
| "boolean", |
| "break", |
| "byte", |
| "case", |
| "catch", |
| "char", |
| "class", |
| "const", |
| "continue", |
| "default", |
| "do", |
| "double", |
| "else", |
| "extends", |
| "final", |
| "finally", |
| "float", |
| "for", |
| "goto", |
| "if", |
| "implements", |
| "import", |
| "instanceof", |
| "int", |
| "interface", |
| "long", |
| "native", |
| "new", |
| "package", |
| "private", |
| "protected", |
| "public", |
| "return", |
| "short", |
| "static", |
| "super", |
| "switch", |
| "synchronized", |
| "this", |
| "throw", |
| "throws", |
| "transient", |
| "try", |
| "void", |
| "volatile", |
| "while", |
| }; |
| |
| static public final Set RESERVED_WORDS = _createReservedWordsSet(); |
| static public final Set PRIMITIVE_TYPES = _createPrimitiveTypesSet(); |
| |
| static private final Pattern _GENERIC_TYPE = Pattern.compile("([^<]+)<(.+)>"); |
| |
| // no instances |
| private Util() |
| { |
| } |
| } |