protected Resource createResource(File file, List<File> sourceDirs, boolean unitTest) {
   org.sonar.api.resources.File resource =
       org.sonar.api.resources.File.fromIOFile(file, sourceDirs);
   if (resource != null) {
     resource.setLanguage(language);
     if (unitTest) {
       resource.setQualifier(Qualifiers.UNIT_TEST_FILE);
     }
   }
   return resource;
 }
Exemplo n.º 2
0
 @Override
 public String getSource(Resource reference) {
   Resource resource = getResource(reference);
   if (resource instanceof File) {
     File file = (File) resource;
     Project module = currentProject;
     ProjectDefinition def = projectTree.getProjectDefinition(module);
     try {
       return FileUtils.readFileToString(new java.io.File(def.getBaseDir(), file.getPath()));
     } catch (IOException e) {
       throw new IllegalStateException("Unable to read file content " + reference, e);
     }
   }
   return null;
 }
  /**
   * Create violation from Aftermath Sin
   *
   * <p>Note can return null
   */
  protected Violation createViolation(RealmNode realm, SoulNode soul, SinNode sin) {
    String ruleKey = sin.getTruth();

    // get the rule from the repository
    Rule rule = this.ruleFinder.findByKey(AftermathRuleRepository.REPOSITORY_KEY, ruleKey);
    if (null == rule) {
      AftermathResultAnalysis.LOG.info("- Rule [" + ruleKey + "] not found in Repository");
      return null;
    }

    // Get resource
    org.sonar.api.resources.File resource =
        org.sonar.api.resources.File.fromIOFile(
            new File(realm.getName(), soul.getName()), this.project);
    if (null == this.context.getResource(resource)) {
      AftermathResultAnalysis.LOG.warn(
          "Cannot get resource for realm [" + realm.getName() + "] soul [" + soul.getName() + "]");
      return null;
    }

    // Create violation
    Violation violation = Violation.create(rule, resource);
    violation.setLineId(sin.getYear());
    violation.setMessage(sin.getMessage());
    violation.setSeverity(AftermathSeverityMap.getSeverity(sin.getSeverity()));

    // AftermathResultAnalysis.LOG.info("- Violation created: " + violation.toString());
    return violation;
  }
Exemplo n.º 4
0
  @Test
  public void shouldIndexTreeOfResources() {
    Directory directory = new Directory("org/foo");
    File file = new File("org/foo/Bar.java");
    file.setLanguage(Java.INSTANCE);

    assertThat(index.index(directory), is(true));
    assertThat(index.index(file, directory), is(true));

    File fileRef = new File("org/foo/Bar.java");
    assertThat(index.getResource(fileRef).getKey(), is("org/foo/Bar.java"));
    assertThat(index.getResource(fileRef).getLanguage(), is((Language) Java.INSTANCE));
    assertThat(index.isIndexed(fileRef, true), is(true));
    assertThat(index.isExcluded(fileRef), is(false));
    assertThat(index.getChildren(fileRef).size(), is(0));
    assertThat(index.getParent(fileRef), is(Directory.class));
  }
Exemplo n.º 5
0
 private Bucket getBucket(@Nullable Resource reference) {
   if (reference == null) {
     return null;
   }
   if (StringUtils.isNotBlank(reference.getKey())) {
     return buckets.get(reference);
   }
   String relativePathFromSourceDir = null;
   boolean isTest = false;
   boolean isDir = false;
   if (reference instanceof File) {
     File referenceFile = (File) reference;
     isTest = Qualifiers.UNIT_TEST_FILE.equals(referenceFile.getQualifier());
     relativePathFromSourceDir = referenceFile.relativePathFromSourceDir();
   } else if (reference instanceof Directory) {
     isDir = true;
     Directory referenceDir = (Directory) reference;
     relativePathFromSourceDir = referenceDir.relativePathFromSourceDir();
     if (Directory.ROOT.equals(relativePathFromSourceDir)) {
       relativePathFromSourceDir = "";
     }
   }
   if (relativePathFromSourceDir != null) {
     // Resolve using deprecated key
     List<String> dirs;
     ProjectDefinition projectDef = projectTree.getProjectDefinition(getProject());
     if (isTest) {
       dirs = projectDef.getTestDirs();
     } else {
       dirs = projectDef.getSourceDirs();
     }
     for (String src : dirs) {
       java.io.File dirOrFile = pathResolver.relativeFile(projectDef.getBaseDir(), src);
       java.io.File abs = new java.io.File(dirOrFile, relativePathFromSourceDir);
       Bucket b =
           getBucket(
               isDir
                   ? Directory.fromIOFile(abs, getProject())
                   : File.fromIOFile(abs, getProject()));
       if (b != null) {
         return b;
       }
     }
   }
   return null;
 }
public class DuplicationPersisterTest extends AbstractDaoTestCase {

  @org.junit.Rule public ExpectedException thrown = ExpectedException.none();

  public static final int FILE_SNAPSHOT_ID = 3003;

  DuplicationPersister duplicationPersister;
  RuleFinder ruleFinder = mock(RuleFinder.class);
  File aFile = File.create("org/foo/Bar.java");
  Snapshot fileSnapshot = snapshot(FILE_SNAPSHOT_ID);

  private DuplicationCache duplicationCache;

