• Home
• net.jangaroo
• ext-as-api-generator
• 4.0.40
• source code
• ExtAsApiGenerator.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.jangaroo.exml.tools.ExtAsApiGenerator Maven / Gradle / Ivy

package net.jangaroo.exml.tools;

import net.jangaroo.exml.tools.ExtJsApi.ExtClass;
import net.jangaroo.jooc.Jooc;
import net.jangaroo.jooc.backend.ActionScriptCodeGeneratingModelVisitor;
import net.jangaroo.jooc.backend.JsCodeGenerator;
import net.jangaroo.jooc.model.AbstractAnnotatedModel;
import net.jangaroo.jooc.model.AnnotationModel;
import net.jangaroo.jooc.model.AnnotationPropertyModel;
import net.jangaroo.jooc.model.ClassModel;
import net.jangaroo.jooc.model.CompilationUnitModel;
import net.jangaroo.jooc.model.CompilationUnitModelRegistry;
import net.jangaroo.jooc.model.FieldModel;
import net.jangaroo.jooc.model.MemberModel;
import net.jangaroo.jooc.model.MethodModel;
import net.jangaroo.jooc.model.MethodType;
import net.jangaroo.jooc.model.NamedModel;
import net.jangaroo.jooc.model.NamespacedModel;
import net.jangaroo.jooc.model.ParamModel;
import net.jangaroo.jooc.model.PropertyModel;
import net.jangaroo.jooc.model.TypedModel;
import net.jangaroo.jooc.mxml.MxmlUtils;
import net.jangaroo.utils.AS3Type;
import net.jangaroo.utils.CompilerUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Pattern;

import static net.jangaroo.exml.tools.ExtJsApi.Cfg;
import static net.jangaroo.exml.tools.ExtJsApi.Deprecation;
import static net.jangaroo.exml.tools.ExtJsApi.Event;
import static net.jangaroo.exml.tools.ExtJsApi.Member;
import static net.jangaroo.exml.tools.ExtJsApi.Method;
import static net.jangaroo.exml.tools.ExtJsApi.Param;
import static net.jangaroo.exml.tools.ExtJsApi.Property;
import static net.jangaroo.exml.tools.ExtJsApi.Tag;
import static net.jangaroo.exml.tools.ExtJsApi.Var;
import static net.jangaroo.exml.tools.ExtJsApi.isConst;
import static net.jangaroo.exml.tools.ExtJsApi.isSingleton;

/**
 * Generate ActionScript 3 APIs from a jsduck JSON export of the Ext JS 4.x API.
 */
public class ExtAsApiGenerator {

  private static final Pattern SINGLETON_CLASS_NAME_PATTERN = Pattern.compile("^S[A-Z]");
  private static ExtJsApi extJsApi;
  private static Set extClasses;
  private static CompilationUnitModelRegistry compilationUnitModelRegistry;
  private static Set interfaces;
  private static final List NON_COMPILE_TIME_CONSTANT_INITIALIZERS = Arrays.asList("window", "document", "document.body", "new Date()", "this", "`this`", "10||document.body", "caller", "array.length");
  private static ExtAsApi referenceApi;
  private static boolean generateEventClasses;
  private static boolean generateForMxml;
  private static Properties jsAsNameMappingProperties = new Properties();
  private static Properties jsConfigClassNameMappingProperties = new Properties();
  private static Properties eventWordsProperties = new Properties();
  private static final String EXT_3_4_EVENT = "ext.IEventObject";
  private static String EXT_EVENT;
  private static Map> aliasGroupToAliasToClass = new TreeMap>();

  public static void main(String[] args) throws IOException {
    File srcDir = new File(args[0]);
    File outputDir = new File(args[1]);
    referenceApi = new ExtAsApi("2.0.14", "2.0.13");
    EXT_EVENT = referenceApi.getMappedQName(EXT_3_4_EVENT);
    if (EXT_EVENT == null) {
      EXT_EVENT = EXT_3_4_EVENT;
    }

    generateEventClasses = args.length <= 2 || Boolean.valueOf(args[2]);
    generateForMxml = args.length <= 3 ? false : Boolean.valueOf(args[3]);

    jsAsNameMappingProperties.load(ExtAsApiGenerator.class.getClassLoader().getResourceAsStream("net/jangaroo/exml/tools/js-as-name-mapping.properties"));
    jsConfigClassNameMappingProperties.load(ExtAsApiGenerator.class.getClassLoader().getResourceAsStream("net/jangaroo/exml/tools/js-config-name-mapping.properties"));
    eventWordsProperties.load(ExtAsApiGenerator.class.getClassLoader().getResourceAsStream("net/jangaroo/exml/tools/event-words.properties"));

    File[] files = srcDir.listFiles();
    if (files != null) {
      compilationUnitModelRegistry = new CompilationUnitModelRegistry();
      interfaces = new HashSet();
      extJsApi = new ExtJsApi(files);
      extClasses = new HashSet(extJsApi.getExtClasses());
      removePrivateApiClasses();

      Set mixins = extJsApi.getMixins();
      for (ExtClass mixin : mixins) {
        String mixinName = getActionScriptName(mixin);
        if (mixinName != null) {
          interfaces.add(mixinName);
        }
      }

      // correct wrong usage of util.Observable as a mixin:
      interfaces.remove("ext.util.Observable");
      // correct wrong usage of dom.Element as a mixin, not superclass, in dom.CompositeElementLite:
      interfaces.remove("ext.dom.Element");
      // since every Ext object extends Base, there is no need to generate an interface for that:
      interfaces.remove("ext.Base");
      interfaces.remove("Object");
      interfaces.add("ext.EventObjectImpl");

      for (ExtClass extClass : extClasses) {
        generateClassModel(extClass);
      }
      compilationUnitModelRegistry.complementOverrides();
      compilationUnitModelRegistry.complementImports();

      adaptToReferenceApi();

      // again, to make corrections consistent (actually needed?)
//      compilationUnitModelRegistry.complementOverrides();
//      compilationUnitModelRegistry.complementImports();

      annotateBindableConfigProperties();

      if (!outputDir.exists()) {
        System.err.println("No output directory specified, skipping code generation.");
        return;
      }
      for (CompilationUnitModel compilationUnitModel : compilationUnitModelRegistry.getCompilationUnitModels()) {
        generateActionScriptCode(compilationUnitModel, outputDir);
      }
    }

    generateManifest(outputDir);
  }

