Esempio n. 1
0
  /**
   * Search for reviewed violations in that file
   *
   * @param file
   */
  private List<Review> findReviewedViolations(final IFile file) {
    final List<Review> reviews = new ArrayList<Review>();
    BufferedReader reader = null;
    try {
      int lineNumber = 0;
      boolean findLine = false;
      boolean comment = false;
      final Stack<String> pendingReviews = new Stack<String>();
      reader = new BufferedReader(new InputStreamReader(file.getContents()));
      while (reader.ready()) {
        String line = reader.readLine();
        if (line != null) {
          line = line.trim();
          lineNumber++;
          if (line.startsWith("/*")) {
            comment = line.indexOf("*/") == -1;
          } else if (comment && line.indexOf("*/") != -1) {
            comment = false;
          } else if (!comment && line.startsWith(PMDRuntimeConstants.PLUGIN_STYLE_REVIEW_COMMENT)) {
            final String tail =
                line.substring(PMDRuntimeConstants.PLUGIN_STYLE_REVIEW_COMMENT.length());
            final String ruleName = tail.substring(0, tail.indexOf(':'));
            pendingReviews.push(ruleName);
            findLine = true;
          } else if (!comment
              && findLine
              && StringUtil.isNotEmpty(line)
              && !line.startsWith("//")) {
            findLine = false;
            while (!pendingReviews.empty()) {
              // @PMD:REVIEWED:AvoidInstantiatingObjectsInLoops:
              // by Herlin on 01/05/05 18:36
              final Review review = new Review();
              review.ruleName = pendingReviews.pop();
              review.lineNumber = lineNumber;
              reviews.add(review);
            }
          }
        }
      }

      // if (log.isDebugEnabled()) {
      // for (int i = 0; i < reviewsList.size(); i++) {
      // final Review review = (Review) reviewsList.get(i);
      // log.debug("Review : rule " + review.ruleName + ", line " +
      // review.lineNumber);
      // }
      // }

    } catch (CoreException e) {
      PMDPlugin.getDefault().logError("Core Exception when searching reviewed violations", e);
    } catch (IOException e) {
      PMDPlugin.getDefault().logError("IO Exception when searching reviewed violations", e);
    } finally {
      IOUtil.closeQuietly(reader);
    }

    return reviews;
  }
  /* @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent) */
  public void resourceChanged(IResourceChangeEvent event) {
    try {
      event
          .getDelta()
          .accept(
              new IResourceDeltaVisitor() {
                public boolean visit(final IResourceDelta delta) throws CoreException {
                  // find the resource for the path of the current page
                  IPath path = getResourcePath();
                  if (delta.getFullPath().equals(path)) {
                    Display.getDefault()
                        .asyncExec(
                            new Runnable() {
                              public void run() {
                                refresh(delta.getResource());
                              }
                            });

                    return false;
                  }
                  return true;
                }
              });
    } catch (CoreException e) {
      PMDPlugin.getDefault().logError(StringKeys.ERROR_CORE_EXCEPTION, e);
    }
  }
Esempio n. 3
0
  /** Calculate the number of methods. */
  public void calculateNumberOfMethods() {
    if (resource.isAccessible()) {

      // we need to change the Resource into a Java-File
      final IJavaElement element = JavaCore.create(resource);
      final List<Object> methods = new ArrayList<Object>();

      if (element instanceof ICompilationUnit) {
        try {
          // ITypes can be Package Declarations or other Java Stuff too
          IType[] types = ((ICompilationUnit) element).getTypes();
          for (IType type : types) {
            // only if it is an IType itself, it's a Class
            // from which we can get its Methods
            methods.addAll(Arrays.asList(type.getMethods()));
          }
        } catch (JavaModelException jme) {
          PMDPlugin.getDefault().logError(StringKeys.ERROR_JAVAMODEL_EXCEPTION + toString(), jme);
        }
      }
      if (!methods.isEmpty()) {
        numberOfMethods = methods.size();
      }
    }
  }
Esempio n. 4
0
  public List<Renderer> activeRenderers() {

    List<Renderer> actives = new ArrayList<Renderer>();
    IPreferences prefs = PMDPlugin.getDefault().loadPreferences();

    for (Renderer renderer : allRenderers) {
      if (prefs.isActiveRenderer(renderer.getName())) actives.add(renderer);
    }

    return actives;
  }
Esempio n. 5
0
  /**
   * Finds PMD PDFA Markers in the File
   *
   * @return an Array of markers
   */
  public IMarker[] findDFAMarkers() {

    try {
      // we can only find Markers for a file
      // we use the DFA-Marker-ID set for Dataflow Anomalies
      if (resource.isAccessible()) {
        return MarkerUtil.findMarkers(resource, PMDRuntimeConstants.PMD_DFA_MARKER);
      }
    } catch (CoreException ce) {
      PMDPlugin.getDefault().logError(StringKeys.ERROR_FIND_MARKER + this.toString(), ce);
    }

    return MarkerUtil.EMPTY_MARKERS;
  }
