How to use

isRootProject

method

in

org.sonar.api.resources.ResourceUtils

private boolean shouldDecorateResource(Resource resource) {
 return ResourceUtils.isRootProject(resource);
}

@Override
public void decorate(Resource resource, DecoratorContext context) {
 if (ResourceUtils.isRootProject(resource)) {
  checkProjectConditions(resource, context);
 }
}

 @Override
 protected boolean shouldDecorateResource(Resource resource, DecoratorContext context) {
  // Should not execute on views
  return (ResourceUtils.isRootProject(resource) || ResourceUtils.isModuleProject(resource))
   // Only on leaf projects
   && ((Project) resource).getModules().isEmpty();
 }
}

 @Override
 protected boolean shouldDecorateResource(Resource resource, DecoratorContext context) {
  // Should not execute on views
  return (ResourceUtils.isRootProject(resource) || ResourceUtils.isModuleProject(resource))
   && !((Project) resource).getModules().isEmpty();
 }
}

private Constants.ComponentType getType(Resource r) {
 if (ResourceUtils.isFile(r)) {
  return Constants.ComponentType.FILE;
 } else if (ResourceUtils.isDirectory(r)) {
  return Constants.ComponentType.DIRECTORY;
 } else if (ResourceUtils.isModuleProject(r)) {
  return Constants.ComponentType.MODULE;
 } else if (ResourceUtils.isRootProject(r)) {
  return Constants.ComponentType.PROJECT;
 }
 throw new IllegalArgumentException("Unknown resource type: " + r);
}

private Constants.ComponentType getType(Resource r) {
 if (ResourceUtils.isFile(r)) {
  return Constants.ComponentType.FILE;
 } else if (ResourceUtils.isDirectory(r)) {
  return Constants.ComponentType.DIRECTORY;
 } else if (ResourceUtils.isModuleProject(r)) {
  return Constants.ComponentType.MODULE;
 } else if (ResourceUtils.isRootProject(r)) {
  return Constants.ComponentType.PROJECT;
 } else if (ResourceUtils.isView(r)) {
  return Constants.ComponentType.VIEW;
 } else if (ResourceUtils.isSubview(r)) {
  return Constants.ComponentType.SUBVIEW;
 }
 throw new IllegalArgumentException("Unknown resource type: " + r);
}

private void computeAbacusComplexity(Resource rsrc, DecoratorContext dc) {
 if (ResourceUtils.isFile(rsrc) || ResourceUtils.isPackage(rsrc) || ResourceUtils.isDirectory(rsrc)
  || ResourceUtils.isRootProject(rsrc) || ResourceUtils.isModuleProject(rsrc)) {
  Double fileComplexity = MeasureUtils.getValue(dc.getMeasure(CoreMetrics.FILE_COMPLEXITY), Double.NaN);
  if (!Double.isNaN(fileComplexity)) {
   dc.saveMeasure(new Measure(AbacusMetrics.ABACUS_COMPLEXITY, ComplexityThresholdsUtils.convertCyclomaticComplexityToAbacusComplexity(fileComplexity, complexityThresholds)));
  }
 }
}

private Bucket doIndex(Resource resource, @Nullable Resource parentReference) {
 Bucket bucket = getBucket(resource);
 if (bucket != null) {
  return bucket;
 }
 if (StringUtils.isBlank(resource.getKey())) {
  LOG.warn("Unable to index a resource without key " + resource);
  return null;
 }
 Resource parent = null;
 if (!ResourceUtils.isLibrary(resource)) {
  // a library has no parent
  parent = (Resource) ObjectUtils.defaultIfNull(parentReference, currentProject);
 }
 Bucket parentBucket = getBucket(parent);
 if (parentBucket == null && parent != null) {
  LOG.warn("Resource ignored, parent is not indexed: " + resource);
  return null;
 }
 if (ResourceUtils.isProject(resource) || /* For technical projects */ResourceUtils.isRootProject(resource)) {
  resource.setEffectiveKey(resource.getKey());
 } else {
  resource.setEffectiveKey(ComponentKeys.createEffectiveKey(currentProject, resource));
 }
 bucket = new Bucket(resource).setParent(parentBucket);
 addBucket(resource, bucket);
 Resource parentResource = parentBucket != null ? parentBucket.getResource() : null;
 resourceCache.add(resource, parentResource);
 return bucket;
}

private void computeAbacusComplexityDistribution(Resource rsrc, DecoratorContext dc) {
 if (ResourceUtils.isPackage(rsrc) || ResourceUtils.isDirectory(rsrc)) {
  ComplexityThresholdsUtils.initCounterThreshold(complexityThresholds);
  for (Measure measure : dc.getChildrenMeasures(AbacusMetrics.ABACUS_COMPLEXITY)) {
   for (ComplexityThreshold complexityThreshold : complexityThresholds) {
    if (measure.getData() != null && measure.getData().equals(complexityThreshold.getComplexityName())) {
     complexityThreshold.incrementCounter(1);
     break;
    }
   }
  }
  dc.saveMeasure(new Measure(AbacusMetrics.ABACUS_COMPLEXITY_DISTRIBUTION, ComplexityThresholdsUtils.buildComplexityDistributionMeasureValue(complexityThresholds)));
 } else if (ResourceUtils.isRootProject(rsrc) || ResourceUtils.isModuleProject(rsrc)) {
  ComplexityThresholdsUtils.initCounterThreshold(complexityThresholds);
  for (Measure measure : dc.getChildrenMeasures(AbacusMetrics.ABACUS_COMPLEXITY_DISTRIBUTION)) {
   String[] distribution = measure.getData().split(";");
   for (String aDistribution : distribution) {
    String[] tmp = aDistribution.split("=");
    for (ComplexityThreshold complexityThreshold : complexityThresholds) {
     if (tmp[0].equals(complexityThreshold.getComplexityName())) {
      complexityThreshold.incrementCounter(Integer.parseInt(tmp[1]));
      break;
     }
    }
   }
  }
  dc.saveMeasure(new Measure(AbacusMetrics.ABACUS_COMPLEXITY_DISTRIBUTION, ComplexityThresholdsUtils.buildComplexityDistributionMeasureValue(complexityThresholds)));
 }
}

