/*
  * Ensures that getCorrespondingResource() returns a non-null value for a primary working copy.
  * (regression test for bug 44065 NPE during hot code replace)
  */
 public void testGetCorrespondingResource() throws CoreException {
   ICompilationUnit cu = null;
   try {
     cu = getCompilationUnit("P/X.java");
     cu.becomeWorkingCopy(null);
     assertResourceNamesEqual(
         "Unexpected resource", "X.java", new Object[] {cu.getCorrespondingResource()});
   } finally {
     if (cu != null) {
       cu.discardWorkingCopy();
     }
   }
 }
예제 #2
0
  /**
   * Gets the problems for a given src file.
   *
   * @param src The src file.
   * @param ids Array of problem ids to accept.
   * @return The problems.
   */
  public static IProblem[] getProblems(ICompilationUnit src, int[] ids) throws Exception {
    ICompilationUnit workingCopy = src.getWorkingCopy(null);

    ProblemRequestor requestor = new ProblemRequestor(ids);
    try {
      workingCopy.discardWorkingCopy();
      workingCopy.becomeWorkingCopy(requestor, null);
    } finally {
      workingCopy.discardWorkingCopy();
    }
    List<IProblem> problems = requestor.getProblems();
    return (IProblem[]) problems.toArray(new IProblem[problems.size()]);
  }
  /*
   * Tests that the same number of calls to discardWorkingCopy() is needed for primary working copy to be back
   * in compilation uint mode.
   */
  public void testDiscardWorkingCopy2() throws CoreException {
    ICompilationUnit cu = null;
    try {
      cu = getCompilationUnit("P/X.java");
      cu.becomeWorkingCopy(null);
      cu.becomeWorkingCopy(null);
      cu.becomeWorkingCopy(null);
      assertTrue("should be in working copy mode", cu.isWorkingCopy());

      cu.discardWorkingCopy();
      assertTrue("should still be in working copy mode", cu.isWorkingCopy());

      cu.discardWorkingCopy();
      cu.discardWorkingCopy();
      assertTrue("should no longer be in working copy mode", !cu.isWorkingCopy());
    } finally {
      if (cu != null) {
        int max = 3;
        while (cu.isWorkingCopy() && max-- > 0) {
          cu.discardWorkingCopy();
        }
      }
    }
  }
  /*
   * Tests that a primary working copy  is removed from its parent after it is discarded and
   * there is no underlying resource.
   */
  public void testDiscardWorkingCopy5() throws CoreException {
    ICompilationUnit cu = null;
    try {
      cu = getCompilationUnit("P/Y.java");
      cu.becomeWorkingCopy(null);

      cu.discardWorkingCopy();
      assertElementsEqual(
          "Unexpected children of default package",
          "X.java [in <default> [in <project root> [in P]]]",
          getPackage("/P").getChildren());
    } finally {
      if (cu != null) {
        cu.discardWorkingCopy();
      }
    }
  }
  /*
   * Ensures that searching takes the primary owner's working copies and the given working copies into account.
   * (regression test for bug 43300 SearchEngine(IWorkingCopy[] workingCopies) not backward compatible)
   */
  public void testSearch4() throws CoreException {
    ICompilationUnit primaryWorkingCopy = null;
    try {
      createFolder("P/p");
      createFile("/P/p/Y.java", "");
      primaryWorkingCopy = getCompilationUnit("P/p/Y.java");
      primaryWorkingCopy.becomeWorkingCopy(null);

      // create type Y in working copy
      primaryWorkingCopy.getBuffer().setContents("package p;\n" + "public class Y {\n" + "}");
      primaryWorkingCopy.makeConsistent(null);

      // create new working copy on X.java and add type X
      this.workingCopy = getCompilationUnit("P/p/X.java").getWorkingCopy(null);
      this.workingCopy.getBuffer().setContents("package p;\n" + "public class X {\n" + "}");
      this.workingCopy.makeConsistent(null);

      JavaSearchTests.JavaSearchResultCollector resultCollector =
          new JavaSearchTests.JavaSearchResultCollector();
      IJavaSearchScope scope =
          SearchEngine.createJavaSearchScope(new IJavaElement[] {primaryWorkingCopy.getParent()});
      SearchPattern pattern =
          SearchPattern.createPattern(
              "*",
              IJavaSearchConstants.TYPE,
              IJavaSearchConstants.DECLARATIONS,
              SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE);
      new SearchEngine(new ICompilationUnit[] {this.workingCopy})
          .search(
              pattern,
              new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
              scope,
              resultCollector,
              null);
      assertEquals("p/X.java p.X [X]\n" + "p/Y.java p.Y [Y]", resultCollector.toString());

    } finally {
      if (primaryWorkingCopy != null) {
        primaryWorkingCopy.discardWorkingCopy();
      }
      deleteFile("/P/p/Y.java");
    }
  }