Esempio n. 6
0
  /**
   * Reads a Resource's File and return the Code as String.
   *
   * @param resource a resource to read ; the resource must be accessible.
   * @return a String which is the Files Content
   */
  protected String resourceToString(IResource resource) {
    final StringBuilder fileContents = new StringBuilder();
    BufferedReader bReader = null;
    try {
      // we create a FileReader
      bReader = new BufferedReader(new FileReader(resource.getRawLocation().toFile()));

      // ... and read the File line by line
      while (bReader.ready()) {
        fileContents.append(bReader.readLine()).append('\n');
      }
    } catch (FileNotFoundException fnfe) {
      PMDPlugin.getDefault()
          .logError(
              StringKeys.ERROR_FILE_NOT_FOUND + resource.toString() + " in " + this.toString(),
              fnfe);
    } catch (IOException ioe) {
      PMDPlugin.getDefault().logError(StringKeys.ERROR_IO_EXCEPTION + this.toString(), ioe);
    } finally {
      IOUtil.closeQuietly(bReader);
    }

    return fileContents.toString();
  }
Esempio n. 7
0
  /**
   * Finds PMD-Markers in the File
   *
   * @return an Array of markers
   */
  @Override
  public final IMarker[] findMarkers() {

    try {
      // this is the overwritten Function from AbstractPMDRecord
      // we simply call the IResource-function to find Markers
      if (resource.isAccessible()) {
        return MarkerUtil.findMarkers(resource, PMDRuntimeConstants.RULE_MARKER_TYPES);
      }
    } catch (CoreException ce) {
      PMDPlugin.getDefault().logError(StringKeys.ERROR_FIND_MARKER + this.toString(), ce);
    }

    return MarkerUtil.EMPTY_MARKERS;
  }
Esempio n. 8
0
  /**
   * Finds Markers, that have a given Attribute with a given Value
   *
   * @param attributeName
   * @param value
   * @return an Array of markers matching these Attribute and Value
   */
  @Override
  public IMarker[] findMarkersByAttribute(String attributeName, Object value) {
    final IMarker[] markers = findMarkers();
    final List<IMarker> attributeMarkers = new ArrayList<IMarker>();
    try {
      // we get all Markers and catch the ones that matches our criteria
      for (IMarker marker : markers) {
        final Object val = marker.getAttribute(attributeName);

        // if the value is null, the Attribute doesn't exist
        if (val != null && val.equals(value)) {
          attributeMarkers.add(marker);
        }
      }
    } catch (CoreException ce) {
      PMDPlugin.getDefault().logError(StringKeys.ERROR_FIND_MARKER + this.toString(), ce);
    }

    // return an Array of the Markers
    return attributeMarkers.toArray(new IMarker[attributeMarkers.size()]);
  }
Esempio n. 9
0
  /** @see net.sourceforge.pmd.eclipse.ui.model.AbstractPMDRecord#createChildren() */
  @Override
  protected final AbstractPMDRecord[] createChildren() {
    AbstractPMDRecord[] children = EMPTY_RECORDS;

    try { // get all markers
      final List<IMarker> markers = Arrays.asList(findMarkers());
      if (markers.isEmpty()) return EMPTY_RECORDS;

      final Iterator<IMarker> markerIterator = markers.iterator();

      // put all markers in a map with key = rulename
      final Map<String, MarkerRecord> allMarkerMap = new HashMap<String, MarkerRecord>();
      while (markerIterator.hasNext()) {
        final IMarker marker = markerIterator.next();

        MarkerRecord markerRecord = allMarkerMap.get(MarkerUtil.ruleNameFor(marker));
        if (markerRecord == null) {
          String ruleName = MarkerUtil.ruleNameFor(marker);
          markerRecord =
              new MarkerRecord(
                  this, // NOPMD by Sven on 13.11.06 11:57
                  ruleName,
                  MarkerUtil.rulePriorityFor(marker));
          markerRecord.addViolation(marker);
          allMarkerMap.put(ruleName, markerRecord);
        } else {
          markerRecord.addViolation(marker);
        }
      }

      children = allMarkerMap.values().toArray(new MarkerRecord[allMarkerMap.size()]);
    } catch (CoreException e) {
      PMDPlugin.getDefault().logError(StringKeys.ERROR_CORE_EXCEPTION + this.toString(), e);
    }

    return children; // no children so return an empty array, not null!
  }
 protected static IPreferenceStore pStore() {
   return PMDPlugin.getDefault().getPreferenceStore();
 }