| /* | |
| * 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.tools; | |
| import com.google.gwt.i18n.client.Constants; | |
| import com.google.gwt.i18n.client.ConstantsWithLookup; | |
| import com.google.gwt.i18n.client.Localizable; | |
| import com.google.gwt.i18n.client.Messages; | |
| import com.google.gwt.i18n.rebind.AbstractLocalizableInterfaceCreator; | |
| import com.google.gwt.i18n.rebind.ConstantsInterfaceCreator; | |
| import com.google.gwt.i18n.rebind.MessagesInterfaceCreator; | |
| import com.google.gwt.util.tools.ArgHandlerExtra; | |
| import com.google.gwt.util.tools.ArgHandlerString; | |
| import com.google.gwt.util.tools.ToolBase; | |
| import java.io.File; | |
| import java.io.FileNotFoundException; | |
| import java.io.IOException; | |
| import java.net.URL; | |
| import java.net.URLDecoder; | |
| /** | |
| * Common public access point for localization support methods. | |
| */ | |
| public class I18NSync extends ToolBase { | |
| private class classNameArgHandler extends ArgHandlerExtra { | |
| @Override | |
| public boolean addExtraArg(String str) { | |
| if (classNameArg != null) { | |
| System.err.println("Too many arguments."); | |
| return false; | |
| } | |
| // We wish to use the same sets of checks for validity whether the user | |
| // calls the static method to create localizable fields or uses the | |
| // command line, as the java call must throw IOException, here we must | |
| // catch it and convert it to a System.err message. | |
| try { | |
| File resourceFile = urlToResourceFile(str); | |
| checkValidResourceInputFile(resourceFile); | |
| classNameArg = str; | |
| } catch (IOException e) { | |
| System.err.println("Error: " + e.getMessage()); | |
| return false; | |
| } | |
| return true; | |
| } | |
| @Override | |
| public String getPurpose() { | |
| return "Identifies the Constants/Messages class to be created. For example com.google.sample.i18n.client.Colors"; | |
| } | |
| @Override | |
| public String[] getTagArgs() { | |
| String[] interfaceArg = {"name of the Constants/Messages interface to create"}; | |
| return interfaceArg; | |
| } | |
| @Override | |
| public boolean isRequired() { | |
| return true; | |
| } | |
| } | |
| private class outDirHandler extends ArgHandlerString { | |
| @Override | |
| public String getPurpose() { | |
| return "Java source directory, defaults to the resource's class path."; | |
| } | |
| @Override | |
| public String getTag() { | |
| return "-out"; | |
| } | |
| @Override | |
| public String[] getTagArgs() { | |
| String[] resourceArgs = {"fileName"}; | |
| return resourceArgs; | |
| } | |
| @Override | |
| public boolean isRequired() { | |
| return false; | |
| } | |
| @Override | |
| public boolean setString(String str) { | |
| // We wish to use the same sets of checks for validity whether the user | |
| // calls the static method to create localizable classes or uses the | |
| // command line, as the java call must throw IOException, here we must | |
| // catch it and convert it to a System.err message. | |
| outDirArg = new File(str); | |
| try { | |
| checkValidSourceDir(outDirArg); | |
| } catch (IOException e) { | |
| System.err.println("Error: " + e.getMessage()); | |
| return false; | |
| } | |
| return true; | |
| } | |
| } | |
| /** | |
| * Creates a <code>Constants</code> interface from a class name. The | |
| * resource file needed to create the class must be on your class path. | |
| * | |
| * @param className the name of the Constants class to be created | |
| * @param outDir source dir root | |
| * @throws IOException | |
| */ | |
| public static void createConstantsInterfaceFromClassName(String className, | |
| File outDir) throws IOException { | |
| createConstantsInterfaceFromClassName(className, outDir, Constants.class); | |
| } | |
| /** | |
| * Creates a <code>ConstantsWithLookup</code> interface from a class name. | |
| * The resource file needed to create the class must be on your class path. | |
| * | |
| * @param className the name of the Constants class to be created | |
| * @throws IOException | |
| */ | |
| public static void createConstantsWithLookupInterfaceFromClassName( | |
| String className) throws IOException { | |
| createConstantsInterfaceFromClassName(className, null, | |
| ConstantsWithLookup.class); | |
| } | |
| /** | |
| * Creates a <code>ConstantsWithLookup</code> interface from a class name. | |
| * The resource file needed to create the class must be on your class path. | |
| * | |
| * @param className the name of the Constants class to be created | |
| * @param sourceDir source dir root | |
| * @throws IOException | |
| */ | |
| public static void createConstantsWithLookupInterfaceFromClassName( | |
| String className, File sourceDir) throws IOException { | |
| createConstantsInterfaceFromClassName(className, sourceDir, | |
| ConstantsWithLookup.class); | |
| } | |
| /** | |
| * Creates one of a Messages, ConstantsWithLookup, or Constants subclass. | |
| * | |
| * @param className Name of the subclass to be created | |
| * @param sourceDir source directory root | |
| * @param interfaceType What kind of base class to use | |
| * @throws IOException | |
| */ | |
| public static void createInterfaceFromClassName(String className, | |
| File sourceDir, Class<? extends Localizable> interfaceType) | |
| throws IOException { | |
| if (interfaceType == Messages.class) { | |
| createMessagesInterfaceFromClassName(className, sourceDir); | |
| } else { | |
| if (!Constants.class.isAssignableFrom(interfaceType)) { | |
| throw new RuntimeException( | |
| "Internal Error: Unable to create i18n class derived from " + | |
| interfaceType.getName()); | |
| } | |
| createConstantsInterfaceFromClassName(className, sourceDir, | |
| interfaceType.asSubclass(Constants.class)); | |
| } | |
| } | |
| /** | |
| * Creates a <code>Messages</code> interface from a class name. The resource | |
| * file needed to create the class must be on your class path. | |
| * | |
| * @param className the name of the Constants class to be created | |
| * @throws IOException | |
| */ | |
| public static void createMessagesInterfaceFromClassName(String className) | |
| throws IOException { | |
| createMessagesInterfaceFromClassName(className, null); | |
| } | |
| /** | |
| * Creates a <code>Messages</code> interface from a class name. The resource | |
| * file needed to create the class must be on your class path. | |
| * | |
| * @param className the name of the Constants class to be created | |
| * @param sourceDir source directory root | |
| * @throws IOException | |
| */ | |
| public static void createMessagesInterfaceFromClassName(String className, | |
| File sourceDir) throws IOException { | |
| File resource = urlToResourceFile(className); | |
| File source; | |
| if (sourceDir == null) { | |
| source = synthesizeSourceFile(resource); | |
| } else { | |
| checkValidSourceDir(sourceDir); | |
| String sourcePath = className.replace('.', File.separatorChar); | |
| sourcePath = sourceDir.getCanonicalFile() + File.separator + sourcePath | |
| + ".java"; | |
| source = new File(sourcePath); | |
| } | |
| // Need both source path and class name for this check | |
| checkValidJavaSourceOutputFile(source); | |
| checkValidResourceInputFile(resource); | |
| int classDiv = className.lastIndexOf("."); | |
| String packageName = className.substring(0, classDiv); | |
| String name = className.substring(classDiv + 1); | |
| AbstractLocalizableInterfaceCreator creator = new MessagesInterfaceCreator( | |
| name, packageName, resource, source); | |
| creator.generate(); | |
| } | |
| /** | |
| * Creates Messages and Constants java source files. | |
| * | |
| * @param args arguments for generation | |
| */ | |
| public static void main(String[] args) { | |
| I18NSync creator = new I18NSync(); | |
| if (creator.processArgs(args)) { | |
| if (creator.run()) { | |
| return; | |
| } | |
| } | |
| System.exit(1); | |
| } | |
| static void checkValidJavaSourceOutputFile(File targetSource) | |
| throws IOException { | |
| if (targetSource.isDirectory()) { | |
| throw new IOException("Output file'" + targetSource | |
| + "' exists and is a directory; cannot overwrite"); | |
| } | |
| if (targetSource.getParentFile().isDirectory() == false) { | |
| throw new IOException("The target source's directory '" | |
| + targetSource.getParent() + "' must be an existing directory"); | |
| } | |
| } | |
| static void checkValidResourceInputFile(File resource) throws IOException { | |
| if (!resource.getPath().endsWith(".properties")) { | |
| throw new IOException("Properties files " + resource | |
| + " should end with '.properties'"); | |
| } | |
| if (!resource.exists() || !resource.isFile()) { | |
| throw new IOException("Properties file not found: " + resource); | |
| } | |
| } | |
| private static void checkValidSourceDir(File outDir) throws IOException { | |
| if (outDir.isDirectory() == false) { | |
| throw new IOException(outDir | |
| + " must be an existing directory. Current path is " | |
| + new File(".").getCanonicalPath()); | |
| } | |
| } | |
| private static void createConstantsInterfaceFromClassName(String className, | |
| File sourceDir, Class<? extends Constants> interfaceClass) | |
| throws IOException { | |
| File resource = urlToResourceFile(className); | |
| File source; | |
| if (sourceDir == null) { | |
| source = synthesizeSourceFile(resource); | |
| } else { | |
| checkValidSourceDir(sourceDir); | |
| String sourcePath = className.replace('.', File.separatorChar); | |
| sourcePath = sourceDir.getCanonicalFile() + File.separator + sourcePath | |
| + ".java"; | |
| source = new File(sourcePath); | |
| } | |
| // Need both source path and class name for this check | |
| checkValidJavaSourceOutputFile(source); | |
| checkValidResourceInputFile(resource); | |
| int classDiv = className.lastIndexOf("."); | |
| String packageName = className.substring(0, classDiv); | |
| String name = className.substring(classDiv + 1); | |
| AbstractLocalizableInterfaceCreator creator = new ConstantsInterfaceCreator( | |
| name, packageName, resource, source, interfaceClass); | |
| creator.generate(); | |
| } | |
| private static File synthesizeSourceFile(File resource) { | |
| String javaPath = resource.getName(); | |
| javaPath = javaPath.substring(0, javaPath.lastIndexOf(".")); | |
| javaPath = resource.getParentFile().getPath() + File.separator + javaPath | |
| + ".java"; | |
| File targetClassFile = new File(javaPath); | |
| return targetClassFile; | |
| } | |
| private static File urlToResourceFile(String className) | |
| throws IOException { | |
| if (className.endsWith(".java") || className.endsWith(".properties") | |
| || className.endsWith(".class") | |
| || className.indexOf(File.separator) > 0) { | |
| throw new IllegalArgumentException( | |
| "class '" | |
| + className | |
| + "'should not contain an extension. \"com.google.gwt.SomeClass\" is an example of a correctly formed class string"); | |
| } | |
| String resourcePath = className.replace('.', '/') + ".properties"; | |
| ClassLoader cl = Thread.currentThread().getContextClassLoader(); | |
| if (cl == null) { | |
| cl = ClassLoader.getSystemClassLoader(); | |
| } | |
| URL r = cl.getResource(resourcePath); | |
| if (r == null) { | |
| throw new FileNotFoundException("Could not find the resource '" | |
| + resourcePath + " matching '" + className | |
| + "' did you remember to add it to your classpath?"); | |
| } | |
| File resourceFile = new File(URLDecoder.decode(r.getPath(), "utf-8")); | |
| return resourceFile; | |
| } | |
| private ArgHandlerValueChooser chooser; | |
| private String classNameArg; | |
| private File outDirArg; | |
| private I18NSync() { | |
| registerHandler(new classNameArgHandler()); | |
| registerHandler(new outDirHandler()); | |
| chooser = new ArgHandlerValueChooser(); | |
| registerHandler(chooser.getConstantsWithLookupArgHandler()); | |
| registerHandler(chooser.getMessagesArgHandler()); | |
| } | |
| /** | |
| * Creates the interface. | |
| * | |
| * @return whether the interface was created | |
| */ | |
| protected boolean run() { | |
| try { | |
| createInterfaceFromClassName(classNameArg, outDirArg, | |
| chooser.getArgValue()); | |
| return true; | |
| } catch (Throwable e) { | |
| System.err.println(e.getMessage()); | |
| return false; | |
| } | |
| } | |
| } |