@Override
  public Change createChange(IProgressMonitor monitor)
      throws CoreException, OperationCanceledException {
    IFolder assetsFolder = resource.getProject().getFolder("assets");
    if (assetsFolder == null || !assetsFolder.exists()) {
      return null;
    }

    if (!"assets".equals(resource.getProjectRelativePath().segment(0))) {
      return null;
    }

    if (resource instanceof IFile && Assets.getAssetType(resource.getName()) == null) {
      return null;
    }

    IResource[] rootResources =
        RefractoringUtils.getSearchScopeRootResources(resource.getProject());
    if (Values.isEmpty(rootResources)) {
      return null;
    }

    IPath assetsFolderPath = assetsFolder.getProjectRelativePath();
    IPath oldResourcePath = resource.getProjectRelativePath().makeRelativeTo(assetsFolderPath);
    String newName = getArguments().getNewName();
    IPath newResourcePath = oldResourcePath.removeLastSegments(1).append(newName);

    String regex =
        "(?<=[[:|\\s|\\r|\\n]{1}[\\s|\\r|\\n]{0,100}]|^)"
            + Pattern.quote(oldResourcePath.toString())
            + "(?=\"|/|\\s|\\r|\\n|$)";
    return RefractoringUtils.createChange(
        false, monitor, rootResources, regex, newResourcePath.toString());
  }
Example #2
0
 private String getProjectRelaticePath(FileDiff diff) {
   IWorkspace workspace = ResourcesPlugin.getWorkspace();
   IWorkspaceRoot root = workspace.getRoot();
   IPath absolutePath = new Path(db.getWorkDir().getAbsolutePath()).append(diff.path);
   IResource resource = root.getFileForLocation(absolutePath);
   return resource.getProjectRelativePath().toString();
 }
Example #3
0
 /**
  * Notifies this listener that the given breakpoint has been added to the breakpoint manager.
  *
  * @param breakpoint the added breakpoint
  * @since 2.0
  */
 public void breakpointAdded(IBreakpoint breakpoint) {
   if (!isAvailable()) {
     return;
   }
   if (supportsBreakpoint(breakpoint)) {
     try {
       if (breakpoint.isEnabled()) {
         // only add the breakpoint to the debugger when the
         // breakpoint is enabled
         int linenumber = breakpoint.getMarker().getAttribute(IMarker.LINE_NUMBER, -1);
         // TODO: get marker language type or get language from the
         // resource
         IResource r = breakpoint.getMarker().getResource();
         String pRel = r.getProjectRelativePath().toOSString();
         String filename = pRel;
         if (linenumber > 0) {
           // only linenumbers greater than 0 are valid as
           // linenumber is 1-based
           // convert the Eclipse breakpoint to an internal
           // representation of breakpoints
           AbstractBreakPoint bp = createBreakpoint(filename, linenumber);
           if (bp != null) {
             this.getVMContainer().addBreakpoint(bp);
           }
         }
       }
     } catch (CoreException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
     }
   }
 }