  @Before
  public void mockResourcePersister() {
    duplicationCache = mock(DuplicationCache.class);

    ResourceCache resourceCache = mock(ResourceCache.class);
    BatchResource batchResource = mock(BatchResource.class);
    when(batchResource.resource()).thenReturn(aFile);
    when(batchResource.snapshotId()).thenReturn(FILE_SNAPSHOT_ID);
    when(resourceCache.get("foo:org/foo/Bar.java")).thenReturn(batchResource);

    MetricFinder metricFinder = mock(MetricFinder.class);
    when(metricFinder.findByKey(CoreMetrics.DUPLICATIONS_DATA_KEY))
        .thenReturn(CoreMetrics.DUPLICATIONS_DATA.setId(2));

    duplicationPersister =
        new DuplicationPersister(
            getMyBatis(), ruleFinder, resourceCache, duplicationCache, metricFinder);
  }

  @Test
  public void should_insert_duplications() {
    setupData("empty");

    Duplication.Block originBlock = new Duplication.Block("foo:org/foo/Bar.java", 1, 4);

    DefaultDuplication group = new DefaultDuplication().setOriginBlock(originBlock);
    group.duplicates().add(new Duplication.Block("foo:org/foo/Foo.java", 5, 9));

    when(duplicationCache.componentKeys()).thenReturn(Arrays.asList("foo:org/foo/Bar.java"));

    when(duplicationCache.byComponent("foo:org/foo/Bar.java")).thenReturn(Arrays.asList(group));

    duplicationPersister.persist();

    checkTables("shouldInsertDuplication", "project_measures");
  }

  private static Snapshot snapshot(int id) {
    Snapshot snapshot = mock(Snapshot.class);
    when(snapshot.getId()).thenReturn(id);
    return snapshot;
  }
}
Exemplo n.º 7
0
 @Override
 public <P extends Perspective> P as(Class<P> perspectiveClass, InputPath inputPath) {
   Resource r;
   if (inputPath instanceof InputDir) {
     r = Directory.create(((InputDir) inputPath).relativePath());
   } else if (inputPath instanceof InputFile) {
     r = File.create(((InputFile) inputPath).relativePath());
   } else {
     throw new IllegalArgumentException("Unknow input path type: " + inputPath);
   }
   return as(perspectiveClass, r);
 }
Exemplo n.º 8
0
  private void save(Collection<SourceCode> squidSourceFiles) {
    for (SourceCode squidSourceFile : squidSourceFiles) {
      SourceFile squidFile = (SourceFile) squidSourceFile;

      File sonarFile = File.fromIOFile(new java.io.File(squidFile.getKey()), project);

      saveMeasures(sonarFile, squidFile);
      saveFunctionsComplexityDistribution(sonarFile, squidFile);
      saveFilesComplexityDistribution(sonarFile, squidFile);
      saveViolations(sonarFile, squidFile);
    }
  }
 private void createViolation(SMInputCursor violationsCursor, Rule currentRule)
     throws XMLStreamException {
   org.sonar.api.resources.File sonarFile =
       org.sonar.api.resources.File.fromIOFile(
           new File(violationsCursor.getAttrValue("Source")), project);
   if (context.isIndexed(sonarFile, false)) {
     Violation violation = Violation.create(currentRule, sonarFile);
     String lineNumber = violationsCursor.getAttrValue("LineNumber");
     if (lineNumber != null) {
       violation.setLineId(Integer.parseInt(lineNumber));
     }
     violation.setMessage(violationsCursor.collectDescendantText().trim());
     violation.setSeverity(currentRule.getSeverity());
     context.saveViolation(violation);
   } else {
     LOG.debug("Violation could not be saved, associated resource not indexed " + sonarFile);
   }
 }
Exemplo n.º 10
0
  @Test
  public void test_measure_coder() throws Exception {
    Resource file1 = File.create("foo/bar/File1.txt").setEffectiveKey("struts:foo/bar/File1.txt");

    Measure measure = new Measure(CoreMetrics.NCLOC, 3.14);
    measure.setData("data");
    measure.setAlertStatus(Level.ERROR);
    measure.setAlertText("alert");
    measure.setDate(new Date());
    measure.setDescription("description");
    measure.setPersistenceMode(null);
    measure.setPersonId(3);
    measure.setUrl("http://foo");
    measure.setVariation1(11.0);
    measure.setVariation2(12.0);
    measure.setVariation3(13.0);
    measure.setVariation4(14.0);
    measure.setVariation5(15.0);
    measureCache.put(file1, measure);

    Measure savedMeasure = measureCache.byResource(file1).iterator().next();
    assertThat(EqualsBuilder.reflectionEquals(measure, savedMeasure)).isTrue();
  }
  public void saveMeasures(final Map<String, List<Measure>> measures) {

    if (measures == null) {
      return;
    }

    for (Map.Entry<String, List<Measure>> entry : measures.entrySet()) {
      final org.sonar.api.resources.File objcfile =
          org.sonar.api.resources.File.fromIOFile(
              new File(project.getFileSystem().getBasedir(), entry.getKey()), project);
      if (fileExists(sensorContext, objcfile)) {
        for (Measure measure : entry.getValue()) {
          try {
            LoggerFactory.getLogger(getClass())
                .debug("Save measure {} for file {}", measure.getMetric().getName(), objcfile);
            sensorContext.saveMeasure(objcfile, measure);
          } catch (Exception e) {
            LoggerFactory.getLogger(getClass())
                .error(" Exception -> {} -> {}", entry.getKey(), measure.getMetric().getName());
          }
        }
      }
    }
  }