예제 #6
0
  /**
   * @param insideTagBody
   * @param tagBody
   * @param templateTag
   * @param contextMap
   * @param placeHolders
   * @param spacesBeforeCursor
   * @param overrideMethods
   * @param exist
   * @param overWrite
   * @param type
   * @throws JavaModelException
   * @throws Exception
   */
  public void createClassFromTag(
      final String className,
      final Object packge,
      final Object project,
      String insideTagBody,
      final Map<String, Object> contextMap,
      final Map<String, Object> placeHolders,
      final ICompilationUnit compUnit,
      final String typeToCreate,
      final String spacesBeforeCursor,
      boolean overrideMethods,
      final boolean exist,
      final boolean overWrite)
      throws JavaModelException, Exception {
    final VersionControlPreferences versionControlPreferences =
        VersionControlPreferences.getInstance();
    if (typeToCreate.equals(ACTION_ENTITY.Innerclass.getValue())) {
      compUnit.becomeWorkingCopy(null);
      final File newFileObj = new File(compUnit.getResource().getLocationURI().toString());
      /*final FastCodeCheckinCache checkinCache = FastCodeCheckinCache.getInstance();
      checkinCache.getFilesToCheckIn().add(new FastCodeFileForCheckin(INITIATED, newFileObj.getAbsolutePath()));*/

      try {
        // addOrUpdateFileStatusInCache(newFileObj);
        final IType innerClassType = SourceUtil.createInnerClass(insideTagBody, compUnit);
        /*final boolean prjShared = !isEmpty(compUnit.getResource().getProject().getPersistentProperties());
        final boolean prjConfigured = !isEmpty(isPrjConfigured(compUnit.getResource().getProject().getName()));*/
        if ((Boolean) placeHolders.get(AUTO_CHECKIN)) {
          if (proceedWithAutoCheckin(newFileObj, compUnit.getResource().getProject())) {
            final IFile file = (IFile) innerClassType.getResource(); // .getLocationURI());
            List<FastCodeEntityHolder> chngsForType =
                ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED))
                    .get(file);
            if (chngsForType == null) {
              chngsForType = new ArrayList<FastCodeEntityHolder>();
              final List<Object> innerClassList = new ArrayList<Object>();
              innerClassList.add(new FastCodeType(innerClassType));
              chngsForType.add(new FastCodeEntityHolder(PLACEHOLDER_INNERCLASSES, innerClassList));
            } else {
              boolean isNew = true;
              Object fastCodeFieldList = null;
              for (final FastCodeEntityHolder fcEntityHolder : chngsForType) {
                if (fcEntityHolder.getEntityName().equals(PLACEHOLDER_INNERCLASSES)) {
                  fastCodeFieldList = fcEntityHolder.getFastCodeEntity();
                  isNew = false;
                  break;
                }
              }

              if (isNew) {
                fastCodeFieldList = new ArrayList<Object>();
                ((List<Object>) fastCodeFieldList).add(innerClassType);
                chngsForType.add(
                    new FastCodeEntityHolder(PLACEHOLDER_INNERCLASSES, fastCodeFieldList));
              } else {
                ((List<Object>) fastCodeFieldList).add(innerClassType);
              }

              /*Object innerClassList = chngsForType.get("innerClasses");
              if (innerClassList == null) {
              	innerClassList = new ArrayList<Object>();
              }
              ((List<Object>) innerClassList).add(new FastCodeType(innerClassType));
              chngsForType.put("innerClasses", innerClassList);*/
            }
            ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED))
                .put(file, chngsForType);
          }
        }
      } catch (final FastCodeRepositoryException ex) {
        ex.printStackTrace();
      }
      compUnit.commitWorkingCopy(false, null);
      compUnit.discardWorkingCopy();
      return;
    }

    final IJavaProject prj =
        project instanceof String ? getJavaProject((String) project) : (IJavaProject) project;
    /*IJavaProject prj = getJavaProject(project);// getJavaProject(attributes.get(PLACEHOLDER_PROJECT));
    if (prj == null) {
    	prj = getJavaProject(placeHolders.get(PLACEHOLDER_PROJECT) instanceof FastCodeProject ? ((FastCodeProject) placeHolders
    			.get(PLACEHOLDER_PROJECT)).getName() : (String) placeHolders.get(PLACEHOLDER_PROJECT));
    }

    if (prj == null) {
    	prj = this.javaProject = this.javaProject == null ? getWorkingJavaProjectFromUser() : this.javaProject;//did for j2ee base
    }*/
    if (prj == null) {
      throw new Exception("Can not continue without java  project.");
    }
    final String srcPath =
        typeToCreate.equals(ACTION_ENTITY.Test.getValue())
            ? getDefaultPathFromProject(prj, typeToCreate, EMPTY_STR)
            : getDefaultPathFromProject(prj, "source", EMPTY_STR);
    IPackageFragment pkgFrgmt = null;
    final TemplateTagsProcessor templateTagsProcessor = new TemplateTagsProcessor();
    if (packge instanceof String && !isEmpty((String) packge)
        || packge instanceof IPackageFragment) {
      pkgFrgmt =
          packge instanceof String
              ? templateTagsProcessor.getPackageFragment(
                  prj,
                  srcPath,
                  (String) packge,
                  typeToCreate.equals(ACTION_ENTITY.Test.getValue()) ? typeToCreate : "source")
              : (IPackageFragment) packge;
    }
    if (pkgFrgmt == null) {
      /*final boolean prjShared = !isEmpty(prj.getProject().getPersistentProperties());
      final boolean prjConfigured = !isEmpty(isPrjConfigured(prj.getProject().getName()));*/
      File file = null;
      if ((Boolean) placeHolders.get(AUTO_CHECKIN)) {
        if (proceedWithAutoCheckin(file, prj.getProject())) {
          final String prjURI = prj.getResource().getLocationURI().toString();
          final String path = prjURI.substring(prjURI.indexOf(COLON) + 1);
          final String newPackURL =
              path + srcPath + FILE_SEPARATOR + ((String) packge).replace(DOT, FILE_SEPARATOR);
          file = new File(newPackURL);
          // final FastCodeCheckinCache checkinCache = FastCodeCheckinCache.getInstance();
          addOrUpdateFileStatusInCache(file);
          // checkinCache.getFilesToCheckIn().add(new FastCodeFileForCheckin(INITIATED,
          // file.getAbsolutePath()));
        }
      }
      pkgFrgmt =
          templateTagsProcessor.createPackage(
              prj, (String) packge, typeToCreate, contextMap); // createPackage(prj,
      // attributes.get(PLACEHOLDER_PACKAGE));
      if ((Boolean) placeHolders.get(AUTO_CHECKIN)) {
        if (proceedWithAutoCheckin(null, prj.getProject())) {
          final IFile ifile = getIFileFromFile(file);
          List<FastCodeEntityHolder> chngsForType =
              ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)).get(ifile);
          if (chngsForType == null) {
            chngsForType = new ArrayList<FastCodeEntityHolder>();
            chngsForType.add(
                new FastCodeEntityHolder(PLACEHOLDER_PACKAGE, new FastCodePackage(pkgFrgmt)));
          }
          ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED))
              .put(ifile, chngsForType);
        }
      }
    }

    boolean createFileAlone = true;
    if ((Boolean) placeHolders.get(AUTO_CHECKIN)) {
      String path;
      try {
        final boolean prjShared =
            !isEmpty(pkgFrgmt.getResource().getProject().getPersistentProperties());
        final boolean prjConfigured =
            !isEmpty(isPrjConfigured(pkgFrgmt.getResource().getProject().getName()));
        createFileAlone = !(versionControlPreferences.isEnable() && prjShared && prjConfigured);

        final String prjURI = pkgFrgmt.getResource().getLocationURI().toString();
        path = prjURI.substring(prjURI.indexOf(COLON) + 1);
        final File newFileObj = new File(path + FORWARD_SLASH + className + DOT + JAVA_EXTENSION);
        if (versionControlPreferences.isEnable() && prjShared && prjConfigured) {
          final RepositoryService repositoryService = getRepositoryServiceClass();
          try {
            if (repositoryService.isFileInRepository(
                newFileObj)) { // && !MessageDialog.openQuestion(new Shell(), "File present in
                               // repository", "File already present in repository. Click yes to
                               // overwrite")) {
              /*MessageDialog.openWarning(new Shell(), "File present in repository", className + " is already present in repository. Please synchronise and try again.");
              return;*/
              createFileAlone =
                  MessageDialog.openQuestion(
                      new Shell(),
                      "File present in repository",
                      "File "
                          + newFileObj.getName()
                          + " already present in repository. Click yes to just create the file, No to return without any action.");
              if (!createFileAlone) {
                return;
              }
            }
          } catch (final Throwable th) {
            th.printStackTrace();
            createFileAlone = true;
          }
        }
        final FastCodeCheckinCache checkinCache = FastCodeCheckinCache.getInstance();
        checkinCache
            .getFilesToCheckIn()
            .add(new FastCodeFileForCheckin(INITIATED, newFileObj.getAbsolutePath()));

      } catch (final FastCodeRepositoryException ex) {
        ex.printStackTrace();
      }
    }

    /*if (parseClassName(insideTagBody) == null) {
    	insideTagBody = MODIFIER_PUBLIC + SPACE + typeToCreate + SPACE + className + SPACE + LEFT_CURL + NEWLINE + insideTagBody
    			+ NEWLINE + RIGHT_CURL;
    }*/

    final Object codeFormatter = createCodeFormatter(prj.getProject());
    if (!isEmpty(insideTagBody)) {
      insideTagBody = formatCode(insideTagBody.trim(), codeFormatter);
    }
    ICompilationUnit compilationUnit = null;
    if (exist) {
      if (overWrite) {
        final IType type = prj.findType(pkgFrgmt.getElementName() + DOT + className.trim());
        if (type.getCompilationUnit().hasUnsavedChanges()) {
          type.getCompilationUnit().save(new NullProgressMonitor(), true);
        }
        // type.getCompilationUnit().delete(true, new NullProgressMonitor());
        insideTagBody = buildClass(insideTagBody, pkgFrgmt, prj, className);

        // type.getCompilationUnit().getBuffer().setContents(insideTagBody);
        final ReplaceEdit replaceEdit =
            new ReplaceEdit(0, type.getCompilationUnit().getSource().length(), insideTagBody);
        type.getCompilationUnit().applyTextEdit(replaceEdit, new NullProgressMonitor());
        compilationUnit = type.getCompilationUnit();
        compilationUnit.becomeWorkingCopy(null);
        compilationUnit.commitWorkingCopy(false, null);
        compilationUnit.discardWorkingCopy();

        // refreshProject(prj.getElementName());
      } else {
        return;
      }
    } else {
      compilationUnit = SourceUtil.createClass(insideTagBody, pkgFrgmt, prj, className);
    }

    if (compilationUnit == null) {
      return;
    }
    if (!typeToCreate.equals(ACTION_ENTITY.Interface.getValue())) {
      if (compilationUnit.findPrimaryType().getSuperclassName() != null) {
        final IType superClassType =
            prj.findType(
                getFQNameFromFieldTypeName(
                    compilationUnit.findPrimaryType().getSuperclassName(), compilationUnit));
        if (superClassType != null && superClassType.exists()) {
          if (Flags.isAbstract(
              superClassType
                  .getFlags()) /*Modifier.isAbstract(Class.forName(superClassType.getFullyQualifiedName()).getModifiers())*/) {
            overrideMethods = true;
          }
        }
      }
      if (overrideMethods) {
        final String superInterfaces[] = compilationUnit.findPrimaryType().getSuperInterfaceNames();
        if (superInterfaces != null) {
          for (final String superInertafce : superInterfaces) {
            final IType superIntType =
                prj.findType(getFQNameFromFieldTypeName(superInertafce, compilationUnit));
            final FastCodeContext fastCodeContext = new FastCodeContext(superIntType);
            final CreateSimilarDescriptorClass createSimilarDescriptorClass =
                new CreateSimilarDescriptorClass.Builder().withClassType(CLASS_TYPE.CLASS).build();
            implementInterfaceMethods(
                superIntType,
                fastCodeContext,
                compilationUnit.findPrimaryType(),
                null,
                createSimilarDescriptorClass);
            final IType[] superInterfaceType = getSuperInterfacesType(superIntType);
            if (superInterfaceType != null) {
              for (final IType type : superInterfaceType) {
                if (type == null || !type.exists()) {
                  continue;
                }
                final FastCodeContext context = new FastCodeContext(type);
                implementInterfaceMethods(
                    type,
                    context,
                    compilationUnit.findPrimaryType(),
                    null,
                    createSimilarDescriptorClass);
              }
            }
          }
        }
        overrideBaseClassMethods(compilationUnit);
      }
    }
    /*
     * final IType newType = compilationUnit.findPrimaryType(); String
     * superClassName = newType.getSuperclassName(); if
     * (!isEmpty(superClassName)) { final IType superClassType =
     * prj.findType(getFQNameFromFieldTypeName(newType.getSuperclassName(),
     * newType.getCompilationUnit())); final FastCodeContext fastCodeContext
     * = new FastCodeContext(superClassType); final
     * CreateSimilarDescriptorClass createSimilarDescriptorClass = new
     * CreateSimilarDescriptorClass.Builder().withClassType(
     * CLASS_TYPE.CLASS).build(); for (final IMethod method :
     * superClassType.getMethods()) { if (method.isConstructor()) {
     * overrideConstructor(method, newType); final MethodBuilder
     * methodBuilder = new SimilarMethodBuilder(fastCodeContext);
     * methodBuilder.buildMethod(method, newType, null,
     * createSimilarDescriptorClass); } } }
     */
    contextMap.put(
        "Class_" + compilationUnit.getElementName(),
        new FastCodeObject(compilationUnit, ACTION_ENTITY.Class.getValue()));

    if (!createFileAlone) {
      final IFile fileObj =
          (IFile) compilationUnit.findPrimaryType().getResource(); // .getLocationURI());
      List<FastCodeEntityHolder> chngsForType =
          ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)).get(fileObj);
      if (chngsForType == null) {
        chngsForType = new ArrayList<FastCodeEntityHolder>();
        chngsForType.add(
            new FastCodeEntityHolder(
                PLACEHOLDER_CLASS, new FastCodeType(compilationUnit.findPrimaryType())));
      }
      ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED))
          .put(fileObj, chngsForType);
    }
    /*final Map<String, Object> listofChange = ((Map<Object, Map<String, Object>>) contextMap.get("changes_for_File")).get(file);
    if (chngsForType == null) {
    	chngsForType = new HashMap<String, Object>();
    	chngsForType.put("class", CREATE_CLASS); //fastCodeCache.getCommentKey().get(fastCodeCache.getCommentKey().indexOf("create.class.field"))
    }
    ((Map<Object, Map<String, Object>>) contextMap.get("changes_for_File")).put(file, listofChange);*/
  }