Example #4
0
  public IBreakpoint findIBreakpoint(String filename, int lineNumber) {
    IBreakpoint[] breakpoints =
        DebugPlugin.getDefault()
            .getBreakpointManager()
            .getBreakpoints(this.debugServiceFactory.getLIConstants().getDebugModel());
    for (int i = 0; i < breakpoints.length; i++) {
      IBreakpoint breakpoint = breakpoints[i];
      if (supportsBreakpoint(breakpoint)) {

        try {
          if (breakpoint.isEnabled()) {
            // only add the breakpoint to the debugger when the
            // breakpoint is enabled
            int l = breakpoint.getMarker().getAttribute(IMarker.LINE_NUMBER, -1);
            // TODO: get marker language type or get language from
            // the resource
            IResource r = breakpoint.getMarker().getResource();
            String location = r.getProjectRelativePath().toOSString();
            if (l > 0) {
              // only linenumbers greater than 0 are valid as
              // linenumber is 1-based
              if (location.equals(filename) && lineNumber == l) {
                return breakpoint;
              }
            }
          }
        } catch (CoreException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
    }
    return null;
  }
Example #5
0
  @Override
  public ICResourceDescription getResDesc(ICConfigurationDescription cf) {
    IAdaptable ad = getElement();

    if (isForProject()) return cf.getRootFolderDescription();
    ICResourceDescription out = null;
    IResource res = (IResource) ad;
    IPath p = res.getProjectRelativePath();
    if (isForFolder() || isForFile()) {
      if (cf instanceof ICMultiItemsHolder) {
        out = cf.getResourceDescription(p, isForFolder()); // sic !
      } else {
        out = cf.getResourceDescription(p, false);
        if (!p.equals(out.getPath())) {
          try {
            if (isForFolder()) out = cf.createFolderDescription(p, (ICFolderDescription) out);
            else out = cf.createFileDescription(p, out);
          } catch (CoreException e) {
            System.out.println(
                Messages.AbstractPage_10
                    + p.toOSString()
                    + "\n"
                    + e.getLocalizedMessage()); // $NON-NLS-1$
          }
        }
      }
    }
    return out;
  }
Example #6
0
 public IPath getErlForYrl(final IResource resource) {
   final IPath path = resource.getProjectRelativePath();
   if (!"yrl".equals(path.getFileExtension())) {
     return null;
   }
   IPath erl = path.removeFileExtension();
   erl = erl.addFileExtension("erl").setDevice(null);
   return erl;
 }
Example #7
0
  /**
   * This operation scans the default project area for SerializedItems and loads them into the Core.
   * It returns false if it encounters and error and true if it is successful.
   *
   * @return True if the SerializedItems stored in the default project area were loaded
   *     successfully, false otherwise.
   */
  private boolean loadDefaultAreaItems() {

    // Local Declarations
    boolean status = false;
    ArrayList<String> serializedItemNames = new ArrayList<String>();
    SerializedItemBuilder builder = null;
    IProject project;
    IResource[] resources = null;
    IResource currentResource = null;
    IFile file = null;
    String filename = null;

    // Get the default project and grab its contents
    project = projectTable.get("defaultUser");
    if (project == null) {
      return status;
    }
    try {
      // Update the status
      status = true;
      // If the "jobProfiles" folder exists, loop over the resources and
      // get the serialized items
      if (project.getFolder("jobProfiles").exists()) {
        // Get the list of resources in the project
        resources = project.getFolder("jobProfiles").members();
        for (int i = 0; i < resources.length; i++) {
          currentResource = resources[i];
          filename = currentResource.getFullPath().toOSString();
          // Grab PSF or XML file
          if (filename.endsWith(".psf") | filename.endsWith(".xml")) {
            // Get the file
            file = project.getFile(currentResource.getProjectRelativePath());
            try {
              // Load the SerializedItemBuilder
              builder = new SerializedItemBuilder(file.getContents());
              // Register the builder
              itemManager.registerBuilder(builder);
            } catch (IOException e) {
              // TODO Auto-generated catch block
              logger.error(getClass().getName() + " Exception!", e);
              status = false;
            }
          }
        }
      } else {
        // Otherwise create the folder and return since there is nothing
        // to load
        project.getFolder("jobProfiles").create(true, true, null);
      }
    } catch (CoreException e) {
      logger.error(getClass().getName() + " Exception!", e);
    }

    return status;
  }
  /**
   * This method validates the resource.
   *
   * @param res The resource
   */
  public void validateResource(final IResource res) {
    EclipseIssueLogger logger = new EclipseIssueLogger((IFile) res);

    try {
      InputStreamResource isr =
          new InputStreamResource(
              res.getProjectRelativePath().toPortableString(), ((IFile) res).getContents());

      // Create a locator based on the Eclipse project root
      ResourceLocator locator =
          new ResourceLocator() {

            public Resource getResource(String name) {
              String filename = name.replace('.', java.io.File.separatorChar) + ".scr";

              IFile file = res.getProject().getFile(filename);

              if (file != null) {
                try {
                  return (new InputStreamResource(filename, file.getContents()));
                } catch (Exception e) {
                  e.printStackTrace();
                }
              }

              return null;
            }
          };

      ProtocolParser pp = new ProtocolParser();

      ProtocolModuleLoader loader = new ProtocolModuleLoader(pp, locator, logger);

      // Use console logger, to 'ignore' parser errors, as these will be detected and
      // reported by the XText generated Scribble editor. However the validation errors
      // should be reported via the Eclipse based logger
      Module module = pp.parse(isr, loader, new ConsoleIssueLogger());

      if (module != null) {
        // Validate
        org.scribble.validation.ProtocolValidator pv =
            new org.scribble.validation.ProtocolValidator();

        DefaultModuleContext context = new DefaultModuleContext(isr, module, loader);

        pv.validate(context, module, logger);
      }

    } catch (Exception e) {
      Activator.logError("Failed to record validation issue on resource '" + res + "'", e);
    } finally {
      logger.finished();
    }
  }
  @Override
  protected IStructureComparator createStructureComparator(
      Object input,
      IDocument document,
      ISharedDocumentAdapter sharedDocumentAdapter,
      IProgressMonitor monitor)
      throws CoreException {

    if (input instanceof CeylonDocumentRangeNode) {
      return (CeylonDocumentRangeNode) input;
    }

    final boolean isEditable;
    if (input instanceof IEditableContent) {
      IEditableContent ec = (IEditableContent) input;
      isEditable = ec.isEditable();
    } else {
      isEditable = false;
    }

    StructureRootNode structureRootNode =
        new StructureRootNode(document, input, this, sharedDocumentAdapter) {
          @Override
          public boolean isEditable() {
            return isEditable;
          }
        };

    CeylonParseController pc = new CeylonParseController();
    if (input instanceof ResourceNode) {
      ResourceNode node = (ResourceNode) input;
      IResource file = node.getResource();
      pc.initialize(file.getProjectRelativePath(), file.getProject(), null);
    } else {
      pc.initialize(null, null, null);
    }

    if (pc.parseAndTypecheck(document, 10, monitor, null) != null) {
      // now visit the model, creating TreeCompareNodes for each ModelTreeNode
      CeylonOutlineNode tree =
          new CeylonOutlineBuilder() {
            // don't create nodes for shortcut refinement
            // because we can't distinguish them w/o a
            // full typecheck
            public void visit(Tree.SpecifierStatement that) {}
          }.buildTree(pc);
      if (tree != null) {
        buildCompareTree(tree, structureRootNode, document);
      }
    }

    return structureRootNode;
  }
Example #10
0
  /**
   * Gets the associated models for the changed one and sets the CoWolf-Marker for them.
   *
   * @param changedRes to get the associated models from
   */
  private void invalidateModels(IResource changedRes) {

    ModelAssociation ma =
        ModelAssociationFactory.eINSTANCE.getModelAssociation(changedRes.getProject());

    Model model = ma.getModelByPath(changedRes.getProjectRelativePath().toString());

    if (model == null) {
      return;
    }

    HashSet<IFile> targets = new HashSet<>();
    for (Association assoc : model.getAllAssociations()) {

      //			for (ModelVersion v : assoc.getSource()) {
      //
      //				if (v.getModel().getModel() != changedRes.getProjectRelativePath().toString()) {
      //					targets.add(v.getModel().getFile());
      //				} else {
      //					break;
      //				}
      //			}
      for (ModelVersion v : assoc.getTarget()) {

        if (!v.getModel().getModel().equals(changedRes.getProjectRelativePath().toString())) {
          targets.add(v.getModel().getFile());
        } else {
          break;
        }
      }
    }

    for (IFile target : targets) {

      if (!doesCowolfMarkerExist(target)) {
        setMarker(changedRes, target);
      }
    }
  }
  /**
   * Create a Model with the supplied name, in the desired project
   *
   * @param targetProj the project resource under which to create the model
   * @param modelName the model name to create
   * @return the newly-created ModelResource
   */
  public ModelResource constructModel(IResource targetRes, String sModelName) {

    String sFileName = getFileName(sModelName);
    IPath relativeModelPath = targetRes.getProjectRelativePath().append(sFileName);
    final IFile modelFile = targetRes.getProject().getFile(relativeModelPath);
    final ModelResource resrc = ModelerCore.create(modelFile);
    try {
      resrc.getModelAnnotation().setPrimaryMetamodelUri(newModelInfo.getModelURI());
      resrc.getModelAnnotation().setModelType(newModelInfo.getModelType());
    } catch (ModelWorkspaceException mwe) {
      mwe.printStackTrace();
    }
    return resrc;
  }
  /** Ensures that location and file are set. */
  void dialogChanged() {
    IResource container =
        ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(getContainerName()));
    String fileName = getFileName();

    if (getContainerName().isEmpty()) {
      updateStatus(Messages.CmsisCodeTemplate_FileContainerNotSpecified);
      return;
    }
    if (container == null || (container.getType() & (IResource.PROJECT | IResource.FOLDER)) == 0) {
      updateStatus(Messages.CmsisCodeTemplate_FileContainerNotExist);
      return;
    }
    String[] segments = container.getFullPath().segments();
    if (!segments[0].equals(getProjectName())) {
      updateStatus(Messages.CmsisCodeTemplateNewWizardPage_LocationNotUnderProject);
      return;
    }
    if (!container.isAccessible()) {
      updateStatus(Messages.CmsisCodeTemplate_ProjectNotWritable);
      return;
    }

    segments = container.getProjectRelativePath().segments();
    if (segments.length > 0 && segments[0].equals(CmsisConstants.RTE)) {
      updateStatus(Messages.CmsisCodeTemplate_FileUnderRTEFolder);
      return;
    }
    if (fileName.length() == 0) {
      updateStatus(Messages.CmsisCodeTemplate_FileNameNotSpecified);
      return;
    }
    if (fileName.replace('\\', '/').indexOf('/', 1) > 0) {
      updateStatus(Messages.CmsisCodeTemplate_FileNameNotValid);
      return;
    }
    int dotLoc = fileName.lastIndexOf('.');
    if (dotLoc == -1) {
      updateStatus(Messages.CmsisCodeTemplate_FileExtensionNotConsistent);
      return;
    }
    String ext = fileName.substring(dotLoc + 1);
    if (!extIsValid(ext)) {
      updateStatus(Messages.CmsisCodeTemplate_FileExtensionNotConsistent);
      return;
    }
    updateStatus(null);
  }
Example #13
0
 boolean filterExtraResource(IResource resource) {
   if (this.extraResourceFileFilters != null) {
     char[] name = resource.getName().toCharArray();
     for (int i = 0, l = this.extraResourceFileFilters.length; i < l; i++)
       if (CharOperation.match(this.extraResourceFileFilters[i], name, true)) return true;
   }
   if (this.extraResourceFolderFilters != null) {
     IPath path = resource.getProjectRelativePath();
     String pathName = path.toString();
     int count = path.segmentCount();
     if (resource.getType() == IResource.FILE) count--;
     for (int i = 0, l = this.extraResourceFolderFilters.length; i < l; i++)
       if (pathName.indexOf(this.extraResourceFolderFilters[i]) != -1)
         for (int j = 0; j < count; j++)
           if (this.extraResourceFolderFilters[i].equals(path.segment(j))) return true;
   }
   return false;
 }
Example #14
0
 /**
  * Notifies this listener that the given breakpoint has been removed from the breakpoint manager.
  * If the given breakpoint has been removed because it has been deleted, the associated marker
  * delta is also provided.
  *
  * @param breakpoint the removed breakpoint
  * @param delta the associated marker delta, or <code>null</code> when the breakpoint is removed
  *     from the breakpoint manager without being deleted
  * @see org.eclipse.core.resources.IMarkerDelta
  * @since 2.0
  */
 public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
   if (!isAvailable()) {
     return;
   }
   if (supportsBreakpoint(breakpoint)) {
     // convert IBreakpoint to AbstractBreakPoint Breakpoint
     int linenumber = breakpoint.getMarker().getAttribute(IMarker.LINE_NUMBER, -1);
     IResource r = breakpoint.getMarker().getResource();
     String pRel = r.getProjectRelativePath().toOSString();
     String filename = pRel;
     if (linenumber > 0) {
       // only linenumbers greater than 0 are valid as linenumber is
       // 1-based
       AbstractBreakPoint bp = createBreakpoint(filename, linenumber);
       if (bp != null) {
         this.getVMContainer().removeBreakpoint(bp);
       }
     }
   }
 }
