@Override
  public String updateAndGetCompilationUnitContents(
      final String fileIdentifier, final ClassOrInterfaceTypeDetails cid) {
    // Validate parameters
    Validate.notBlank(fileIdentifier, "Oringinal unit path required");
    Validate.notNull(cid, "Type details required");

    // Load original compilation unit from file
    final File file = new File(fileIdentifier);
    String fileContents = "";
    try {
      fileContents = FileUtils.readFileToString(file);
    } catch (final IOException ignored) {
    }
    if (StringUtils.isBlank(fileContents)) {
      return getCompilationUnitContents(cid);
    }
    CompilationUnit compilationUnit;
    try {
      compilationUnit = JavaParser.parse(new ByteArrayInputStream(fileContents.getBytes()));

    } catch (final IOException e) {
      throw new IllegalStateException(e);
    } catch (final ParseException e) {
      throw new IllegalStateException(e);
    }

    // Load new compilation unit from cid information
    final String cidContents = getCompilationUnitContents(cid);
    CompilationUnit cidCompilationUnit;
    try {
      cidCompilationUnit = JavaParser.parse(new ByteArrayInputStream(cidContents.getBytes()));

    } catch (final IOException e) {
      throw new IllegalStateException(e);
    } catch (final ParseException e) {
      throw new IllegalStateException(e);
    }

    // Update package
    if (!compilationUnit
        .getPackage()
        .getName()
        .getName()
        .equals(cidCompilationUnit.getPackage().getName().getName())) {
      compilationUnit.setPackage(cidCompilationUnit.getPackage());
    }

    // Update imports
    UpdateCompilationUnitUtils.updateCompilationUnitImports(compilationUnit, cidCompilationUnit);

    // Update types
    UpdateCompilationUnitUtils.updateCompilationUnitTypes(compilationUnit, cidCompilationUnit);

    // Return new contents
    return compilationUnit.toString();
  }
  @Override
  public final String getCompilationUnitContents(final ClassOrInterfaceTypeDetails cid) {
    Validate.notNull(cid, "Class or interface type details are required");
    // Create a compilation unit to store the type to be created
    final CompilationUnit compilationUnit = new CompilationUnit();

    // NB: this import list is replaced at the end of this method by a
    // sorted version
    compilationUnit.setImports(new ArrayList<ImportDeclaration>());

    if (!cid.getName().isDefaultPackage()) {
      compilationUnit.setPackage(
          new PackageDeclaration(
              ASTHelper.createNameExpr(cid.getName().getPackage().getFullyQualifiedPackageName())));
    }

    // Add the class of interface declaration to the compilation unit
    final List<TypeDeclaration> types = new ArrayList<TypeDeclaration>();
    compilationUnit.setTypes(types);

    updateOutput(compilationUnit, null, cid, null);

    return compilationUnit.toString();
  }
