@Override public void visitClassDef(GroovySourceAST t, int visit) { if (visit == OPENING_VISIT) { SimpleGroovyClassDoc parent = getCurrentClassDoc(); String shortName = getIdentFor(t); String className = shortName; if (parent != null && isNested() && !insideAnonymousInnerClass()) { className = parent.name() + "." + className; } else { foundClasses = new HashMap<String, SimpleGroovyClassDoc>(); } SimpleGroovyClassDoc current = (SimpleGroovyClassDoc) classDocs.get(packagePath + FS + className); if (current == null) { current = new SimpleGroovyClassDoc(importedClassesAndPackages, aliases, className, links); current.setGroovy(isGroovy); } current.setRawCommentText(getJavaDocCommentsBeforeNode(t)); current.setFullPathName(packagePath + FS + current.name()); current.setTokenType(t.getType()); current.setNameWithTypeArgs(getIdentPlusTypeArgsFor(t)); processAnnotations(t, current); processModifiers(t, current); classDocs.put(current.getFullPathName(), current); foundClasses.put(shortName, current); if (parent != null) { parent.addNested(current); current.setOuter(parent); } } }
@Override public void visitMethodDef(GroovySourceAST t, int visit) { if (visit == OPENING_VISIT && !insideEnum && !insideAnonymousInnerClass()) { SimpleGroovyClassDoc currentClassDoc = getCurrentClassDoc(); if (currentClassDoc == null) { // assume we have a script if ("true".equals(properties.getProperty("processScripts", "true"))) { currentClassDoc = new SimpleGroovyClassDoc(importedClassesAndPackages, aliases, className, links); currentClassDoc.setFullPathName(packagePath + FS + className); currentClassDoc.setPublic(true); currentClassDoc.setScript(true); currentClassDoc.setGroovy(isGroovy); currentClassDoc.setSuperClassName("groovy/lang/Script"); if ("true".equals(properties.getProperty("includeMainForScripts", "true"))) { currentClassDoc.add(createMainMethod(currentClassDoc)); } classDocs.put(currentClassDoc.getFullPathName(), currentClassDoc); if (foundClasses == null) { foundClasses = new HashMap<String, SimpleGroovyClassDoc>(); } foundClasses.put(className, currentClassDoc); } else { return; } } SimpleGroovyMethodDoc currentMethodDoc = createMethod(t, currentClassDoc); currentClassDoc.add(currentMethodDoc); } }
private void postProcessClassDocs() { for (GroovyClassDoc groovyClassDoc : classDocs.values()) { SimpleGroovyClassDoc classDoc = (SimpleGroovyClassDoc) groovyClassDoc; // potentially add default constructor to class docs (but not interfaces) if (classDoc.isClass()) { GroovyConstructorDoc[] constructors = classDoc.constructors(); if (constructors != null && constructors.length == 0) { // add default constructor to doc // name of class for the constructor GroovyConstructorDoc constructorDoc = new SimpleGroovyConstructorDoc(classDoc.name(), classDoc); // don't forget to tell the class about this default constructor. classDoc.add(constructorDoc); } } } }
private void setUpImports(String packagePath, List<LinkArgument> links, boolean isGroovy, String className) { importedClassesAndPackages.add(packagePath + "/*"); // everything in this package if (isGroovy) { for (String pkg : ResolveVisitor.DEFAULT_IMPORTS) { importedClassesAndPackages.add(pkg.replace('.', '/') + "*"); } } else { importedClassesAndPackages.add("java/lang/*"); } SimpleGroovyClassDoc currentClassDoc = new SimpleGroovyClassDoc(importedClassesAndPackages, aliases, className, links); currentClassDoc.setFullPathName(packagePath + FS + className); currentClassDoc.setGroovy(isGroovy); classDocs.put(currentClassDoc.getFullPathName(), currentClassDoc); }
@Override public void visitExtendsClause(GroovySourceAST t, int visit) { SimpleGroovyClassDoc currentClassDoc = getCurrentClassDoc(); if (visit == OPENING_VISIT) { for (GroovySourceAST superClassNode : findTypeNames(t)) { String superClassName = extractName(superClassNode); if (currentClassDoc.isInterface()) { currentClassDoc.addInterfaceName(superClassName); } else { currentClassDoc.setSuperClassName(superClassName); } } } }
private GroovyClassDoc resolveClass(GroovyRootDoc rootDoc, String name) { if (isPrimitiveType(name)) return null; if (name.endsWith("[]")) { GroovyClassDoc componentClass = resolveClass(rootDoc, name.substring(0, name.length() - 2)); if (componentClass != null) return new ArrayClassDocWrapper(componentClass); return null; int slashIndex = name.lastIndexOf("/"); if (slashIndex < 1) { doc = resolveInternalClassDocFromImport(rootDoc, name); if (doc != null) return doc; for (GroovyClassDoc nestedDoc : nested) { if (slashIndex > 0) { shortname = name.substring(slashIndex + 1); c = resolveExternalFullyQualifiedClass(name); } else { c = resolveExternalClassFromImport(name); c = resolveFromJavaLang(name); GroovyClassDoc gcd = resolveClass(rootDoc, outerName); if (gcd instanceof ExternalGroovyClassDoc) { ExternalGroovyClassDoc egcd = (ExternalGroovyClassDoc) gcd; SimpleGroovyClassDoc innerClass = new SimpleGroovyClassDoc(importedClassesAndPackages, aliases, innerClassName); innerClass.setFullPathName(gcd.getFullPathName() + "." + innerClassName); return innerClass; if (hasAlias(name)) {
public void visitClassDef(GroovySourceAST t,int visit) { if (visit == OPENING_VISIT) { // todo is this correct for java + groovy src? String className = t.childOfType(GroovyTokenTypes.IDENT).getText(); currentClassDoc = (SimpleGroovyClassDoc) classDocs.get(packagePath + FS + className); if (currentClassDoc == null) { currentClassDoc = new SimpleGroovyClassDoc(importedClassesAndPackages, className, importedClassesAndPackages); } // comments String commentText = getJavaDocCommentsBeforeNode(t); currentClassDoc.setRawCommentText(commentText); currentClassDoc.setFullPathName(packagePath + FS + currentClassDoc.name()); classDocs.put(currentClassDoc.getFullPathName(), currentClassDoc); } }
private void adjustForAutomaticEnumMethods(SimpleGroovyClassDoc currentClassDoc) { SimpleGroovyMethodDoc valueOf = new SimpleGroovyMethodDoc("valueOf", currentClassDoc); valueOf.setRawCommentText("Returns the enum constant of this type with the specified name."); SimpleGroovyParameter parameter = new SimpleGroovyParameter("name"); parameter.setTypeName("String"); valueOf.add(parameter); valueOf.setReturnType(new SimpleGroovyType(currentClassDoc.name())); currentClassDoc.add(valueOf); SimpleGroovyMethodDoc values = new SimpleGroovyMethodDoc("values", currentClassDoc); values.setRawCommentText("Returns an array containing the constants of this enum type, in the order they are declared."); values.setReturnType(new SimpleGroovyType(currentClassDoc.name() + "[]")); currentClassDoc.add(values); }
private GroovyClassDoc resolveClass(GroovyRootDoc rootDoc, String name) { if (isPrimitiveType(name)) return null; GroovyClassDoc doc = ((SimpleGroovyRootDoc)rootDoc).classNamedExact(name); if (doc != null) return doc; int slashIndex = name.lastIndexOf("/"); if (slashIndex < 1) { doc = resolveInternalClassDocFromImport(rootDoc, name); if (doc != null) return doc; for (GroovyClassDoc nestedDoc : nested) { if (slashIndex > 0) { shortname = name.substring(slashIndex + 1); c = resolveExternalFullyQualifiedClass(name); } else { c = resolveExternalClassFromImport(name); SimpleGroovyClassDoc placeholder = new SimpleGroovyClassDoc(null, shortname); placeholder.setFullPathName(name); return placeholder;
public SimpleGroovyClassDocAssembler(String packagePath, String file, SourceBuffer sourceBuffer, List links) { this.sourceBuffer = sourceBuffer; this.packagePath = packagePath; this.links = links; stack = new Stack(); classDocs = new HashMap(); String className = file; if (file != null) { // todo: replace this simple idea of default class name int idx = file.lastIndexOf("."); className = file.substring(0,idx); } importedClassesAndPackages = new ArrayList(); importedClassesAndPackages.add(packagePath + "/*"); // everything in this package is automatically imported importedClassesAndPackages.add("groovy/lang/*"); // default imports in Groovy, from org.codehaus.groovy.control.ResolveVisitor.DEFAULT_IMPORTS importedClassesAndPackages.add("groovy/util/*"); // todo - non Groovy source files shouldn't import these, but let us import them for now, it won't hurt... currentClassDoc = new SimpleGroovyClassDoc(importedClassesAndPackages, className, links); currentClassDoc.setFullPathName(packagePath + FS + className); classDocs.put(currentClassDoc.getFullPathName(),currentClassDoc); previousJavaDocCommentPattern = Pattern.compile("(?s)/\\*\\*(.*?)\\*/"); }
private GroovyClassDoc resolveClass(GroovyRootDoc rootDoc, String name) { GroovyClassDoc doc = rootDoc.classNamed(name); if (doc != null) return doc; // The class is not in the tree being documented String shortname = name; int slashIndex = name.lastIndexOf("/"); Class c = null; if (slashIndex > 0) { shortname = name.substring(slashIndex + 1); c = resolveExternalClass(name); } else { c = resolveExternalClassFromImport(name); } if (c != null) { return new ExternalGroovyClassDoc(c); } // and we can't find it SimpleGroovyClassDoc placeholder = new SimpleGroovyClassDoc(null, shortname); placeholder.setFullPathName(name); return placeholder; }
@Override public void visitVariableDef(GroovySourceAST t, int visit) { if (visit == OPENING_VISIT && !insideAnonymousInnerClass() && isFieldDefinition()) { SimpleGroovyClassDoc currentClassDoc = getCurrentClassDoc(); if (currentClassDoc != null) { String fieldName = getIdentFor(t); currentFieldDoc = new SimpleGroovyFieldDoc(fieldName, currentClassDoc); currentFieldDoc.setRawCommentText(getJavaDocCommentsBeforeNode(t)); boolean isProp = processModifiers(t, currentFieldDoc); currentFieldDoc.setType(new SimpleGroovyType(getTypeOrDefault(t))); processAnnotations(t, currentFieldDoc); if (isProp) { currentClassDoc.addProperty(currentFieldDoc); } else { currentClassDoc.add(currentFieldDoc); } } } }
@Override public void visitAnnotationFieldDef(GroovySourceAST t, int visit) { if (isGroovy && visit == OPENING_VISIT) { // TODO shouldn't really be treating annotation fields as methods - remove this hack SimpleGroovyClassDoc currentClassDoc = getCurrentClassDoc(); SimpleGroovyMethodDoc currentMethodDoc = createMethod(t, currentClassDoc); String defaultText = getDefaultValue(t); if (defaultText != null) { String orig = currentMethodDoc.getRawCommentText(); currentMethodDoc.setRawCommentText(orig + "\n* @default " + defaultText); } currentClassDoc.add(currentMethodDoc); } else if (visit == OPENING_VISIT) { // if (visit == OPENING_VISIT) { visitVariableDef(t, visit); String defaultText = getDefaultValue(t); if (isGroovy) { currentFieldDoc.setPublic(true); } if (defaultText != null) { currentFieldDoc.setConstantValueExpression(defaultText); String orig = currentFieldDoc.getRawCommentText(); currentFieldDoc.setRawCommentText(orig + "\n* @default " + defaultText); } } }
public void resolve() { //resolve class names at the end of adding all files to the tree for (GroovyClassDoc groovyClassDoc : classDocs.values()) { SimpleGroovyClassDoc classDoc = (SimpleGroovyClassDoc) groovyClassDoc; classDoc.resolve(this); } }
public void visitExtendsClause(GroovySourceAST t,int visit) { if (visit == OPENING_VISIT) { GroovySourceAST superClassNode = t.childOfType(GroovyTokenTypes.IDENT); if (superClassNode != null) { String superClassName = superClassNode.getText(); currentClassDoc.setSuperClassName(superClassName); // un 'packaged' class name } } }
superClass = new SimpleGroovyClassDoc(null, superClassName); // dummy class with name, not to be put into main tree superClass = new SimpleGroovyClassDoc(null, "Object"); // dummy class representing java.lang.Object, not to be put into main tree
private GroovyClassDoc doResolveClass(final GroovyRootDoc rootDoc, final String name) { if (name.endsWith("[]")) { GroovyClassDoc componentClass = resolveClass(rootDoc, name.substring(0, name.length() - 2)); if (componentClass != null) return new ArrayClassDocWrapper(componentClass); return null; int slashIndex = name.lastIndexOf("/"); if (slashIndex < 1) { doc = resolveInternalClassDocFromImport(rootDoc, name); if (doc != null) return doc; for (GroovyClassDoc nestedDoc : nested) { if (slashIndex > 0) { shortname = name.substring(slashIndex + 1); c = resolveExternalFullyQualifiedClass(name); } else { c = resolveExternalClassFromImport(name); c = resolveFromJavaLang(name); GroovyClassDoc gcd = resolveClass(rootDoc, outerName); if (gcd instanceof ExternalGroovyClassDoc) { ExternalGroovyClassDoc egcd = (ExternalGroovyClassDoc) gcd; SimpleGroovyClassDoc innerClass = new SimpleGroovyClassDoc(importedClassesAndPackages, aliases, innerClassName); innerClass.setFullPathName(gcd.getFullPathName() + "." + innerClassName); return innerClass; if (hasAlias(name)) { String fullyQualifiedTypeName = getFullyQualifiedTypeNameForAlias(name);
@Override public void visitCtorIdent(GroovySourceAST t, int visit) { if (visit == OPENING_VISIT && !insideEnum && !insideAnonymousInnerClass()) { SimpleGroovyClassDoc currentClassDoc = getCurrentClassDoc(); SimpleGroovyConstructorDoc currentConstructorDoc = new SimpleGroovyConstructorDoc(currentClassDoc.name(), currentClassDoc); currentConstructorDoc.setRawCommentText(getJavaDocCommentsBeforeNode(t)); processModifiers(t, currentConstructorDoc); addParametersTo(t, currentConstructorDoc); processAnnotations(t, currentConstructorDoc); currentClassDoc.add(currentConstructorDoc); } }
private void setUpImports(String packagePath, List<LinkArgument> links, boolean isGroovy, String className) { importedClassesAndPackages.add(packagePath + "/*"); // everything in this package if (isGroovy) { for (String pkg : ResolveVisitor.DEFAULT_IMPORTS) { importedClassesAndPackages.add(pkg.replace('.', '/') + "*"); } } else { importedClassesAndPackages.add("java/lang/*"); } SimpleGroovyClassDoc currentClassDoc = new SimpleGroovyClassDoc(importedClassesAndPackages, aliases, className, links); currentClassDoc.setFullPathName(packagePath + FS + className); currentClassDoc.setGroovy(isGroovy); classDocs.put(currentClassDoc.getFullPathName(), currentClassDoc); }
@Override public void visitExtendsClause(GroovySourceAST t, int visit) { SimpleGroovyClassDoc currentClassDoc = getCurrentClassDoc(); if (visit == OPENING_VISIT) { for (GroovySourceAST superClassNode : findTypeNames(t)) { String superClassName = extractName(superClassNode); if (currentClassDoc.isInterface()) { currentClassDoc.addInterfaceName(superClassName); } else { currentClassDoc.setSuperClassName(superClassName); } } } }