Example #15
0
  public static boolean projectHasCamelResource(final IProject project) {
    try {
      ArrayList<IResource> xmlResources = getAllXMLFilesInProject(project);
      for (Iterator<IResource> iterator = xmlResources.iterator(); iterator.hasNext(); ) {
        IResource item = iterator.next();
        File testFile = new File(item.getLocationURI());
        if (testFile.exists()) {
          boolean isValidCamel =
              CamelFileTypeHelper.isSupportedCamelFile(
                  project, item.getProjectRelativePath().toPortableString());
          if (isValidCamel) {
            return true;
          }
        }
      }
    } catch (final Exception e) {
      // ignore
    }

    return false;
  }
  protected boolean findSourceFiles(
      IResourceDelta sourceDelta, ClasspathMultiDirectory md, int segmentCount)
      throws CoreException {
    // When a package becomes a type or vice versa, expect 2 deltas,
    // one on the folder & one on the source file
    IResource resource = sourceDelta.getResource();
    // remember that if inclusion & exclusion patterns change then a full build is done
    boolean isExcluded =
        (md.exclusionPatterns != null || md.inclusionPatterns != null)
            && Util.isExcluded(resource, md.inclusionPatterns, md.exclusionPatterns);
    switch (resource.getType()) {
      case IResource.FOLDER:
        if (isExcluded && md.inclusionPatterns == null)
          return true; // no need to go further with this delta since its children cannot be
        // included

        switch (sourceDelta.getKind()) {
          case IResourceDelta.ADDED:
            if (!isExcluded) {
              IPath addedPackagePath = resource.getFullPath().removeFirstSegments(segmentCount);
              createFolder(
                  addedPackagePath, md.binaryFolder); // ensure package exists in the output folder
              // see if any known source file is from the same package... classpath already includes
              // new package
              if (this.sourceLocations.length > 1
                  && this.newState.isKnownPackage(addedPackagePath.toString())) {
                if (JavaBuilder.DEBUG)
                  System.out.println(
                      "Skipped dependents of added package " + addedPackagePath); // $NON-NLS-1$
              } else {
                if (JavaBuilder.DEBUG)
                  System.out.println("Found added package " + addedPackagePath); // $NON-NLS-1$
                addDependentsOf(addedPackagePath, true);
              }
            }
            // $FALL-THROUGH$ collect all the source files
          case IResourceDelta.CHANGED:
            IResourceDelta[] children = sourceDelta.getAffectedChildren();
            for (int i = 0, l = children.length; i < l; i++)
              if (!findSourceFiles(children[i], md, segmentCount)) return false;
            return true;
          case IResourceDelta.REMOVED:
            if (isExcluded) {
              // since this folder is excluded then there is nothing to delete (from this md), but
              // must walk any included subfolders
              children = sourceDelta.getAffectedChildren();
              for (int i = 0, l = children.length; i < l; i++)
                if (!findSourceFiles(children[i], md, segmentCount)) return false;
              return true;
            }
            IPath removedPackagePath = resource.getFullPath().removeFirstSegments(segmentCount);
            if (this.sourceLocations.length > 1) {
              for (int i = 0, l = this.sourceLocations.length; i < l; i++) {
                if (this.sourceLocations[i].sourceFolder.getFolder(removedPackagePath).exists()) {
                  // only a package fragment was removed, same as removing multiple source files
                  createFolder(
                      removedPackagePath,
                      md.binaryFolder); // ensure package exists in the output folder
                  IResourceDelta[] removedChildren = sourceDelta.getAffectedChildren();
                  for (int j = 0, m = removedChildren.length; j < m; j++)
                    if (!findSourceFiles(removedChildren[j], md, segmentCount)) return false;
                  return true;
                }
              }
            }
            if ((sourceDelta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
              // same idea as moving a source file
              // see bug 163200
              IResource movedFolder =
                  this.javaBuilder.workspaceRoot.getFolder(sourceDelta.getMovedToPath());
              JavaBuilder.removeProblemsAndTasksFor(movedFolder);
            }
            IFolder removedPackageFolder = md.binaryFolder.getFolder(removedPackagePath);
            if (removedPackageFolder.exists()) removedPackageFolder.delete(IResource.FORCE, null);
            // add dependents even when the package thinks it does not exist to be on the safe side
            if (JavaBuilder.DEBUG)
              System.out.println("Found removed package " + removedPackagePath); // $NON-NLS-1$
            addDependentsOf(removedPackagePath, true);
            this.newState.removePackage(sourceDelta);
        }
        return true;
      case IResource.FILE:
        if (isExcluded) return true;

        String resourceName = resource.getName();
        // GROOVY start
        // determine if this is a Groovy project
        final boolean isInterestingProject =
            LanguageSupportFactory.isInterestingProject(this.javaBuilder.getProject());
        // GROOVY end

        // GROOVY start
        /* old {
        if (org.eclipse.jdt.internal.core.util.Util.isJavaLikeFileName(resourceName)) {
        } new */
        // GRECLIPSE-404 must call 'isJavaLikeFile' directly in order to make the Scala-Eclipse
        // plugin's weaving happy
        if ((!isInterestingProject
                && org.eclipse.jdt.internal.core.util.Util.isJavaLikeFileName(resourceName)
                && !LanguageSupportFactory.isInterestingSourceFile(resourceName))
            || (isInterestingProject
                && LanguageSupportFactory.isSourceFile(resourceName, isInterestingProject))) {
          // GROOVY end
          IPath typePath =
              resource.getFullPath().removeFirstSegments(segmentCount).removeFileExtension();
          String typeLocator = resource.getProjectRelativePath().toString();
          switch (sourceDelta.getKind()) {
            case IResourceDelta.ADDED:
              if (JavaBuilder.DEBUG)
                System.out.println("Compile this added source file " + typeLocator); // $NON-NLS-1$
              this.sourceFiles.add(new SourceFile((IFile) resource, md, true));
              String typeName = typePath.toString();
              if (!this.newState.isDuplicateLocator(
                  typeName, typeLocator)) { // adding dependents results in 2 duplicate errors
                if (JavaBuilder.DEBUG)
                  System.out.println("Found added source file " + typeName); // $NON-NLS-1$
                addDependentsOf(typePath, true);
              }
              return true;
            case IResourceDelta.REMOVED:
              char[][] definedTypeNames = this.newState.getDefinedTypeNamesFor(typeLocator);
              if (definedTypeNames == null) { // defined a single type matching typePath
                removeClassFile(typePath, md.binaryFolder);
                if ((sourceDelta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
                  // remove problems and tasks for a compilation unit that is being moved (to
                  // another package or renamed)
                  // if the target file is a compilation unit, the new cu will be recompiled
                  // if the target file is a non-java resource, then markers are removed
                  // see bug 2857
                  IResource movedFile =
                      this.javaBuilder.workspaceRoot.getFile(sourceDelta.getMovedToPath());
                  JavaBuilder.removeProblemsAndTasksFor(movedFile);
                }
              } else {
                if (JavaBuilder.DEBUG)
                  System.out.println(
                      "Found removed source file " + typePath.toString()); // $NON-NLS-1$
                addDependentsOf(
                    typePath,
                    true); // add dependents of the source file since it may be involved in a name
                // collision
                if (definedTypeNames.length
                    > 0) { // skip it if it failed to successfully define a type
                  IPath packagePath = typePath.removeLastSegments(1);
                  for (int i = 0, l = definedTypeNames.length; i < l; i++)
                    removeClassFile(
                        packagePath.append(new String(definedTypeNames[i])), md.binaryFolder);
                }
              }
              this.newState.removeLocator(typeLocator);
              return true;
            case IResourceDelta.CHANGED:
              if ((sourceDelta.getFlags() & IResourceDelta.CONTENT) == 0
                  && (sourceDelta.getFlags() & IResourceDelta.ENCODING) == 0)
                return true; // skip it since it really isn't changed
              if (JavaBuilder.DEBUG)
                System.out.println(
                    "Compile this changed source file " + typeLocator); // $NON-NLS-1$
              this.sourceFiles.add(new SourceFile((IFile) resource, md, true));
          }
          return true;
        } else if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(resourceName)) {
          // perform full build if a managed class file has been changed
          if (this.makeOutputFolderConsistent) {
            IPath typePath =
                resource.getFullPath().removeFirstSegments(segmentCount).removeFileExtension();
            if (this.newState.isKnownType(typePath.toString())) {
              if (JavaBuilder.DEBUG)
                System.out.println(
                    "MUST DO FULL BUILD. Found change to class file " + typePath); // $NON-NLS-1$
              return false;
            }
          }
          return true;
        } else if (md.hasIndependentOutputFolder) {
          if (this.javaBuilder.filterExtraResource(resource)) return true;

          // copy all other resource deltas to the output folder
          IPath resourcePath = resource.getFullPath().removeFirstSegments(segmentCount);
          IResource outputFile = md.binaryFolder.getFile(resourcePath);
          switch (sourceDelta.getKind()) {
            case IResourceDelta.ADDED:
              if (outputFile.exists()) {
                if (JavaBuilder.DEBUG)
                  System.out.println("Deleting existing file " + resourcePath); // $NON-NLS-1$
                outputFile.delete(IResource.FORCE, null);
              }
              if (JavaBuilder.DEBUG)
                System.out.println("Copying added file " + resourcePath); // $NON-NLS-1$
              createFolder(
                  resourcePath.removeLastSegments(1),
                  md.binaryFolder); // ensure package exists in the output folder
              copyResource(resource, outputFile);
              return true;
            case IResourceDelta.REMOVED:
              if (outputFile.exists()) {
                if (JavaBuilder.DEBUG)
                  System.out.println("Deleting removed file " + resourcePath); // $NON-NLS-1$
                outputFile.delete(IResource.FORCE, null);
              }
              return true;
            case IResourceDelta.CHANGED:
              if ((sourceDelta.getFlags() & IResourceDelta.CONTENT) == 0
                  && (sourceDelta.getFlags() & IResourceDelta.ENCODING) == 0)
                return true; // skip it since it really isn't changed
              if (outputFile.exists()) {
                if (JavaBuilder.DEBUG)
                  System.out.println("Deleting existing file " + resourcePath); // $NON-NLS-1$
                outputFile.delete(IResource.FORCE, null);
              }
              if (JavaBuilder.DEBUG)
                System.out.println("Copying changed file " + resourcePath); // $NON-NLS-1$
              createFolder(
                  resourcePath.removeLastSegments(1),
                  md.binaryFolder); // ensure package exists in the output folder
              copyResource(resource, outputFile);
          }
          return true;
        }
    }
    return true;
  }
Example #17
0
 /**
  * Updates the commands.
  *
  * @param commands
  */
 private void updateCommands(ArrayList<TexCommandEntry> commands) {
   IResource resource = getFile();
   if (resource == null) return;
   if (commandContainer.addRefSource(resource.getProjectRelativePath().toString(), commands))
     commandContainer.organize();
 }
Example #18
0
 /**
  * Updates the labels.
  *
  * @param labels
  */
 private void updateLabels(List<ReferenceEntry> labels) {
   IResource resource = getFile();
   if (resource == null) return;
   labelContainer.addRefSource(resource.getProjectRelativePath().toString(), labels);
   labelContainer.organize();
 }
Example #19
0
  /**
   * Parses the LaTeX-document and adds error markers if there were any errors. Throws <code>
   * TexDocumentParseException</code> if there were fatal parse errors that prohibit building an
   * outline.
   *
   * @param monitor
   * @throws TexDocumentParseException
   */
  private ArrayList<OutlineNode> doParse(IProgressMonitor monitor)
      throws TexDocumentParseException {

    if (this.parser == null) {
      this.parser =
          new TexParser(editor.getDocumentProvider().getDocument(editor.getEditorInput()));
    }
    if (projectOutline == null) {
      createProjectOutline();
    }

    try {
      parser.parseDocument(sectionCheckEnabled);
    } catch (IOException e) {
      TexlipsePlugin.log("Can't read file.", e);
      throw new TexDocumentParseException(e);
    }
    pollCancel(monitor);

    List<ParseErrorMessage> errors = parser.getErrors();
    List<ParseErrorMessage> tasks = parser.getTasks();
    MarkerHandler marker = MarkerHandler.getInstance();

    // somewhat inelegantly ensures that errors marked in createProjectDatastructs()
    // aren't removed immediately
    if (!firstRun) {
      marker.clearErrorMarkers(editor);
      marker.clearTaskMarkers(editor);
    } else {
      firstRun = false;
    }

    if (editor.getProject() != null && editor.getFullOutline() != null) {
      IResource res = (IResource) editor.getEditorInput().getAdapter(IResource.class);
      String fileName = res.getProjectRelativePath().toString();
      projectOutline.addOutline(parser.getOutlineTree(), fileName);

      List<OutlineNode> fo = projectOutline.getFullOutline();
      postParseJob.setFONodes(fo);
    } else {
      postParseJob.setFONodes(null);
    }
    pollCancel(monitor);

    processIncludes(parser.getInputs(), editor.getEditorInput());

    if (errors.size() > 0) {
      marker.createErrorMarkers(editor, errors);
    }
    if (tasks.size() > 0) {
      marker.createTaskMarkers(editor, tasks);
    }
    if (parser.isFatalErrors()) {
      throw new TexDocumentParseException("Fatal errors in file, parsing aborted.");
    }

    updateReferences(monitor);

    List<DocumentReference> cites = parser.getCites();
    List<DocumentReference> bibErrors = null;
    for (DocumentReference cite : cites) {
      if (!bibContainer.binTest(cite.getKey())) {
        if (bibErrors == null) bibErrors = new ArrayList<DocumentReference>();
        bibErrors.add(cite);
      }
    }
    if (bibErrors != null) {
      marker.createReferencingErrorMarkers(editor, bibErrors);
    }

    List<DocumentReference> refs = parser.getRefs();
    List<DocumentReference> refErrors = null;
    for (DocumentReference ref : refs) {
      if (!labelContainer.binTest(ref.getKey())) {
        if (refErrors == null) refErrors = new ArrayList<DocumentReference>();
        refErrors.add(ref);
      }
    }
    if (refErrors != null) {
      marker.createReferencingErrorMarkers(editor, refErrors);
    }

    return this.parser.getOutlineTree();
  }
Example #20
0
 /**
  * Creates a problem for a specific reference in the workspace
  *
  * @param reference reference
  * @param associated java project (with reference source location)
  * @return problem or <code>null</code> if none
  * @exception CoreException if something goes wrong
  */
 protected IApiProblem createProblem(IReference reference, IJavaProject javaProject) {
   IProject project = javaProject.getProject();
   if (ApiPlugin.getDefault().getSeverityLevel(getSeverityKey(), project)
       == ApiPlugin.SEVERITY_IGNORE) {
     return null;
   }
   try {
     String lookupName = getTypeName(reference.getMember()).replace('$', '.');
     IType type = javaProject.findType(lookupName, new NullProgressMonitor());
     if (type == null) {
       return null;
     }
     ICompilationUnit compilationUnit = type.getCompilationUnit();
     if (compilationUnit == null) {
       return null;
     }
     IResource resource = Util.getResource(project, type);
     if (resource == null) {
       return null;
     }
     int charStart = -1;
     int charEnd = -1;
     int lineNumber = reference.getLineNumber();
     IJavaElement element = compilationUnit;
     if (!Util.isManifest(resource.getProjectRelativePath()) && !type.isBinary()) {
       IDocument document = Util.getDocument(compilationUnit);
       // retrieve line number, char start and char end
       if (lineNumber > 0) {
         lineNumber--;
       }
       // get the source range for the problem
       try {
         Position pos = getSourceRange(type, document, reference);
         if (pos != null) {
           charStart = pos.getOffset();
           if (charStart != -1) {
             charEnd = charStart + pos.getLength();
             lineNumber = document.getLineOfOffset(charStart);
           }
         }
       } catch (CoreException e) {
         ApiPlugin.log(e);
         return null;
       } catch (BadLocationException e) {
         ApiPlugin.log(e);
         return null;
       }
       if (charStart > -1) {
         element = compilationUnit.getElementAt(charStart);
       }
     }
     return ApiProblemFactory.newApiUsageProblem(
         resource.getProjectRelativePath().toPortableString(),
         type.getFullyQualifiedName(),
         getMessageArgs(reference),
         new String[] {
           IApiMarkerConstants.MARKER_ATTR_HANDLE_ID, IApiMarkerConstants.API_MARKER_ATTR_ID
         },
         new Object[] {
           (element == null
               ? compilationUnit.getHandleIdentifier()
               : element.getHandleIdentifier()),
           new Integer(IApiMarkerConstants.API_USAGE_MARKER_ID)
         },
         lineNumber,
         charStart,
         charEnd,
         getElementType(reference),
         getProblemKind(),
         getProblemFlags(reference));
   } catch (CoreException e) {
     ApiPlugin.log(e);
   }
   return null;
 }
Example #21
0
 static boolean mustBeVisited(final IResource resource) {
   return (resource instanceof IFile
       && hasCorrectExtension(resource.getProjectRelativePath())
       && isInSourceFolder((IFile) resource));
 }
  /**
   * Called by {@link NewXmlFileWizard} to initialize the page with the selection received by the
   * wizard -- typically the current user workbench selection.
   *
   * <p>Things we expect to find out from the selection:
   *
   * <ul>
   *   <li>The project name, valid if it's an android nature.
   *   <li>The current folder, valid if it's a folder under /res
   *   <li>An existing filename, in which case the user will be asked whether to override it.
   * </ul>
   *
   * <p>The selection can also be set to a {@link Pair} of {@link IProject} and a workspace resource
   * path (where the resource path does not have to exist yet, such as res/anim/).
   *
   * @param selection The selection when the wizard was initiated.
   */
  private boolean initializeFromSelection(IStructuredSelection selection) {
    if (selection == null) {
      return false;
    }

    // Find the best match in the element list. In case there are multiple selected elements
    // select the one that provides the most information and assign them a score,
    // e.g. project=1 + folder=2 + file=4.
    IProject targetProject = null;
    String targetWsFolderPath = null;
    String targetFileName = null;
    int targetScore = 0;
    for (Object element : selection.toList()) {
      if (element instanceof IAdaptable) {
        IResource res = (IResource) ((IAdaptable) element).getAdapter(IResource.class);
        IProject project = res != null ? res.getProject() : null;

        // Is this an Android project?
        try {
          if (project == null || !project.hasNature(AdtConstants.NATURE_DEFAULT)) {
            continue;
          }
        } catch (CoreException e) {
          // checking the nature failed, ignore this resource
          continue;
        }

        int score = 1; // we have a valid project at least

        IPath wsFolderPath = null;
        String fileName = null;
        assert res != null; // Eclipse incorrectly thinks res could be null, so tell it no
        if (res.getType() == IResource.FOLDER) {
          wsFolderPath = res.getProjectRelativePath();
        } else if (res.getType() == IResource.FILE) {
          if (SdkUtils.endsWithIgnoreCase(res.getName(), DOT_XML)) {
            fileName = res.getName();
          }
          wsFolderPath = res.getParent().getProjectRelativePath();
        }

        // Disregard this folder selection if it doesn't point to /res/something
        if (wsFolderPath != null
            && wsFolderPath.segmentCount() > 1
            && SdkConstants.FD_RESOURCES.equals(wsFolderPath.segment(0))) {
          score += 2;
        } else {
          wsFolderPath = null;
          fileName = null;
        }

        score += fileName != null ? 4 : 0;

        if (score > targetScore) {
          targetScore = score;
          targetProject = project;
          targetWsFolderPath = wsFolderPath != null ? wsFolderPath.toString() : null;
          targetFileName = fileName;
        }
      } else if (element instanceof Pair<?, ?>) {
        // Pair of Project/String
        @SuppressWarnings("unchecked")
        Pair<IProject, String> pair = (Pair<IProject, String>) element;
        targetScore = 1;
        targetProject = pair.getFirst();
        targetWsFolderPath = pair.getSecond();
        targetFileName = "";
      }
    }

    if (targetProject == null) {
      // Try to figure out the project from the active editor
      IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
      if (window != null) {
        IWorkbenchPage page = window.getActivePage();
        if (page != null) {
          IEditorPart activeEditor = page.getActiveEditor();
          if (activeEditor instanceof AndroidXmlEditor) {
            Object input = ((AndroidXmlEditor) activeEditor).getEditorInput();
            if (input instanceof FileEditorInput) {
              FileEditorInput fileInput = (FileEditorInput) input;
              targetScore = 1;
              IFile file = fileInput.getFile();
              targetProject = file.getProject();
              IPath path = file.getParent().getProjectRelativePath();
              targetWsFolderPath = path != null ? path.toString() : null;
            }
          }
        }
      }
    }

    if (targetProject == null) {
      // If we didn't find a default project based on the selection, check how many
      // open Android projects we can find in the current workspace. If there's only
      // one, we'll just select it by default.
      IJavaProject[] projects = AdtUtils.getOpenAndroidProjects();
      if (projects != null && projects.length == 1) {
        targetScore = 1;
        targetProject = projects[0].getProject();
      }
    }

    // Now set the UI accordingly
    if (targetScore > 0) {
      mValues.project = targetProject;
      mValues.folderPath = targetWsFolderPath;
      mProjectButton.setSelectedProject(targetProject);
      mFileNameTextField.setText(targetFileName != null ? targetFileName : ""); // $NON-NLS-1$

      // If the current selection context corresponds to a specific file type,
      // select it.
      if (targetWsFolderPath != null) {
        int pos = targetWsFolderPath.lastIndexOf(WS_SEP_CHAR);
        if (pos >= 0) {
          targetWsFolderPath = targetWsFolderPath.substring(pos + 1);
        }
        String[] folderSegments = targetWsFolderPath.split(RES_QUALIFIER_SEP);
        if (folderSegments.length > 0) {
          mValues.configuration = FolderConfiguration.getConfig(folderSegments);
          String folderName = folderSegments[0];
          selectTypeFromFolder(folderName);
        }
      }
    }

    return true;
  }