| /* | |
| * Copyright 2008 Google Inc. | |
| * | |
| * 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 com.google.gwt.i18n.rebind; | |
| import com.google.gwt.dev.util.Util; | |
| import com.google.gwt.dev.util.log.PrintWriterTreeLogger; | |
| import com.google.gwt.i18n.client.Localizable; | |
| import com.google.gwt.user.rebind.ClassSourceFileComposerFactory; | |
| import com.google.gwt.user.rebind.SourceWriter; | |
| import org.apache.tapestry.util.text.LocalizedProperties; | |
| import java.io.File; | |
| import java.io.FileInputStream; | |
| import java.io.FileNotFoundException; | |
| import java.io.FileOutputStream; | |
| import java.io.IOException; | |
| import java.io.InputStream; | |
| import java.io.OutputStreamWriter; | |
| import java.io.PrintWriter; | |
| import java.io.Writer; | |
| import java.util.ArrayList; | |
| import java.util.Arrays; | |
| import java.util.HashSet; | |
| import java.util.List; | |
| import java.util.Set; | |
| /** | |
| * Abstract base functionality for <code>MessagesInterfaceCreator</code> and | |
| * <code>ConstantsInterfaceCreator</code>. | |
| */ | |
| public abstract class AbstractLocalizableInterfaceCreator { | |
| private static class RenameDuplicates extends ResourceKeyFormatter { | |
| private Set<String> methodNames = new HashSet<String>(); | |
| @Override | |
| public String format(String key) { | |
| while (methodNames.contains(key)) { | |
| key += "_dup"; | |
| } | |
| methodNames.add(key); | |
| return key; | |
| } | |
| } | |
| private static class ReplaceBadChars extends ResourceKeyFormatter { | |
| @Override | |
| public String format(String key) { | |
| StringBuilder buf = new StringBuilder(); | |
| int keyLen = key == null ? 0 : key.length(); | |
| for (int i = 0; i < keyLen; i = key.offsetByCodePoints(i, 1)) { | |
| int codePoint = key.codePointAt(i); | |
| if (i == 0 ? Character.isJavaIdentifierStart(codePoint) | |
| : Character.isJavaIdentifierPart(codePoint)) { | |
| buf.appendCodePoint(codePoint); | |
| } else { | |
| buf.append('_'); | |
| } | |
| } | |
| if (buf.length() == 0) { | |
| buf.append('_'); | |
| } | |
| return buf.toString(); | |
| } | |
| } | |
| private abstract static class ResourceKeyFormatter { | |
| public abstract String format(String key); | |
| } | |
| /** | |
| * Index into this array using a nibble, 4 bits, to get the corresponding | |
| * hexadecimal character representation. | |
| */ | |
| private static final char NIBBLE_TO_HEX_CHAR[] = { | |
| '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', | |
| 'E', 'F'}; | |
| private static boolean needsUnicodeEscape(char ch) { | |
| if (ch == ' ') { | |
| return false; | |
| } | |
| switch (Character.getType(ch)) { | |
| case Character.COMBINING_SPACING_MARK: | |
| case Character.ENCLOSING_MARK: | |
| case Character.NON_SPACING_MARK: | |
| case Character.UNASSIGNED: | |
| case Character.PRIVATE_USE: | |
| case Character.SPACE_SEPARATOR: | |
| case Character.CONTROL: | |
| case Character.LINE_SEPARATOR: | |
| case Character.FORMAT: | |
| case Character.PARAGRAPH_SEPARATOR: | |
| case Character.SURROGATE: | |
| return true; | |
| default: | |
| break; | |
| } | |
| return false; | |
| } | |
| private static void unicodeEscape(char ch, StringBuilder buf) { | |
| buf.append('\\'); | |
| buf.append('u'); | |
| buf.append(NIBBLE_TO_HEX_CHAR[(ch >> 12) & 0x0F]); | |
| buf.append(NIBBLE_TO_HEX_CHAR[(ch >> 8) & 0x0F]); | |
| buf.append(NIBBLE_TO_HEX_CHAR[(ch >> 4) & 0x0F]); | |
| buf.append(NIBBLE_TO_HEX_CHAR[ch & 0x0F]); | |
| } | |
| /** | |
| * Composer for the current Constant. | |
| */ | |
| protected SourceWriter composer; | |
| private List<ResourceKeyFormatter> formatters = new ArrayList<ResourceKeyFormatter>(); | |
| private File resourceFile; | |
| private File sourceFile; | |
| private PrintWriter writer; | |
| /** | |
| * Creates a new constants creator. | |
| * | |
| * @param className constant class to create | |
| * @param packageName package to create it in | |
| * @param resourceBundle resource bundle with value | |
| * @param targetLocation | |
| * @throws IOException | |
| */ | |
| public AbstractLocalizableInterfaceCreator(String className, | |
| String packageName, File resourceBundle, File targetLocation, | |
| Class<? extends Localizable> interfaceClass) throws IOException { | |
| setup(packageName, className, resourceBundle, targetLocation, | |
| interfaceClass); | |
| } | |
| /** | |
| * Generate class. | |
| * | |
| * @throws FileNotFoundException | |
| * @throws IOException | |
| */ | |
| public void generate() throws FileNotFoundException, IOException { | |
| try { | |
| try { | |
| // right now, only property files are legal | |
| generateFromPropertiesFile(); | |
| } finally { | |
| writer.close(); | |
| } | |
| } catch (IOException e) { | |
| sourceFile.delete(); | |
| throw e; | |
| } catch (RuntimeException e) { | |
| sourceFile.delete(); | |
| throw e; | |
| } | |
| } | |
| /** | |
| * Create a String method declaration from a Dictionary/value pair. | |
| * | |
| * @param key Dictionary | |
| * @param defaultValue default value | |
| */ | |
| public void genSimpleMethodDecl(String key, String defaultValue) { | |
| genMethodDecl("String", defaultValue, key); | |
| } | |
| /** | |
| * Create method args based upon the default value. | |
| * | |
| * @param defaultValue | |
| */ | |
| protected abstract void genMethodArgs(String defaultValue); | |
| /** | |
| * Create an annotation to hold the default value. | |
| */ | |
| protected abstract void genValueAnnotation(String defaultValue); | |
| /** | |
| * Returns the javaDocComment for the class. | |
| * | |
| * @param path path of class | |
| * @return java doc comment | |
| */ | |
| protected abstract String javaDocComment(String path); | |
| protected String makeJavaString(String value) { | |
| StringBuilder buf = new StringBuilder(); | |
| buf.append('\"'); | |
| for (int i = 0; i < value.length(); ++i) { | |
| char c = value.charAt(i); | |
| switch (c) { | |
| case '\r': | |
| buf.append("\\r"); | |
| break; | |
| case '\n': | |
| buf.append("\\n"); | |
| break; | |
| case '\"': | |
| buf.append("\\\""); | |
| break; | |
| default: | |
| if (needsUnicodeEscape(c)) { | |
| unicodeEscape(c, buf); | |
| } else { | |
| buf.append(c); | |
| } | |
| break; | |
| } | |
| } | |
| buf.append('\"'); | |
| return buf.toString(); | |
| } | |
| @SuppressWarnings("unchecked") | |
| // use of raw type from LocalizedProperties | |
| void generateFromPropertiesFile() throws IOException { | |
| InputStream propStream = new FileInputStream(resourceFile); | |
| LocalizedProperties p = new LocalizedProperties(); | |
| p.load(propStream, Util.DEFAULT_ENCODING); | |
| addFormatters(); | |
| // TODO: Look for a generic version of Tapestry's LocalizedProperties class | |
| Set<String> keySet = p.getPropertyMap().keySet(); | |
| // sort keys for deterministic results | |
| String[] keys = keySet.toArray(new String[keySet.size()]); | |
| Arrays.sort(keys); | |
| if (keys.length == 0) { | |
| throw new IllegalStateException( | |
| "File '" | |
| + resourceFile | |
| + "' cannot be used to generate message classes, as it has no key/value pairs defined."); | |
| } | |
| for (String key : keys) { | |
| String value = p.getProperty(key); | |
| genSimpleMethodDecl(key, value); | |
| } | |
| composer.commit(new PrintWriterTreeLogger()); | |
| } | |
| private void addFormatters() { | |
| // For now, we completely control property key formatters. | |
| formatters.add(new ReplaceBadChars()); | |
| // Rename Duplicates must always come last. | |
| formatters.add(new RenameDuplicates()); | |
| } | |
| private String formatKey(String key) { | |
| for (ResourceKeyFormatter formatter : formatters) { | |
| key = formatter.format(key); | |
| } | |
| return key; | |
| } | |
| private void genMethodDecl(String type, String defaultValue, String key) { | |
| composer.beginJavaDocComment(); | |
| String escaped = makeJavaString(defaultValue); | |
| composer.println("Translated " + escaped + ".\n"); | |
| composer.print("@return translated " + escaped); | |
| composer.endJavaDocComment(); | |
| genValueAnnotation(defaultValue); | |
| composer.println("@Key(" + makeJavaString(key) + ")"); | |
| String methodName = formatKey(key); | |
| composer.print(type + " " + methodName); | |
| composer.print("("); | |
| genMethodArgs(defaultValue); | |
| composer.print(");\n"); | |
| } | |
| private void setup(String packageName, String className, File resourceBundle, | |
| File targetLocation, Class<? extends Localizable> interfaceClass) | |
| throws IOException { | |
| ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory( | |
| packageName, className); | |
| factory.makeInterface(); | |
| // TODO(jat): need a way to add an @GeneratedFrom annotation. | |
| factory.setJavaDocCommentForClass(javaDocComment(resourceBundle.getCanonicalPath().replace( | |
| File.separatorChar, '/'))); | |
| factory.addImplementedInterface(interfaceClass.getName()); | |
| FileOutputStream file = new FileOutputStream(targetLocation); | |
| Writer underlying = new OutputStreamWriter(file, Util.DEFAULT_ENCODING); | |
| writer = new PrintWriter(underlying); | |
| composer = factory.createSourceWriter(writer); | |
| resourceFile = resourceBundle; | |
| sourceFile = targetLocation; | |
| } | |
| } |