/*
* CommandBundleGenerator.java
*
* Copyright (C) 2009-12 by RStudio, Inc.
*
* Unless you have received this program directly from RStudio pursuant
* to the terms of a commercial license agreement with RStudio, then
* this program is licensed to you under the terms of version 3 of the
* GNU Affero General Public License. This program is distributed WITHOUT
* ANY EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT,
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the
* AGPL (http://www.gnu.org/licenses/agpl-3.0.txt) for more details.
*
*/
package org.rstudio.core.rebind.command;
import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.dev.resource.Resource;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
/**
* This generator runs at compile time (like all GWT Generators) and creates
* implementations for any subinterfaces of CommandBundle that are found in
* client code.
*/
public class CommandBundleGenerator extends Generator
{
@Override
public String generate(TreeLogger logger,
GeneratorContext context,
String typeName) throws UnableToCompleteException
{
try
{
return new CommandBundleGeneratorHelper(logger,
context,
typeName).generate();
}
catch (UnableToCompleteException e)
{
throw e;
}
catch (Exception e)
{
logger.log(TreeLogger.Type.ERROR, "Barf", e);
throw new UnableToCompleteException();
}
}
}
/**
* The actual logic for type generation is moved into this separate class
* so we can access a lot of the common info as fields instead of passing
* them around.
*/
class CommandBundleGeneratorHelper
{
CommandBundleGeneratorHelper(TreeLogger logger,
GeneratorContext context,
String typeName) throws Exception
{
logger_ = logger;
context_ = context;
bundleType_ = context_.getTypeOracle().getType(typeName);
commandMethods_ = getMethods(true, false, false);
menuMethods_ = getMethods(false, true, false);
shortcutsMethods_ = getMethods(false, false, true);
resourceMap_ = context_.getResourcesOracle().getResourceMap();
packageName_ = bundleType_.getPackage().getName();
}
/**
* Generates the impl class and returns its name.
*/
public String generate() throws Exception
{
ImageResourceInfo images = generateImageBundle();
simpleName_ = bundleType_.getName().replace('.', '_') + "__Impl";
PrintWriter printWriter = context_.tryCreate(
logger_, packageName_, simpleName_);
if (printWriter != null)
{
// I don't fully understand why images is sometimes null but we better
// not get into a situation where we are generating this type but don't
// know what images we can use. Empirically it seems like images is
// always null only when printWriter is also null.
assert images != null;
ClassSourceFileComposerFactory factory =
new ClassSourceFileComposerFactory(packageName_, simpleName_);
factory.setSuperclass(bundleType_.getName());
factory.addImport("org.rstudio.core.client.command.AppCommand");
factory.addImport("org.rstudio.core.client.command.MenuCallback");
factory.addImport("org.rstudio.core.client.command.ShortcutManager");
SourceWriter writer = factory.createSourceWriter(context_, printWriter);
emitConstructor(writer, images);
emitCommandFields(writer);
emitMenus(writer);
emitShortcuts(writer);
emitCommandAccessors(writer);
// Close the class and commit it
writer.outdent();
writer.println("}");
context_.commit(logger_, printWriter);
}
return packageName_ + "." + simpleName_;
}
private void emitConstructor(SourceWriter writer, ImageResourceInfo images)
throws UnableToCompleteException
{
writer.println("public " + simpleName_ + "() {");
// Get additional properties from XML resource file, if exists
Map<String, Element> props = getCommandProperties();
// Implement the methods for the commands
for (JMethod method : commandMethods_)
emitCommandInitializers(writer, props, method, images);
writer.println();
writer.indentln("__registerShortcuts();");
writer.println("}");
}
private void emitCommandFields(SourceWriter writer)
throws UnableToCompleteException
{
// Declare the fields for the commands
for (JMethod method : commandMethods_)
{
String name = method.getName();
writer.println("private AppCommand " + name + "_;");
}
}
private void emitMenus(SourceWriter writer) throws UnableToCompleteException
{
for (JMethod method : menuMethods_)
{
String name = method.getName();
NodeList nodes = getConfigDoc("/commands/menu[@id='" + name + "']");
if (nodes.getLength() == 0)
{
logger_.log(TreeLogger.Type.ERROR,
"Unable to find config info for menu " + name);
throw new UnableToCompleteException();
}
else if (nodes.getLength() > 1)
{
logger_.log(TreeLogger.Type.ERROR,
"Duplicate menu entries for menu " + name);
}
String menuClass = new MenuEmitter(logger_,
context_,
bundleType_,
(Element) nodes.item(0)).generate();
writer.println("public void " + name + "(MenuCallback callback) {");
writer.indentln("new " + menuClass +
"(this).createMenu(callback);");
writer.println("}");
}
}
private void emitShortcuts(SourceWriter writer) throws UnableToCompleteException
{
writer.println("private void __registerShortcuts() {");
writer.indent();
NodeList nodes = getConfigDoc("/commands/shortcuts");
for (int i = 0; i < nodes.getLength(); i++)
{
NodeList groups = nodes.item(i).getChildNodes();
for (int j = 0; j < groups.getLength(); j++)
{
if (groups.item(j).getNodeType() != Node.ELEMENT_NODE)
continue;
String groupName = ((Element) groups.item(j)).getAttribute("name");
new ShortcutsEmitter(logger_, groupName,
(Element) groups.item(j)).generate(writer);
}
}
writer.outdent();
writer.println("}");
}
private JMethod[] getMethods(boolean includeCommands,
boolean includeMenus,
boolean includeShortcuts)
throws UnableToCompleteException
{
ArrayList<JMethod> methods = new ArrayList<JMethod>();
for (JMethod method : bundleType_.getMethods())
{
if (!method.isAbstract())
continue;
validateMethod(method);
if (!includeCommands && isCommandMethod(method))
continue;
if (!includeMenus && isMenuMethod(method))
continue;
if (!includeShortcuts && isShortcutsMethod(method))
continue;
methods.add(method);
}
return methods.toArray(new JMethod[methods.size()]);
}
// Log and throw if anything is awry about the declaration
private void validateMethod(JMethod method) throws UnableToCompleteException
{
if (isMenuMethod(method))
{
if (method.getParameters().length != 1)
{
logger_.log(TreeLogger.Type.ERROR,
"Method " + method +
" had the wrong number of parameters (expected 1)");
throw new UnableToCompleteException();
}
String paramType =
method.getParameters()[0].getType().getQualifiedSourceName();
if (!paramType.equals("org.rstudio.core.client.command.MenuCallback"))
{
logger_.log(TreeLogger.Type.ERROR,
"Method " + method +
" had wrong parameter type (expected " +
"org.rstudio.core.client.command.MenuCallback)");
throw new UnableToCompleteException();
}
}
else
{
if (method.getParameters().length != 0)
{
logger_.log(TreeLogger.Type.ERROR,
"Method " + method +
" had parameters where none were expected");
throw new UnableToCompleteException();
}
}
if (!isCommandMethod(method)
&& !isMenuMethod(method)
&& !isShortcutsMethod(method))
{
logger_.log(TreeLogger.Type.ERROR,
"Method " + method +
" had an unexpected return type");
throw new UnableToCompleteException();
}
}
private boolean isCommandMethod(JMethod method)
{
return method.getReturnType().getQualifiedSourceName().equals(
"org.rstudio.core.client.command.AppCommand");
}
private boolean isMenuMethod(JMethod method)
{
String sourceName = method.getReturnType().getQualifiedSourceName();
return sourceName.equals("void");
}
private boolean isShortcutsMethod(JMethod method)
{
String sourceName = method.getReturnType().getQualifiedSourceName();
return sourceName.equals("org.rstudio.core.client.command.ShortcutManager");
}
/**
* Emit the getter method for the command--it is implemented as a cached
* lazy-load. e.g.:
*
* public AppCommand newSourceDoc() {
* if (newSourceDoc_ == null) {
* newSourceDoc_ = new AppCommand();
* // call various setters...
* }
* return newSourceDoc_;
* }
*/
private void emitCommandInitializers(SourceWriter writer,
Map<String, Element> props,
JMethod method,
ImageResourceInfo images)
{
String name = method.getName();
writer.println(name + "_ = new AppCommand();");
setProperty(writer, name, props.get(name), "id");
setProperty(writer, name, props.get(name), "desc");
setProperty(writer, name, props.get(name), "label");
setProperty(writer, name, props.get(name), "buttonLabel");
setProperty(writer, name, props.get(name), "menuLabel");
// Any additional textual properties would be added here...
setPropertyBool(writer, name, props.get(name), "visible");
setPropertyBool(writer, name, props.get(name), "enabled");
setPropertyBool(writer, name, props.get(name),
"preventShortcutWhenDisabled");
setPropertyBool(writer, name, props.get(name), "checkable");
setPropertyBool(writer, name, props.get(name), "checked");
if (images.hasImage(name))
{
writer.println(name + "_.setImageResource("
+ images.getImageRef(name) + ");");
}
writer.println("addCommand(\"" + Generator.escape(name) + "\", " + name + "_);");
writer.println();
}
private void emitCommandAccessors(SourceWriter writer)
{
for (JMethod method : commandMethods_)
{
String name = method.getName();
writer.println("public AppCommand " + name + "() {");
writer.indent();
writer.println("return " + name + "_;");
writer.outdent();
writer.println("}");
}
}
private void setProperty(SourceWriter writer,
String name,
Element props,
String propertyName)
{
if (props == null)
return;
// This check is important because getAttribute() returns empty string
// even if the attribute isn't present, which is not what we want. In
// the command system, empty string is distinct from null.
if (!props.hasAttribute(propertyName))
return;
String value = props.getAttribute(propertyName);
String setter = "set" + Character.toUpperCase(propertyName.charAt(0))
+ propertyName.substring(1);
writer.println(name + "_." + setter
+ "(\"" + Generator.escape(value) + "\");");
}
private void setPropertyBool(SourceWriter writer,
String name,
Element props,
String propertyName)
{
if (props == null)
return;
// This check is important because getAttribute() returns empty string
// even if the attribute isn't present, which is not what we want. In
// the command system, empty string is distinct from null.
if (!props.hasAttribute(propertyName))
return;
String value = props.getAttribute(propertyName);
String setter = "set" + Character.toUpperCase(propertyName.charAt(0))
+ propertyName.substring(1);
writer.println(name + "_." + setter
+ "(" + value + ");");
}
private ImageResourceInfo generateImageBundle()
{
String className = bundleType_.getSimpleSourceName() + "__AutoGenResources";
String pathToInstance = packageName_ + "." + className + ".INSTANCE";
ImageResourceInfo iri = new ImageResourceInfo(pathToInstance);
PrintWriter printWriter = context_.tryCreate(logger_,
packageName_,
className);
if (printWriter == null)
return null;
ClassSourceFileComposerFactory factory =
new ClassSourceFileComposerFactory(packageName_, className);
factory.addImport("com.google.gwt.core.client.GWT");
factory.addImport("com.google.gwt.resources.client.*");
factory.makeInterface();
factory.addImplementedInterface("ClientBundle");
SourceWriter writer = factory.createSourceWriter(context_, printWriter);
for (JMethod method : commandMethods_)
{
String commandId = method.getName();
String key = packageName_.replace('.', '/') + "/" + commandId + ".png";
if (resourceMap_.containsKey(key))
{
writer.println("ImageResource " + commandId + "();");
iri.addImage(commandId);
}
}
writer.println("public static final " + className + " INSTANCE = " +
"(" + className + ")GWT.create(" + className + ".class);");
writer.outdent();
writer.println("}");
context_.commit(logger_, printWriter);
return iri;
}
public Map<String, Element> getCommandProperties() throws UnableToCompleteException
{
Map<String, Element> properties = new HashMap<String, Element>();
NodeList nodes = getConfigDoc("/commands/cmd");
for (int i = 0; i < nodes.getLength(); i++)
{
Element cmd = (Element) nodes.item(i);
String id = cmd.getAttribute("id");
properties.put(id, cmd);
}
return properties;
}
private NodeList getConfigDoc(String xpath) throws UnableToCompleteException
{
try
{
String resourceName =
bundleType_.getQualifiedSourceName().replace('.', '/') + ".cmd.xml";
Resource resource = resourceMap_.get(resourceName);
if (resource == null)
return null;
Object result = XPathFactory.newInstance().newXPath().evaluate(
xpath,
new InputSource(resource.getLocation()),
XPathConstants.NODESET);
return (NodeList) result;
}
catch (Exception e)
{
logger_.log(TreeLogger.Type.ERROR, "Barf", e);
throw new UnableToCompleteException();
}
}
private final TreeLogger logger_;
private final GeneratorContext context_;
private final JClassType bundleType_;
private final JMethod[] commandMethods_;
private final JMethod[] menuMethods_;
@SuppressWarnings("unused")
private final JMethod[] shortcutsMethods_;
private final Map<String, Resource> resourceMap_;
private final String packageName_;
private String simpleName_;
}
class ImageResourceInfo
{
public ImageResourceInfo(String imagesRefPath)
{
this.imagesRefPath_ = imagesRefPath;
}
public void addImage(String commandId)
{
imageIds_.add(commandId);
}
public boolean hasImage(String commandId)
{
return imageIds_.contains(commandId);
}
public String getImageRef(String commandId)
{
assert hasImage(commandId);
return imagesRefPath_ + "." + commandId + "()";
}
private final String imagesRefPath_;
private final HashSet<String> imageIds_ = new HashSet<String>();
}