Example #3
0
  public Boolean visit(CompilationUnit n1, Node arg) {
    CompilationUnit n2 = (CompilationUnit) arg;

    if (!nodeEquals(n1.getPackage(), n2.getPackage())) {
      return Boolean.FALSE;
    }

    if (!nodesEquals(n1.getImports(), n2.getImports())) {
      return Boolean.FALSE;
    }

    if (!nodesEquals(n1.getTypes(), n2.getTypes())) {
      return Boolean.FALSE;
    }

    return Boolean.TRUE;
  }
  /**
   * Appends the presented class to the end of the presented body declarations. The body
   * declarations appear within the presented compilation unit. This is used to progressively build
   * inner types.
   *
   * @param compilationUnit the work-in-progress compilation unit (required)
   * @param enclosingCompilationUnitServices
   * @param cid the new class to add (required)
   * @param parent the class body declarations a subclass should be added to (may be null, which
   *     denotes a top-level type within the compilation unit)
   */
  private void updateOutput(
      final CompilationUnit compilationUnit,
      CompilationUnitServices enclosingCompilationUnitServices,
      final ClassOrInterfaceTypeDetails cid,
      final List<BodyDeclaration> parent) {
    // Append the new imports this class declares
    Validate.notNull(
        compilationUnit.getImports(),
        "Compilation unit imports should be non-null when producing type '%s'",
        cid.getName());
    for (final ImportMetadata importType : cid.getRegisteredImports()) {
      ImportDeclaration importDeclaration;

      if (!importType.isAsterisk()) {
        NameExpr typeToImportExpr;
        if (importType.getImportType().getEnclosingType() == null) {
          typeToImportExpr =
              new QualifiedNameExpr(
                  new NameExpr(
                      importType.getImportType().getPackage().getFullyQualifiedPackageName()),
                  importType.getImportType().getSimpleTypeName());
        } else {
          typeToImportExpr =
              new QualifiedNameExpr(
                  new NameExpr(
                      importType.getImportType().getEnclosingType().getFullyQualifiedTypeName()),
                  importType.getImportType().getSimpleTypeName());
        }

        importDeclaration = new ImportDeclaration(typeToImportExpr, importType.isStatic(), false);
      } else {
        importDeclaration =
            new ImportDeclaration(
                new NameExpr(importType.getImportPackage().getFullyQualifiedPackageName()),
                importType.isStatic(),
                importType.isAsterisk());
      }

      JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(
          importDeclaration, importType.getCommentStructure());

      compilationUnit.getImports().add(importDeclaration);
    }

    // Create a class or interface declaration to represent this actual type
    final int javaParserModifier = JavaParserUtils.getJavaParserModifier(cid.getModifier());
    TypeDeclaration typeDeclaration;
    ClassOrInterfaceDeclaration classOrInterfaceDeclaration;

    // Implements handling
    final List<ClassOrInterfaceType> implementsList = new ArrayList<ClassOrInterfaceType>();
    for (final JavaType current : cid.getImplementsTypes()) {
      implementsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
    }

    if (cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE
        || cid.getPhysicalTypeCategory() == PhysicalTypeCategory.CLASS) {
      final boolean isInterface = cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE;

      if (parent == null) {
        // Top level type
        typeDeclaration =
            new ClassOrInterfaceDeclaration(
                javaParserModifier,
                isInterface,
                cid.getName()
                    .getNameIncludingTypeParameters()
                    .replace(cid.getName().getPackage().getFullyQualifiedPackageName() + ".", ""));
        classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
      } else {
        // Inner type
        typeDeclaration =
            new ClassOrInterfaceDeclaration(
                javaParserModifier, isInterface, cid.getName().getSimpleTypeName());
        classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;

        if (cid.getName().getParameters().size() > 0) {
          classOrInterfaceDeclaration.setTypeParameters(new ArrayList<TypeParameter>());

          for (final JavaType param : cid.getName().getParameters()) {
            NameExpr pNameExpr =
                JavaParserUtils.importTypeIfRequired(
                    cid.getName(), compilationUnit.getImports(), param);
            final String tempName =
                StringUtils.replace(pNameExpr.toString(), param.getArgName() + " extends ", "", 1);
            pNameExpr = new NameExpr(tempName);
            final ClassOrInterfaceType pResolvedName =
                JavaParserUtils.getClassOrInterfaceType(pNameExpr);
            classOrInterfaceDeclaration
                .getTypeParameters()
                .add(
                    new TypeParameter(
                        param.getArgName().getSymbolName(),
                        Collections.singletonList(pResolvedName)));
          }
        }
      }

      // Superclass handling
      final List<ClassOrInterfaceType> extendsList = new ArrayList<ClassOrInterfaceType>();
      for (final JavaType current : cid.getExtendsTypes()) {
        if (!OBJECT.equals(current)) {
          extendsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
        }
      }
      if (extendsList.size() > 0) {
        classOrInterfaceDeclaration.setExtends(extendsList);
      }

      // Implements handling
      if (implementsList.size() > 0) {
        classOrInterfaceDeclaration.setImplements(implementsList);
      }
    } else {
      typeDeclaration = new EnumDeclaration(javaParserModifier, cid.getName().getSimpleTypeName());
    }
    typeDeclaration.setMembers(new ArrayList<BodyDeclaration>());

    Validate.notNull(
        typeDeclaration.getName(), "Missing type declaration name for '%s'", cid.getName());

    // If adding a new top-level type, must add it to the compilation unit
    // types
    Validate.notNull(
        compilationUnit.getTypes(),
        "Compilation unit types must not be null when attempting to add '%s'",
        cid.getName());

    if (parent == null) {
      // Top-level class
      compilationUnit.getTypes().add(typeDeclaration);
    } else {
      // Inner class
      parent.add(typeDeclaration);
    }

    // If the enclosing CompilationUnitServices was not provided a default
    // CompilationUnitServices needs to be created
    if (enclosingCompilationUnitServices == null) {
      // Create a compilation unit so that we can use JavaType*Metadata
      // static methods directly
      enclosingCompilationUnitServices =
          new CompilationUnitServices() {
            @Override
            public JavaPackage getCompilationUnitPackage() {
              return cid.getName().getPackage();
            }

            @Override
            public JavaType getEnclosingTypeName() {
              return cid.getName();
            }

            @Override
            public List<ImportDeclaration> getImports() {
              return compilationUnit.getImports();
            }

            @Override
            public List<TypeDeclaration> getInnerTypes() {
              return compilationUnit.getTypes();
            }

            @Override
            public PhysicalTypeCategory getPhysicalTypeCategory() {
              return cid.getPhysicalTypeCategory();
            }
          };
    }

    final CompilationUnitServices finalCompilationUnitServices = enclosingCompilationUnitServices;
    // A hybrid CompilationUnitServices must be provided that references the
    // enclosing types imports and package
    final CompilationUnitServices compilationUnitServices =
        new CompilationUnitServices() {
          @Override
          public JavaPackage getCompilationUnitPackage() {
            return finalCompilationUnitServices.getCompilationUnitPackage();
          }

          @Override
          public JavaType getEnclosingTypeName() {
            return cid.getName();
          }

          @Override
          public List<ImportDeclaration> getImports() {
            return finalCompilationUnitServices.getImports();
          }

          @Override
          public List<TypeDeclaration> getInnerTypes() {
            return compilationUnit.getTypes();
          }

          @Override
          public PhysicalTypeCategory getPhysicalTypeCategory() {
            return cid.getPhysicalTypeCategory();
          }
        };

    // Add type annotations
    final List<AnnotationExpr> annotations = new ArrayList<AnnotationExpr>();
    typeDeclaration.setAnnotations(annotations);
    for (final AnnotationMetadata candidate : cid.getAnnotations()) {
      JavaParserAnnotationMetadataBuilder.addAnnotationToList(
          compilationUnitServices, annotations, candidate);
    }

    // ROO-3834: Generating default Javadoc inside class if class doesn't contains JavaDoc
    List<Comment> classComments = compilationUnit.getComments();
    if (classComments == null || classComments.isEmpty()) {
      CommentStructure defaultCommentStructure = new CommentStructure();

      String defaultComment =
          "/**\n * = "
              .concat(cid.getType().getSimpleTypeName())
              .concat("\n *\n * TODO Auto-generated class documentation\n *\n */\n");

      defaultCommentStructure.addComment(
          new JavadocComment(defaultComment), CommentLocation.BEGINNING);

      if (annotations.isEmpty()) {
        JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(
            typeDeclaration, defaultCommentStructure);
      } else {
        // If exists some annotation, include comment before the existing annotations
        AnnotationExpr firstAnnotation = annotations.get(0);
        JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(
            firstAnnotation, defaultCommentStructure);
      }
    }

    // Add enum constants and interfaces
    if (typeDeclaration instanceof EnumDeclaration && cid.getEnumConstants().size() > 0) {
      final EnumDeclaration enumDeclaration = (EnumDeclaration) typeDeclaration;

      final List<EnumConstantDeclaration> constants = new ArrayList<EnumConstantDeclaration>();
      enumDeclaration.setEntries(constants);

      for (final JavaSymbolName constant : cid.getEnumConstants()) {
        addEnumConstant(constants, constant);
      }

      // Implements handling
      if (implementsList.size() > 0) {
        enumDeclaration.setImplements(implementsList);
      }
    }

    // Add fields
    for (final FieldMetadata candidate : cid.getDeclaredFields()) {
      JavaParserFieldMetadataBuilder.addField(
          compilationUnitServices, typeDeclaration.getMembers(), candidate);
    }

    // Add constructors
    for (final ConstructorMetadata candidate : cid.getDeclaredConstructors()) {
      JavaParserConstructorMetadataBuilder.addConstructor(
          compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
    }

    // Add methods
    for (final MethodMetadata candidate : cid.getDeclaredMethods()) {
      JavaParserMethodMetadataBuilder.addMethod(
          compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
    }

    // Add inner types
    for (final ClassOrInterfaceTypeDetails candidate : cid.getDeclaredInnerTypes()) {
      updateOutput(
          compilationUnit, compilationUnitServices, candidate, typeDeclaration.getMembers());
    }

    final HashSet<String> imported = new HashSet<String>();
    final ArrayList<ImportDeclaration> imports = new ArrayList<ImportDeclaration>();
    for (final ImportDeclaration importDeclaration : compilationUnit.getImports()) {
      JavaPackage importPackage = null;
      JavaType importType = null;
      if (importDeclaration.isAsterisk()) {
        importPackage = new JavaPackage(importDeclaration.getName().toString());
      } else {
        importType = new JavaType(importDeclaration.getName().toString());
        importPackage = importType.getPackage();
      }

      if (importPackage.equals(cid.getName().getPackage()) && importDeclaration.isAsterisk()) {
        continue;
      }

      if (importPackage.equals(cid.getName().getPackage())
          && importType != null
          && importType.getEnclosingType() == null) {
        continue;
      }

      if (importType != null && importType.equals(cid.getName())) {
        continue;
      }

      if (!imported.contains(importDeclaration.getName().toString())) {
        imports.add(importDeclaration);
        imported.add(importDeclaration.getName().toString());
      }
    }

    Collections.sort(
        imports,
        new Comparator<ImportDeclaration>() {
          @Override
          public int compare(
              final ImportDeclaration importDeclaration,
              final ImportDeclaration importDeclaration1) {
            return importDeclaration
                .getName()
                .toString()
                .compareTo(importDeclaration1.getName().toString());
          }
        });

    compilationUnit.setImports(imports);
  }