private Bucket doIndex(Resource resource, @Nullable Resource parentReference) {
 Bucket bucket = getBucket(resource);
 if (bucket != null) {
  return bucket;
 }
 if (StringUtils.isBlank(resource.getKey())) {
  LOG.warn("Unable to index a resource without key " + resource);
  return null;
 }
 Resource parent = (Resource) ObjectUtils.defaultIfNull(parentReference, currentProject);
 Bucket parentBucket = getBucket(parent);
 if (parentBucket == null && parent != null) {
  LOG.warn("Resource ignored, parent is not indexed: " + resource);
  return null;
 }
 if (ResourceUtils.isProject(resource) || /* For technical projects */ResourceUtils.isRootProject(resource)) {
  resource.setEffectiveKey(resource.getKey());
 } else {
  resource.setEffectiveKey(ComponentKeys.createEffectiveKey(currentProject, resource));
 }
 bucket = new Bucket(resource).setParent(parentBucket);
 addBucket(resource, bucket);
 Resource parentResource = parentBucket != null ? parentBucket.getResource() : null;
 BatchComponent component = componentCache.add(resource, parentResource);
 if (ResourceUtils.isProject(resource)) {
  component.setInputComponent(new DefaultInputModule(resource.getEffectiveKey()));
 }
 return bucket;
}

public List<TrackedIssue> trackIssues(BatchComponent component, Collection<BatchReport.Issue> reportIssues, Date analysisDate) {
 List<TrackedIssue> trackedIssues = new LinkedList<>();
 if (hasServerAnalysis) {
  // all the issues that are not closed in db before starting this module scan, including manual issues
  Collection<ServerIssueFromWs> serverIssues = loadServerIssues(component);
  if (shouldCopyServerIssues(component)) {
   // raw issues should be empty, we just need to deal with server issues (SONAR-6931)
   copyServerIssues(serverIssues, trackedIssues);
  } else {
   SourceHashHolder sourceHashHolder = loadSourceHashes(component);
   Collection<TrackedIssue> rIssues = IssueTransformer.toTrackedIssue(component, reportIssues, sourceHashHolder);
   Input<ServerIssueFromWs> baseIssues = createBaseInput(serverIssues, sourceHashHolder);
   Input<TrackedIssue> rawIssues = createRawInput(rIssues, sourceHashHolder);
   Tracking<TrackedIssue, ServerIssueFromWs> track = tracker.track(rawIssues, baseIssues);
   addUnmatchedFromServer(track.getUnmatchedBases(), sourceHashHolder, trackedIssues);
   addUnmatchedFromServer(track.getOpenManualIssuesByLine().values(), sourceHashHolder, trackedIssues);
   mergeMatched(track, trackedIssues, rIssues);
   addUnmatchedFromReport(track.getUnmatchedRaws(), trackedIssues, analysisDate);
  }
 }
 if (hasServerAnalysis && ResourceUtils.isRootProject(component.resource())) {
  // issues that relate to deleted components
  addIssuesOnDeletedComponents(trackedIssues);
 }
 return trackedIssues;
}

public void trackIssues(BatchResource component) {
 Collection<DefaultIssue> issues = Lists.newArrayList();
 for (Issue issue : issueCache.byComponent(component.resource().getEffectiveKey())) {
  issues.add((DefaultIssue) issue);
 }
 issueCache.clear(component.resource().getEffectiveKey());
 // issues = all the issues created by rule engines during this module scan and not excluded by filters
 if (analysisMode.isIncremental() && !component.isFile()) {
  // No need to report issues on project or directories in preview mode since it is likely to be wrong anyway
  return;
 }
 // all the issues that are not closed in db before starting this module scan, including manual issues
 Collection<ServerIssue> serverIssues = loadServerIssues(component);
 SourceHashHolder sourceHashHolder = loadSourceHashes(component);
 IssueTrackingResult trackingResult = tracking.track(sourceHashHolder, serverIssues, issues);
 // unmatched = issues that have been resolved + issues on disabled/removed rules + manual issues
 addUnmatched(trackingResult.unmatched(), sourceHashHolder, issues);
 mergeMatched(trackingResult);
 if (ResourceUtils.isRootProject(component.resource())) {
  // issues that relate to deleted components
  addIssuesOnDeletedComponents(issues);
 }
 for (DefaultIssue issue : issues) {
  workflow.doAutomaticTransition(issue, changeContext);
  issueCache.put(issue);
 }
}