  private static void generateManifest(File outputDir) throws FileNotFoundException, UnsupportedEncodingException {
    // create manifest.xml component library:
    File outputFile = new File(outputDir, "manifest.xml");
    System.out.printf("Creating manifest file %s...%n", outputFile.getPath());
    PrintStream out = new PrintStream(new FileOutputStream(outputFile), true, net.jangaroo.exml.api.Exmlc.OUTPUT_CHARSET);
    out.println("");
    out.println("");
    for (String aliasGroup : aliasGroupToAliasToClass.keySet()) {
      String previousId = "";
      for (Map.Entry aliasToClass : aliasGroupToAliasToClass.get(aliasGroup).entrySet()) {
        String alias = aliasToClass.getKey();
        String classQName = aliasToClass.getValue();
        String id = computeId(alias, classQName + previousId);
        previousId = id;
        if (!"widget".equals(aliasGroup)) {
          id = aliasGroup + "_" + id;
        }
        out.printf("  %n", id, classQName);
      }
    }
    out.println("");
    out.close();
  }

  private static String computeId(String alias, String classQName) {
    int dotPos = alias.indexOf('.');
    if (dotPos != -1) {
      // special format used e.g. in "data" aliases: capitalize the dot-prefix and use it as suffix.
      return computeId(alias.substring(dotPos + 1), classQName) + capitalize(alias.substring(0, dotPos));
    }
    // remove all dashes from alias:
    alias = alias.replaceAll("-", "");

    // match unqualified class name word by word:
    String className = CompilerUtils.className(classQName);
    String[] words = className.split("(? iterator = ((MethodModel) member).getParams().iterator(),
                         newIterator = ((MethodModel) newMember).getParams().iterator();
          while (iterator.hasNext() && newIterator.hasNext()) {
            ParamModel param = iterator.next();
            ParamModel newParam = newIterator.next();
            changed |= adaptTypeToReferenceApi(referenceCompilationUnitModel, newParam, param);
          }
          if (iterator.hasNext() || newIterator.hasNext()) {
            changed = true;
          }
        }
        if (changed) {
          ++changedCount;
        }
      }
    }
    int sameCount = referenceClassModel.getMembers().size() - changedCount - removedCount;
    //System.err.printf("=== Adapted %s: removed: %d, changed: %d, same: %d%n", compilationUnitModel.getQName(), removedCount, changedCount, sameCount);
    System.err.printf("%s\t%d\t%d\t%d%n", compilationUnitModel.getQName(), removedCount, changedCount, sameCount);
  }


  private static boolean adaptTypeToReferenceApi(CompilationUnitModel referenceCompilationUnitModel, TypedModel newMember, TypedModel member) {
    String oldType = referenceApi.resolveQualifiedName(referenceCompilationUnitModel, member.getType());
    String newType = newMember.getType(); // already fully-qualified!
    if (oldType != null && !oldType.equals(newType)) {
      //System.err.printf("*** found %s member %s type change: from %s to %s%n", classModel.getName(), member.getName(), oldType, newType);
      if (shouldCorrect(oldType, newType)) {
        newMember.setType(oldType);
        //System.err.printf("!!! corrected type of %s.%s from %s back to %s%n", classModel.getName(), member.getName(), newType, oldType);
        return true;
      }
    }
    return false;
  }

  private static void adaptNamespaceToReferenceApi(MemberModel newMember, MemberModel member) {
    String oldNamespace = member.getNamespace();
    String newNamespace = newMember.getNamespace();
    if (oldNamespace != null && !oldNamespace.equals(newNamespace)) {
      newMember.setNamespace(oldNamespace);
    }
  }

  private static boolean shouldCorrect(String oldType, String newType) {
    return newType == null ||
            "void".equals(newType) ||
            "*".equals(newType) ||
            "void".equals(oldType) ||
            "Object".equals(newType) && "*".equals(oldType) ||
            EXT_EVENT.equals(oldType) && newType.contains("Event") ||
            "Function".equals(newType) && "Class".equals(oldType);
  }

  private static MemberModel findMemberModel(CompilationUnitModel compilationUnitModel, MemberModel referenceMemberModel) {
    ClassModel classModel = compilationUnitModel.getClassModel();
    String referenceMemberName = referenceApi.getMappedMemberName(compilationUnitModel, referenceMemberModel.getName());
    MemberModel memberModel = referenceMemberModel instanceof MethodModel
            ? classModel.getMethod(referenceMemberModel.isStatic(), ((MethodModel) referenceMemberModel).getMethodType(), referenceMemberName)
            : classModel.getMember(referenceMemberModel.isStatic(), referenceMemberName);
    if (memberModel == null) {
      CompilationUnitModel superclass = compilationUnitModelRegistry.getSuperclassCompilationUnit(classModel);
      if (superclass != null && !referenceApi.hasReferenceQName(superclass.getQName())) {
        return findMemberModel(superclass, referenceMemberModel);
      }
    }
    return memberModel;
  }

  private static void generateClassModel(ExtClass extClass) {
    String extClassName = getActionScriptName(extClass);
    if (extClassName == null) {
      return;
    }
    CompilationUnitModel extAsClassUnit = createClassModel(convertType(extClass.name));
    ClassModel extAsClass = extAsClassUnit.getClassModel();
    System.out.printf("Generating AS3 API model %s for %s...%n", extAsClassUnit.getQName(), extClassName);
    extAsClass.setAsdoc(toAsDoc(extClass));
    addDeprecation(extClass.deprecated, extAsClass);
    CompilationUnitModel extAsInterfaceUnit = null;
    if (interfaces.contains(extClassName)) {
      extAsInterfaceUnit = createClassModel(convertToInterface(extClassName));
      System.out.printf("Generating AS3 API model %s for %s...%n", extAsInterfaceUnit.getQName(), extClassName);
      ClassModel extAsInterface = (ClassModel)extAsInterfaceUnit.getPrimaryDeclaration();
      extAsInterface.setInterface(true);
      extAsInterface.setAsdoc(toAsDoc(extClass.doc) + "\n * @see " + extClassName);
      if (extClass.extends_ != null) {
        String superInterface = convertToInterface(getActionScriptName(extClass.extends_));
        if (superInterface != null) {
          extAsInterface.addInterface(superInterface);
        }
      }
    }
    AnnotationModel nativeAnnotation = createNativeAnnotation(extClass.name);
    if (isSingleton(extClass)) {
      extAsClass.addAnnotation(createNativeAnnotation(null));
      FieldModel singleton = new FieldModel(CompilerUtils.className(extAsClass.getName().substring(1)), extAsClassUnit.getQName());
      singleton.setConst(true);
      singleton.setValue("new " + extAsClassUnit.getQName());
      singleton.addAnnotation(nativeAnnotation);
      singleton.setAsdoc(extAsClass.getAsdoc());
      CompilationUnitModel singletonUnit = new CompilationUnitModel(extAsClassUnit.getPackage(), singleton);
      compilationUnitModelRegistry.register(singletonUnit);

      extAsClass.setAsdoc(String.format("%s%n
Type of singleton %s.
%n@see %s %s",
        extAsClass.getAsdoc(),
        singleton.getName(),
        CompilerUtils.qName(extAsClassUnit.getPackage(), "#" + singleton.getName()),
        singletonUnit.getQName()));
    } else {
      extAsClass.addAnnotation(nativeAnnotation);
    }
    if (extAsInterfaceUnit != null) {
      extAsInterfaceUnit.getClassModel().addAnnotation(new AnnotationModel(Jooc.MIXIN_ANNOTATION_NAME,
              new AnnotationPropertyModel(null, CompilerUtils.quote(extClassName))));
    }
    if (extClass.private_) {
      extAsClass.addAnnotation(new AnnotationModel(Jooc.PUBLIC_API_EXCLUSION_ANNOTATION_NAME));
    }
    extAsClass.setSuperclass(convertType(extClass.extends_));
    if (extAsInterfaceUnit != null) {
      extAsClass.addInterface(extAsInterfaceUnit.getQName());
    }
    for (String mixin : extClass.mixins) {
      String superInterface = convertToInterface(getActionScriptName(mixin));
      if (superInterface != null) {
        extAsClass.addInterface(superInterface);
        if (extAsInterfaceUnit != null) {
          extAsInterfaceUnit.getClassModel().addInterface(superInterface);
        }
      }
    }

    if (extAsInterfaceUnit != null) {
      addNonStaticMembers(extClass, extAsInterfaceUnit);
    } else {
      addFields(extAsClass, extJsApi.filterByOwner(false, true, extClass, extClass.members, Property.class));
      addMethods(extAsClass, extJsApi.filterByOwner(false, true, extClass, extClass.members, Method.class));
    }

    addNonStaticMembers(extClass, extAsClassUnit);

    // todo: remove #getConfigClassQName and its mapping properties, a constructor needs to be generated if and only if the class or a superclass has config parameters
    if (getConfigClassQName(extClass) != null) {
      addConfigConstructor(extAsClassUnit);
    }

    for (Map.Entry> aliasEntry : extClass.aliases.entrySet()) {
      String aliasGroup = aliasEntry.getKey();
      Map aliasMapping = aliasGroupToAliasToClass.get(aliasGroup);
      if (aliasMapping == null) {
        aliasMapping = new TreeMap();
        aliasGroupToAliasToClass.put(aliasGroup, aliasMapping);
      }
      for (String alias : aliasEntry.getValue()) {
        aliasMapping.put(alias, extAsClassUnit.getQName());
      }
    }
  }

  private static void addConfigConstructor(CompilationUnitModel extAsClassUnit) {
    ClassModel extAsClass = extAsClassUnit.getClassModel();
    MethodModel targetClassConstructor = extAsClass.getConstructor();
    if (targetClassConstructor == null) {
      targetClassConstructor = extAsClass.createConstructor();
      targetClassConstructor.addParam(new ParamModel("config", extAsClassUnit.getQName(), "null", "@inheritDoc"));
    } else {
      for (ParamModel param : targetClassConstructor.getParams()) {
        if ("config".equals(param.getName())) {
          param.setType(extAsClass.getName());
          param.setOptional(true);
          break;
        }
      }
    }
  }

  private static String getActionScriptName(String extClassName) {
    return getActionScriptName(extJsApi.getExtClass(extClassName));
  }

  private static String getConfigClassQName(ExtClass extClass) {
    String extClassName = extClass.name;
    String alias = jsConfigClassNameMappingProperties.getProperty(extClassName);
    if (alias == null) {
      return null;
    }
    String configClassQName = CompilerUtils.qName("ext.config", alias);
    System.err.println("********* derived config class name "  + configClassQName + " from Ext class " + extClassName + " with alias " + alias);
    return configClassQName;
  }

  private static String getPreferredAlias(Map.Entry> aliases) {
    String alias;
    alias = aliases.getValue().get(aliases.getValue().size() - 1);
    if (aliases.getValue().size() > 1) {
      // for the following exceptions, use the first alias:
      if ("box".equals(alias)) {
        alias = aliases.getValue().get(0);
      }
      System.err.println("***### multiple aliases: " + aliases.getValue() + ", choosing " + alias);
    }
    return alias;
  }

  private static Map.Entry> getAlias(ExtClass extClass) {
    Iterator>> iterator = extClass.aliases.entrySet().iterator();
    if (iterator.hasNext()) {
      Map.Entry> firstEntry = iterator.next();
      if (firstEntry.getValue().size() > 0) {
        return firstEntry;
      }
    }
    return null;
  }

  private static AnnotationModel createNativeAnnotation(String nativeName) {
    AnnotationModel nativeAnnotation = new AnnotationModel(Jooc.NATIVE_ANNOTATION_NAME);
    if (nativeName != null) {
      nativeAnnotation.addProperty(new AnnotationPropertyModel(null, CompilerUtils.quote(nativeName)));
      nativeAnnotation.addProperty(new AnnotationPropertyModel(Jooc.NATIVE_ANNOTATION_REQUIRE_PROPERTY, null));
    }
    return nativeAnnotation;
  }

  private static CompilationUnitModel createClassModel(String qName) {
    CompilationUnitModel oldCompilationUnitModel = compilationUnitModelRegistry.resolveCompilationUnit(qName);
    if (oldCompilationUnitModel != null) {
      System.err.println("[WARN] Redefining class " + qName);
      return oldCompilationUnitModel;
    }
    CompilationUnitModel compilationUnitModel = new CompilationUnitModel(null, new ClassModel());
    compilationUnitModel.setQName(qName);
    compilationUnitModelRegistry.register(compilationUnitModel);
    return compilationUnitModel;
  }

  private static void addNonStaticMembers(ExtClass extClass, CompilationUnitModel extAsClassUnit) {
    ClassModel extAsClass = extAsClassUnit.getClassModel();
    if (!extAsClass.isInterface()) {
      addEvents(extAsClass, extAsClassUnit, extJsApi.filterByOwner(false, false, extClass, extClass.members, Event.class));
    }
    addProperties(extAsClass, extJsApi.filterByOwner(extAsClass.isInterface(), false, extClass, extClass.members, Property.class), false);
    addMethods(extAsClass, extJsApi.filterByOwner(extAsClass.isInterface(), false, extClass, extClass.members, Method.class));
    addProperties(extAsClass, extJsApi.filterByOwner(extAsClass.isInterface(), false, extClass, extClass.members, Cfg.class), true);
  }

  private static void generateActionScriptCode(CompilationUnitModel extAsClass, File outputDir) throws IOException {
    File outputFile = CompilerUtils.fileFromQName(extAsClass.getQName(), outputDir, Jooc.AS_SUFFIX);
    //noinspection ResultOfMethodCallIgnored
    outputFile.getParentFile().mkdirs(); // NOSONAR
    System.out.printf("Generating AS3 API for %s into %s ...\n", extAsClass.getQName(), outputFile.getCanonicalPath());
    extAsClass.visit(new ActionScriptCodeGeneratingModelVisitor(new OutputStreamWriter(new FileOutputStream(outputFile), "UTF-8")));
  }

  private static void addDeprecation(Deprecation deprecation, AbstractAnnotatedModel model) {
    if (deprecation != null) {
      final AnnotationModel deprecated = new AnnotationModel("Deprecated");
      if (deprecation.text != null && !deprecation.text.matches("\\s*")) {
        deprecated.addProperty(new AnnotationPropertyModel(
                "message",
                CompilerUtils.quote(deprecation.text.replace("
", "").replace("
", ""))));
      }
      if (deprecation.version != null && !deprecation.version.matches("\\s*")) {
        deprecated.addProperty(new AnnotationPropertyModel(
                "since",
                deprecation.version.startsWith("\"") ? deprecation.version : CompilerUtils.quote(deprecation.version)));
      }
      model.addAnnotation(deprecated);
    }
  }

  private static void addEvents(ClassModel classModel, CompilationUnitModel compilationUnitModel, List events) {
    for (Event event : events) {
      String eventName = toCamelCase(event.name);
      AnnotationModel annotationModel = new AnnotationModel("Event",
              new AnnotationPropertyModel("name", "'on" + eventName + "'"));
      String asdoc = toAsDoc(event);
      if (generateEventClasses) {
        String eventTypeQName = generateEventClass(compilationUnitModel, event);
        annotationModel.addProperty(new AnnotationPropertyModel("type", "'" + eventTypeQName + "'"));
        asdoc +=  String.format("%n@eventType %s.%s", eventTypeQName, toConstantName(event.name));
      }
      annotationModel.setAsdoc(asdoc);
      classModel.addAnnotation(annotationModel);
    }
  }

  public static String capitalize(String name) {
    return name == null || name.length() == 0 ? name : Character.toUpperCase(name.charAt(0)) + name.substring(1);
  }

  private static String generateEventClass(CompilationUnitModel eventClientClass, Event event) {
    String eventTypeNamePrefix = eventClientClass.getPrimaryDeclaration().getName();
    if (SINGLETON_CLASS_NAME_PATTERN.matcher(eventTypeNamePrefix).find()) {
      eventTypeNamePrefix = eventTypeNamePrefix.substring(1);
    }
    String eventTypeQName = eventClientClass.getPackage() + ".events." + eventTypeNamePrefix;
    String eventClientClassQName = eventClientClass.getQName();
    for (int i = 0; i < event.params.size(); i++) {
      Param param = event.params.get(i);
      String asType = convertType(param.type);
      if (!"eOpts".equals(param.name) && !"this".equals(param.name) && (i > 0 || !eventClientClassQName.equals(asType))) {
        eventTypeQName += "_" + param.name;
      }
    }
    eventTypeQName += "Event";

    String eventName = toCamelCase(event.name);

    CompilationUnitModel eventType = compilationUnitModelRegistry.resolveCompilationUnit(eventTypeQName);
    if (eventType == null) {
      eventType = createClassModel(eventTypeQName);
      ClassModel extAsClass = eventType.getClassModel();
      extAsClass.setSuperclass("net.jangaroo.ext.FlExtEvent");

      MethodModel constructorModel = extAsClass.createConstructor();
      constructorModel.addParam(new ParamModel("type", "String"));
      constructorModel.addParam(new ParamModel("arguments", "Array"));
      constructorModel.setBody("super(type, arguments);");

      StringBuilder parameterSequence = new StringBuilder();
      String separator = "[";
      for (Param param : event.params) {
        String parameterName = convertName(param.name);

        // add parameter to sequence constant:
        parameterSequence.append(separator).append(CompilerUtils.quote(parameterName));
        separator = ", ";

        if (!"eOpts".equals(param.name)) { // eOpts is inherited from FlExtEvent!
          // add getter method:
          MethodModel property = new MethodModel(MethodType.GET, parameterName, convertType(param.type));
          property.setAsdoc(toAsDoc(param));
          extAsClass.addMember(property);
        }
      }
      parameterSequence.append("]");

      FieldModel parameterSequenceConstant = new FieldModel("__PARAMETER_SEQUENCE__", "Array", parameterSequence.toString());
      parameterSequenceConstant.setStatic(true);
      parameterSequenceConstant.setConst(true);
      extAsClass.addMember(parameterSequenceConstant);
    }

    FieldModel eventNameConstant = new FieldModel(toConstantName(event.name), "String", CompilerUtils.quote("on" + eventName));
    eventNameConstant.setStatic(true);
    eventNameConstant.setConst(true);
    eventNameConstant.setAsdoc(String.format("\"%s%n@see %s%n@eventType %s", toAsDoc(event), eventClientClass.getQName(), "on" + eventName));
    eventType.getClassModel().addMember(eventNameConstant);

    return eventTypeQName;
  }

  private static String toCamelCase(String eventName) {
    if (!eventName.toLowerCase().equals(eventName)) {
      // already CamelCase:
      return eventName;
    }
    StringBuilder camelCaseName = new StringBuilder();
    for (String word : splitIntoWords(eventName)) {
      camelCaseName.append(capitalize(word));
    }
    assert camelCaseName.toString().toLowerCase().equals(eventName);
    return camelCaseName.toString();
  }

  private static String toConstantName(String eventName) {
    StringBuilder constantName = new StringBuilder();
    for (String word : splitIntoWords(eventName.toLowerCase())) {
      constantName.append(word.toUpperCase()).append('_');
    }
    constantName.setLength(constantName.length() - 1); // cut last '_'
    return constantName.toString();
  }

  private static List splitIntoWords(String mergedWords) {
    List words = new ArrayList();
    String remaining = mergedWords;
    while (!remaining.isEmpty()) {
      String candidate = "";
      for (Object keyObject : eventWordsProperties.keySet()) {
        String key = (String) keyObject;
        if (key.length() > candidate.length() && remaining.startsWith(key)) {
          candidate = key;
        }
      }
      if (candidate.isEmpty()) {
        System.err.printf("No word found in dictionary for %s's suffix '%s'.%n", mergedWords, remaining);
        candidate = remaining;
      }
      words.add(candidate);
      remaining = remaining.substring(candidate.length());
    } return words;
  }

  private static void addFields(ClassModel classModel, List fields) {
    for (Member member : fields) {
      PropertyModel fieldModel = new PropertyModel(convertName(member.name), convertType(member.type));
      setVisibility(fieldModel, member);
      setStatic(fieldModel, member);
      fieldModel.addGetter().setAsdoc(toAsDoc(member));
      if (!isConst(member)) {
        fieldModel.addSetter().setAsdoc("@private");
      }
      addDeprecation(member.deprecated, fieldModel);
      classModel.addMember(fieldModel);
    }
  }

  private static void addProperties(ClassModel classModel, List properties, boolean isConfig) {
    for (Member member : properties) {
      if (extJsApi.inheritsDoc(member)) {
        // suppress overridden properties with the same JSDoc!
        continue;
      }

      boolean isStatic = extJsApi.isStatic(member);
      String name = convertName(member.name);
      String type = convertType(member.type);
      String asDoc = toAsDoc(member);
      if (type == null || "*".equals(type) || "Object".equals(type)) {
        // try to deduce a more specific type from the property name:
        type = "cls".equals(member.name) ? "String"
                : "useBodyElement".equals(member.name) ? "Boolean"
                : "items".equals(member.name) || "plugins".equals(member.name) ? "Array"
                : type;
      }
      MemberModel priorMember = classModel.getMember(isStatic, name);
      if (priorMember != null) {
        String priorMemberType;
        if (priorMember.isMethod() && !priorMember.isAccessor()) {
          priorMemberType = "Function";
        } else {
          priorMemberType = priorMember.getType();
        }
        if (!priorMemberType.equals(type)){
          System.err.println("Duplicate member " + member.name + (isConfig ? " (config)" : "")
                  + " in class " + classModel.getName()
                  + " with deviating type " + type + " instead of " + priorMemberType + ".");
        }
        if ("Array".equals(type) && priorMemberType.contains("Collection")) {
          String newName = (name.endsWith("s") ? name.substring(0, name.length() - 1) : name) + "Collection";
          System.out.println("Renaming member " + priorMember.getName() + " to " + newName + " in class " + classModel.getName()
                  + " to avoid name clash with config.");
          priorMember.setName(newName);
        } else if ("Function".equals(priorMemberType)) {
          name += "_";
          System.out.println("Renaming config " + member.name + " to " + name + " in class " + classModel.getName()
                  + " to avoid name clash with method.");
        } else {
          type = priorMemberType;
          asDoc = priorMember.isProperty() ? ((PropertyModel)priorMember).getGetter().getAsdoc() : priorMember.getAsdoc();
          System.out.println("Merging member " + priorMember.getName() + " and config " + member.name + " in class " + classModel.getName()
                  + " to avoid name clash.");
          classModel.removeMember(priorMember);
        }
      }

      PropertyModel propertyModel = new PropertyModel(name, type);
      if (generateForMxml && "items".equals(member.name)) {
        propertyModel.addAnnotation(new AnnotationModel(MxmlUtils.MXML_DEFAULT_PROPERTY_ANNOTATION));
      }
      propertyModel.setAsdoc(asDoc);
      addDeprecation(member.deprecated, propertyModel);
      setVisibility(propertyModel, member);
      propertyModel.setStatic(isStatic);
      MethodModel getter = propertyModel.addGetter();
      AnnotationModel extConfigAnnotation = null;
      if (isConfig) {
        extConfigAnnotation = new AnnotationModel(Jooc.EXT_CONFIG_ANNOTATION_NAME);
        if (!name.equals(member.name)) {
          extConfigAnnotation.addProperty(new AnnotationPropertyModel(null, CompilerUtils.quote(member.name)));
        }
        getter.addAnnotation(extConfigAnnotation);
      }
      if (!extJsApi.isReadOnly(member)) {
        MethodModel setter = propertyModel.addSetter();
        if (classModel.isInterface()) {
          // do not add @private to ASDoc in interfaces, or IDEA will completely ignore the declaration!
          setter.setAsdoc(null);
        }
        if (extConfigAnnotation != null) {
          setter.addAnnotation(extConfigAnnotation);
        }
      }
      classModel.addMember(propertyModel);
    }
  }

  private static void addMethods(ClassModel classModel, List methods) {
    for (Method method : methods) {
      String methodName = method.name;
      if (methodName == null || methodName.length() == 0) {
        System.err.printf("methods name missing for method #%d in class %s", methods.indexOf(method) + 1, classModel.getName());
        continue;
      }
      if (classModel.getMember(methodName) == null) {
        boolean isConstructor = methodName.equals("constructor");
        if (!isConstructor && extJsApi.inheritsDoc(method)) {
          // suppress overridden methods with the same JSDoc!
          continue;
        }
        MethodModel methodModel = isConstructor
                ? new MethodModel(classModel.getName(), null)
                : new MethodModel(convertName(methodName), method.return_ == null ? "void" : convertType(method.return_.type));
        methodModel.setAsdoc(toAsDoc(method));
        if (method.return_ != null) {
          methodModel.getReturnModel().setAsdoc(toAsDoc(method.return_));
        }
        setVisibility(methodModel, method);
        setStatic(methodModel, method);
        addDeprecation(method.deprecated, methodModel);
        for (Param param : method.params) {
          String paramName = param.name == null ? "param" + (method.params.indexOf(param) + 1) : convertName(param.name);
          ParamModel paramModel = new ParamModel(paramName, convertType(param.type));
          paramModel.setAsdoc(toAsDoc(param, param.name));
          setDefaultValue(paramModel, param);
          paramModel.setRest(param == method.params.get(method.params.size() - 1) && param.type.endsWith("..."));
          methodModel.addParam(paramModel);
        }
        try {
          classModel.addMember(methodModel);
        } catch (IllegalArgumentException e) {
          System.err.println("while adding method " + methodModel + ": " + e);
        }
      }
    }
  }

  private static void setVisibility(MemberModel memberModel, Member member) {
    memberModel.setNamespace(extJsApi.isProtected(member) ? NamespacedModel.PROTECTED : NamespacedModel.PUBLIC);
  }

  private static void setStatic(MemberModel memberModel, Member member) {
    memberModel.setStatic(extJsApi.isStatic(member));
  }

  private static String toAsDoc(Tag tag) {
    return toAsDoc(tag, null);
  }

  private static String toAsDoc(Tag tag, String paramPrefix) {
    StringBuilder asDoc = new StringBuilder(toAsDoc(tag.doc));
    if (tag instanceof Var && ((Var)tag).default_ != null) {
      asDoc.append("\n@default ").append(((Var)tag).default_);
    }
    if (tag instanceof Member && ((Member)tag).since != null) {
      asDoc.append("\n@since ").append(((Member)tag).since);
    }
    if (tag.properties != null && !tag.properties.isEmpty()) {
      if (paramPrefix != null) {
        for (Param property : tag.properties) {
          asDoc.append("\n   * @param ");
          String propertyType = convertType(property.type);
          if (propertyType != null && !"*".equals(propertyType)) {
            asDoc.append("{").append(propertyType).append("} ");
          }
          String qualifiedPropertyName = paramPrefix + "." + property.name;
          if (property.optional) {
            asDoc.append("[").append(qualifiedPropertyName).append("]");
          } else {
            asDoc.append(qualifiedPropertyName);
          }
          asDoc.append(" ");
          asDoc.append(toAsDoc(property, qualifiedPropertyName));
        }
      } else {
        asDoc.append("\n   * 
");
        for (Param property : tag.properties) {
          asDoc.append("\n   *   
");
          asDoc.append("").append(property.name).append("");
          String propertyType = convertType(property.type);
          if (propertyType != null && !"*".equals(propertyType)) {
            asDoc.append(" : ").append(propertyType);
          }
          if (property.optional) {
            asDoc.append(" (optional)");
          }
          String propertyAsDoc = toAsDoc(property);
          if (!propertyAsDoc.trim().isEmpty()) {
            asDoc.append("\n   * ").append(propertyAsDoc).append("\n   *   ");
          }
          asDoc.append("
");
        }
        asDoc.append("\n   * 
");
      }
    }

    String result = asDoc.toString();
    if (tag instanceof Param) {
      // suppress multiple new lines in nested ASDoc, or IDEA will treat everything following as top-level ASDoc:
      result = result.replaceAll("\n+", "\n");
    }
    return result;
  }

  private static String toAsDoc(String doc) {
    // remove  and :
    String asDoc = doc.replaceAll("", "");
    asDoc = asDoc.trim();
    if (asDoc.startsWith("
")) {
      // remove 
...
 around first paragraph:
      asDoc = asDoc.substring(3);
      int endTagPos = asDoc.indexOf("
");
      if (endTagPos != -1) {
        asDoc = asDoc.substring(0, endTagPos) + asDoc.substring(endTagPos + 4);
      }
    }
    if (asDoc.startsWith("{")) {
      int closingBracePos = asDoc.indexOf("} ");
      if (closingBracePos != -1) {
        asDoc = asDoc.substring(closingBracePos + 2);
      }
    }
    // add closing "/" on  elements:
    asDoc = asDoc.replaceAll("(]*[^/])>", "$1/>");
    return asDoc;
  }

  private static void setDefaultValue(ParamModel paramModel, Param param) {
    String defaultValue = param.default_;
    if (defaultValue != null) {
      if (NON_COMPILE_TIME_CONSTANT_INITIALIZERS.contains(defaultValue)) {
        paramModel.setAsdoc("(Default " + defaultValue + ") " + paramModel.getAsdoc());
        defaultValue = null;
        param.optional = true; // only in case it is set inconsistently...
      }
    }
    if (defaultValue == null && param.optional) {
      defaultValue = AS3Type.getDefaultValue(paramModel.getType());
    }
    if (defaultValue != null && "String".equals(param.type) &&
            !(defaultValue.equals("null") || defaultValue.startsWith("'") || defaultValue.startsWith("\""))) {
      defaultValue = CompilerUtils.quote(defaultValue);
    }
    paramModel.setValue(defaultValue);
  }

  private static String convertName(String name) {
    name = replaceSeparatorByCamelCase(name, '-');
    return "is".equals(name) ? "matches" :
            "class".equals(name) ? "cls" :
                    "this".equals(name) ? "source" :
                            "new".equals(name) ? "new_" :
                                    "default".equals(name) ? "default_" :
                                            name;
  }

  private static String replaceSeparatorByCamelCase(String string, char separator) {
    while (true) {
      int separatorPos = string.indexOf(separator);
      if (separatorPos == -1) {
        break;
      }
      string = string.substring(0, separatorPos) + string.substring(separatorPos + 1, separatorPos + 2).toUpperCase() + string.substring(separatorPos + 2);
    }
    return string;
  }

  private static String convertToInterface(String className) {
    if (className == null || !interfaces.contains(className)) {
      return null;
    }
    String interfaceName = "I" + CompilerUtils.className(className);
    if (interfaceName.endsWith("Impl")) {
      interfaceName = interfaceName.substring(0, interfaceName.length() - 4);
    }
    return CompilerUtils.qName(CompilerUtils.packageName(className), interfaceName);
  }

  private static String convertType(String extType) {
    if (extType == null) {
      return null;
    }
    if ("undefined".equals(extType) || "null".equals(extType)) {
      return "void";
    }
    if ("number".equals(extType) || "boolean".equals(extType) || "string".equals(extType)) {
      return capitalize(extType);
    }
    if ("HTMLElement".equals(extType) || "Event".equals(extType) || "XMLHttpRequest".equals(extType)) {
      return "js." + extType;
    }
    if ("google.maps.Map".equals(extType) || "CSSStyleSheet".equals(extType) || "CSSStyleRule".equals(extType)) {
      return "Object"; // no AS3 type yet
    }
    // enums and ad-hoc enums:
    if (extType.startsWith("Ext.enums.") || extType.matches("(['\"].*['\"]/)*['\"].*['\"]")) {
      return "String";
    }
    // array / vararg syntax:
    if (extType.endsWith("...") || extType.matches("[a-zA-Z0-9._$<>]+\\[\\]")) {
      return "Array";
    }
    if (!extType.matches("[a-zA-Z0-9._$<>]+") || "Mixed".equals(extType)) {
      return "*"; // TODO: join types? rather use Object? simulate overloading by splitting into several methods?
    }
    if (JsCodeGenerator.PRIMITIVES.contains(extType)) {
      return extType;
    }
    ExtClass extClass = extJsApi.getExtClass(extType);
    if (extClass == null) {
      //throw new RuntimeException("Fatal: No Ext class '" + extType + "' found.");
      System.err.println("Warning: No Ext class '" + extType + "' found, falling back to Object");
      return "Object";
    }
    String qName = getActionScriptName(extClass);
    if (qName == null) {
      // try with super class:
      return convertType(extClass.extends_);
    }
    if (isSingleton(extClass)) {
      qName = CompilerUtils.qName(CompilerUtils.packageName(qName), "S" + CompilerUtils.className(qName));
    }
    return qName;
  }

  // normalize / use alternate class name if it can be found in reference API:
  private static void removePrivateApiClasses() {
    // collect all non-public classes:
    Set privateClasses = new HashSet();

    for (ExtClass extClass: extClasses) {
      // correct wrong usage of Ext.util.Observable as a mixin:
      replaceMixin(extClass, "Ext.util.Observable", "Ext.mixin.Observable");
      // simplify "extends Base mixins Mixin-that-extends-Base" to "extends Mixin-that-extends-Base":
      replaceMixinByExtends(extClass, "Ext.dom.Element");

      // all classes that are mapped explicitly must remain part of the API:
      if (getActionScriptName(extClass) != null) {
        continue;
      }

      // Classes to remove from public API:
      // explicitly marked private OR
      // a built-in type / class OR
      // Ext enums - they are just for documentation, so treat them as private API, too.
      if (extClass.private_ || JsCodeGenerator.PRIMITIVES.contains(extClass.name) || extClass.name.startsWith("Ext.enums.")) {
        privateClasses.add(extClass);
      }
    }

    // all super classes of public classes must be public:
    for (ExtClass extClass : extClasses) {
      if (!privateClasses.contains(extClass)) {
        markPublic(privateClasses, extClass.name);
      }
    }

    extClasses.removeAll(privateClasses);

    System.out.println("*****ADD TO JS-AS-NAME-MAPPING:");
    for (ExtClass extClass : extClasses) {
      if (getActionScriptName(extClass) == null) {
        System.out.println(extClass.name + " = " + extClass.name.substring(0, 1).toLowerCase() + extClass.name.substring(1));
      }
    }
    System.out.println("*****END ADD TO JS-AS-NAME-MAPPING");
  }

  private static CompilationUnitModel getReferenceDeclaration(String jooClassName) {
    List referenceDeclarations = getReferenceDeclarations(jooClassName);
    return referenceDeclarations.isEmpty() ? null : referenceDeclarations.get(0);
  }

  private static List getReferenceDeclarations(String jooClassName) {
    return referenceApi.getCompilationUnitModels(jooClassName);
  }

  private static void replaceMixin(ExtClass extClass, String mixinImpl, String mixin) {
    // instead of implementing mixinImpl, a class has to implement its interface:
    int mixinImplIndex = extClass.mixins.indexOf(mixinImpl);
    if (mixinImplIndex != -1) {
      extClass.mixins.set(mixinImplIndex, mixin);
    }
    replaceMixinByExtends(extClass, mixin);
  }

  private static void replaceMixinByExtends(ExtClass extClass, String mixin) {
    // instead of extending Ext.Base and implementing the mixin, it is simpler to extend the mixin
    if ("Ext.Base".equals(extClass.extends_) && extClass.mixins.contains(mixin)) {
      extClass.mixins.remove(mixin);
      extClass.extends_ = mixin;
    }
  }

  private static void markPublic(Set privateClasses, String extClassName) {
    ExtClass extClass = extJsApi.getExtClass(extClassName);
    //noinspection StatementWithEmptyBody
    if (privateClasses.remove(extClass)) {
      //System.err.println("*** marked public because it is a super class: " + extClass.name);
    }
    if (extClass.extends_ != null) {
      markPublic(privateClasses, extClass.extends_);
    }
    for (String mixin : extClass.mixins) {
      markPublic(privateClasses, mixin);
    }
  }

  // normalize / use alternate class name if it can be found in reference API:
  private static String getActionScriptName(ExtClass extClass) {
    String normalizedClassName = jsAsNameMappingProperties.getProperty(extClass.name);
    if (normalizedClassName == null) {
      // System.err.println(String.format("Ext JS class name %s not mapped to AS.", extClass.name));
      // throw new IllegalStateException("unmapped class " + extClass.name);
      return null;
    }
    return normalizedClassName;
  }


  private static void annotateBindableConfigProperties() {
    for (CompilationUnitModel compilationUnitModel : compilationUnitModelRegistry.getCompilationUnitModels()) {
      ClassModel classModel = compilationUnitModel.getClassModel();
      if (classModel != null) {
        annotateBindableConfigProperties(classModel);
      }
    }
  }

  private static void annotateBindableConfigProperties(ClassModel classModel) {
    List members = classModel.getMembers();
    // two-pass to get the order of @see #get() and @see #set() right:
    // first, the getters:
    for (MemberModel member : members) {
      if (member.isGetter()) {
        annotateBindableConfigProperty(classModel, (MethodModel) member);
      }
    }
    // then, the setters:
    for (MemberModel member : members) {
      if (member.isSetter()) {
        annotateBindableConfigProperty(classModel, (MethodModel) member);
      }
    }
  }

  private static void annotateBindableConfigProperty(ClassModel classModel, MethodModel accessor) {
    if (accessor.getAnnotations(Jooc.EXT_CONFIG_ANNOTATION_NAME).isEmpty()) {
      return;
    }
    String prefix = accessor.getMethodType().toString();

    String propertyType = getMethodType(accessor, accessor.getMethodType());
    if (propertyType == null) {
      warnConfigProperty(prefix + " property accessor without type", classModel, accessor);
      return;
    }

    String methodName = prefix + capitalize(accessor.getName());
    MethodModel method = compilationUnitModelRegistry.resolveMethod(classModel, null, methodName);
    if (method == null) {
      warnConfigProperty("no matching " + prefix + "ter method", classModel, accessor);
      return;
    }

    List methodParams = method.getParams();
    if (accessor.isSetter() && methodParams.isEmpty()) {
      warnConfigProperty(String.format("matching setter method '%s' without parameters. "
              + "Still marking property as [Bindable] - assuming it's compatible at runtime.",
              method.getName()), classModel, accessor);
    } else {
      List moreParams = accessor.isSetter() ? methodParams.subList(1, methodParams.size()) : methodParams;
      for (ParamModel param : moreParams) {
        if (!param.isOptional()) {
          warnConfigProperty(String.format("matching %ster method '%s' has additional non-optional parameter '%s'",
                  prefix, method.getName(), param.getName()), classModel, accessor);
          return;
        }
      }

      String methodType = getMethodType(method, accessor.getMethodType());
      if (!propertyType.equals(methodType)) {
        boolean probablyCompatible = "*".equals(propertyType) || "*".equals(methodType)
                || "Object".equals(propertyType) || "Object".equals(methodType);
        if (!probablyCompatible) {
          warnConfigProperty(String.format("type '%s' does not match method '%s' with type '%s'",
                  propertyType, method.getName(), methodType), classModel, accessor);
          return;
        }

        warnConfigProperty(String.format("type '%s' does not quite match method '%s' with type '%s'. "
                + "Still marking property as [Bindable] - assuming it's compatible at runtime.",
                propertyType, method.getName(), methodType), classModel, accessor);
      }
    }

    accessor.addAnnotation(new AnnotationModel(Jooc.BINDABLE_ANNOTATION_NAME));
    MethodModel documentedMethod = null;
    if (accessor.isSetter()) {
      documentedMethod = classModel.getMethod(accessor.isStatic(), MethodType.GET, accessor.getName());
    }
    if (documentedMethod == null) {
      documentedMethod = accessor;
    }
    String asDoc = documentedMethod.getAsdoc();
    documentedMethod.setAsdoc((asDoc == null ? "" : asDoc) + "\n@see #" + methodName + "()");
  }

  private static String getMethodType(MethodModel method, MethodType methodType) {
    if (methodType == MethodType.GET) {
      return method.getType();
    }
    List propertySetterParams = method.getParams();
    if (propertySetterParams.isEmpty()) {
      return null;
    }
    return propertySetterParams.get(0).getType();
  }

  private static void warnConfigProperty(String message, ClassModel classModel, MethodModel propertySetter) {
    System.err.format("!!! Config property %s#%s: %s\n", classModel.getName(), propertySetter.getName(), message);
  }


}