org.sonar.api.batch.sensor.issue.NewIssue Java Examples

private void saveVulnerabilities(List<Vulnerability> vulnerabilities, SensorContext context) {
    Optional<InputFile> fileOptional = getFile("project.clj", context.fileSystem());

    fileOptional.ifPresent(projectFile -> {
        for (Vulnerability v : vulnerabilities) {
            LOG.debug("Processing vulnerability: " +v.toString());
            RuleKey ruleKey = RuleKey.of(ClojureLintRulesDefinition.REPOSITORY_KEY, "nvd-" + v.getSeverity().toLowerCase());
            NewIssue newIssue = context.newIssue().forRule(ruleKey);
            NewIssueLocation primaryLocation = newIssue
                    .newLocation()
                    .on(projectFile)
                    .message(v.getName()
                            + ";" + v.getCwes()
                            + ";" + v.getFileName())
                    .at(projectFile.selectLine(1));
            newIssue.at(primaryLocation);
            newIssue.save();
        }
    });
}
 

private void saveViolations(SensorContext context, InputFile inputFile, SourceFile squidFile) {
  Collection<CheckMessage> messages = squidFile.getCheckMessages();
  if (messages != null) {

    for (CheckMessage message : messages) {
      RuleKey ruleKey = checks.ruleKey((SquidCheck<LexerlessGrammar>) message.getCheck());
      NewIssue newIssue = context.newIssue()
        .forRule(ruleKey)
        .gap(message.getCost());
      Integer line = message.getLine();
      NewIssueLocation location = newIssue.newLocation()
        .on(inputFile)
        .message(message.getText(Locale.ENGLISH));
      if (line != null) {
        location.at(inputFile.selectLine(line));
      }
      newIssue.at(location);
      newIssue.save();
    }
  }
}
 

private static void savePreciseIssue(SensorContext sensorContext, InputFile inputFile, RuleKey ruleKey, PreciseIssue issue) {
    NewIssue newIssue = sensorContext.newIssue();

    newIssue
            .forRule(ruleKey)
            .at(newLocation(inputFile, newIssue, issue.primaryLocation()));

    if (issue.cost() != null) {
        newIssue.gap(issue.cost());
    }

    for (IssueLocation secondary : issue.secondaryLocations()) {
        newIssue.addLocation(newLocation(inputFile, newIssue, secondary));
    }
    newIssue.save();
}
 

private void processRecognitionException(RecognitionException e, SensorContext sensorContext, InputFile inputFile) {
    if (parsingErrorRuleKey != null) {
        NewIssue newIssue = sensorContext.newIssue();

        NewIssueLocation primaryLocation = newIssue.newLocation()
                .message(ParsingErrorCheck.MESSAGE)
                .on(inputFile)
                .at(inputFile.selectLine(e.getLine()));

        newIssue
                .forRule(parsingErrorRuleKey)
                .at(primaryLocation)
                .save();
    }

    sensorContext.newAnalysisError()
            .onFile(inputFile)
            .at(inputFile.newPointer(e.getLine(), 0))
            .message(e.getMessage())
            .save();
}
 

public static void saveIssues(SensorContext context, HtmlSourceCode sourceCode) {
    InputFile inputFile = sourceCode.inputFile();

    for (HtmlIssue issue : sourceCode.getIssues()) {
        NewIssue newIssue = context.newIssue()
            .forRule(issue.ruleKey())
            .gap(issue.cost());
        Integer line = issue.line();
        NewIssueLocation location = newIssue.newLocation()
            .on(inputFile)
            .message(issue.message());
        if (line != null && line > 0) {
            location.at(inputFile.selectLine(line));
        }
        newIssue.at(location);
        newIssue.save();
    }
}
 

private void saveLineIssue(LineIssue issue) {
  NewIssue newIssue = sensorContext.newIssue();
  InputFile primaryFile = Preconditions.checkNotNull(fileSystem.inputFile(fileSystem.predicates().is(issue.file())));

  NewIssueLocation primaryLocation = newIssue.newLocation()
    .message(issue.message())
    .on(primaryFile)
    .at(primaryFile.selectLine(issue.line()));

  newIssue
    .forRule(ruleKey(issue.check()))
    .at(primaryLocation);

  if (issue.cost() != null) {
    newIssue.gap(issue.cost());
  }

  newIssue.save();
}
 

private void savePreciseIssue(PreciseIssue issue) {
  NewIssue newIssue = sensorContext.newIssue();
  InputFile primaryFile = Preconditions.checkNotNull(fileSystem.inputFile(fileSystem.predicates().is(issue.primaryLocation().file())));

  newIssue
    .forRule(ruleKey(issue.check()))
    .at(newLocation(primaryFile, newIssue, issue.primaryLocation()));

  if (issue.cost() != null) {
    newIssue.gap(issue.cost());
  }

  InputFile secondaryFile;
  for (IssueLocation secondary : issue.secondaryLocations()) {
    secondaryFile = fileSystem.inputFile(fileSystem.predicates().is(secondary.file()));
    if (secondaryFile == null) {
      secondaryFile = primaryFile;
    }
    newIssue.addLocation(newLocation(secondaryFile, newIssue, secondary));
  }

  newIssue.save();
}
 

private void saveNewIssue(RubocopIssue issue, InputFile inputFile, Set<String> ruleNames, SensorContext sensorContext) {
    // Make sure the rule we're violating is one we recognise - if not, we'll
    // fall back to the generic 'rubocop-issue' rule
    String ruleName = issue.getRuleName();
    if (!ruleNames.contains(ruleName)) {
        ruleName = RubyRulesDefinition.RUBY_LINT_UNKNOWN_RULE.key;
    }

    NewIssue newIssue =
        sensorContext
            .newIssue()
            .forRule(RuleKey.of("rubocop", ruleName));

    NewIssueLocation newIssueLocation =
        newIssue
            .newLocation()
            .on(inputFile)
            .message(issue.getFailure())
            .at(inputFile.selectLine(issue.getPosition().getLine()));

    newIssue.at(newIssueLocation);
    newIssue.save();
}
 

private void saveLineIssue(LineIssue issue) {
  NewIssue newIssue = sensorContext.newIssue();
  InputFile primaryFile = Preconditions.checkNotNull(fileSystem.inputFile(fileSystem.predicates().is(issue.file())));

  NewIssueLocation primaryLocation = newIssue.newLocation()
    .message(issue.message())
    .on(primaryFile)
    .at(primaryFile.selectLine(issue.line()));

  newIssue
    .forRule(ruleKey(issue.check()))
    .at(primaryLocation);

  if (issue.cost() != null) {
    newIssue.gap(issue.cost());
  }

  newIssue.save();
}
 

protected void saveIssue(Issue issue, SensorContext context) {
    try {
        Optional<InputFile> fileOptional = getFile(issue.getFilePath(), context.fileSystem());

        if (fileOptional.isPresent()) {
            InputFile file = fileOptional.get();
            RuleKey ruleKey = RuleKey.of(ClojureLintRulesDefinition.REPOSITORY_KEY, issue.getExternalRuleId().trim());

            NewIssue newIssue = context.newIssue().forRule(ruleKey);

            NewIssueLocation primaryLocation = newIssue
                    .newLocation()
                    .on(file)
                    .message(issue.getDescription().trim());

            primaryLocation.at(file.selectLine(issue.getLine()));

            newIssue.at(primaryLocation);
            newIssue.save();
        } else {
            LOG.warn("Not able to find a file with path '{}'", issue.getFilePath());
        }
    } catch (Exception e) {
        LOG.error("Can not save the issue due to: " + e.getMessage());
    }
}
 

/**
 * Saves the found issues in SonarQube
 *
 * @param context the context
 * @param inputFile the file where the issue was found
 * @param line the line where the issue was found
 * @param ruleId the Id of the rule that raised the issue
 * @param message a message describing the issue
 */
protected void saveIssue(SensorContext context, InputFile inputFile, int line, String ruleId, String message) {
    RuleKey ruleKey = getRuleKey(context, ruleId);

    // Old rules (ansible-lint < 3.5) had id ANSIBLE... but now it is E... so we may need to add the heading E back
    if (ruleKey == null) {
        ruleKey = getRuleKey(context, "E" + ruleId);
    }

    if (ruleKey == null) {
        LOGGER.debug("Rule " + ruleId + " ignored, not found in repository");
        return;
    }

    NewIssue newIssue = context.newIssue().forRule(ruleKey);
    NewIssueLocation location = newIssue.newLocation()
            .on(inputFile)
            .message(message)
            .at(inputFile.selectLine(line));
    newIssue.at(location).save();
    LOGGER.debug("Issue {} saved for {}", ruleId, inputFile.filename());
}
 

private void savePreciseIssue(PreciseIssue issue) {
  NewIssue newIssue = sensorContext.newIssue();
  InputFile primaryFile = Preconditions.checkNotNull(fileSystem.inputFile(fileSystem.predicates().is(issue.primaryLocation().file())));

  newIssue
    .forRule(ruleKey(issue.check()))
    .at(newLocation(primaryFile, newIssue, issue.primaryLocation()));

  if (issue.cost() != null) {
    newIssue.gap(issue.cost());
  }

  InputFile secondaryFile;
  for (IssueLocation secondary : issue.secondaryLocations()) {
    secondaryFile = fileSystem.inputFile(fileSystem.predicates().is(secondary.file()));
    if (secondaryFile == null) {
      secondaryFile = primaryFile;
    }
    newIssue.addLocation(newLocation(secondaryFile, newIssue, secondary));
  }

  newIssue.save();
}
 

@Override
public void addError(AuditEvent event) {
    final String ruleKey = getRuleKey(event);

    if (Objects.nonNull(ruleKey)) {
        final String message = getMessage(event);
        // In Checkstyle 5.5 exceptions are reported as an events from
        // TreeWalker
        if ("com.puppycrawl.tools.checkstyle.TreeWalker".equals(ruleKey)) {
            LOG.warn("{} : {}", event.getFileName(), message);
        }

        initResource(event);

        final NewIssue issue = context.newIssue();
        final ActiveRule rule = ruleFinder.find(
                RuleKey.of(CheckstyleConstants.REPOSITORY_KEY, ruleKey));
        if (Objects.nonNull(issue) && Objects.nonNull(rule)) {
            final NewIssueLocation location = issue.newLocation()
                    .on(currentResource)
                    .at(currentResource.selectLine(getLineId(event)))
                    .message(message);
            issue.forRule(rule.ruleKey())
                    .at(location)
                    .save();
        }
    }
}
 

private void saveOutdated(List<OutdatedDependency> outdatedDependencies, SensorContext context) {

        Optional<InputFile> fileOptional = getFile("project.clj", context.fileSystem());

        fileOptional.ifPresent(projectFile -> outdatedDependencies.forEach(outdatedDependency -> {
            ProjectFile pr;
            try {
                pr = new ProjectFile(projectFile.contents());
            } catch (IOException e) {
                LOG.warn("project.clj could not be read");
                return;
            }
            LOG.debug("Processing outdated dependencies");

            RuleKey ruleKey = RuleKey.of(ClojureLintRulesDefinition.REPOSITORY_KEY, "ancient-clj-dependency");
            NewIssue newIssue = context.newIssue().forRule(ruleKey);
            int lineNumber = pr.findLineNumber(
                    outdatedDependency.getName() + " \"" + outdatedDependency.getCurrentVersion() + "\"");

            NewIssueLocation primaryLocation = newIssue
                    .newLocation()
                    .on(projectFile)
                    .message(outdatedDependency.toString())
                    .at(projectFile.selectLine(lineNumber));
            newIssue.at(primaryLocation);
            newIssue.save();
        }));
    }
 

private static void saveIssue(NewIssue newIssue, NewIssueLocation primaryLocation, RuleKey ruleKey, Issue issue) {
    newIssue
            .forRule(ruleKey)
            .at(primaryLocation);

    if (issue.cost() != null) {
        newIssue.gap(issue.cost());
    }

    newIssue.save();
}
 

private static void saveFileIssue(SensorContext sensorContext, InputFile inputFile, RuleKey ruleKey, FileIssue issue) {
    NewIssue newIssue = sensorContext.newIssue();

    NewIssueLocation primaryLocation = newIssue.newLocation()
            .message(issue.message())
            .on(inputFile);

    saveIssue(newIssue, primaryLocation, ruleKey, issue);
}
 

private static void saveLineIssue(SensorContext sensorContext, InputFile inputFile, RuleKey ruleKey, LineIssue issue) {
    NewIssue newIssue = sensorContext.newIssue();

    NewIssueLocation primaryLocation = newIssue.newLocation()
            .message(issue.message())
            .on(inputFile)
            .at(inputFile.selectLine(issue.line()));

    saveIssue(newIssue, primaryLocation, ruleKey, issue);
}
 

private void processRecognitionException(RecognitionException e, SensorContext sensorContext, InputFile inputFile) {
  if (parsingErrorRuleKey != null) {
    NewIssue newIssue = sensorContext.newIssue();

    NewIssueLocation primaryLocation = newIssue.newLocation()
      .message(e.getMessage())
      .on(inputFile)
      .at(inputFile.selectLine(e.getLine()));

    newIssue
      .forRule(parsingErrorRuleKey)
      .at(primaryLocation)
      .save();
  }
}
 

private void processRecognitionExceptionForCustomRule(SightlyCompilerException e, SensorContext sensorContext, InputFile inputFile) {
    NewIssue newIssue = sensorContext.newIssue();

    NewIssueLocation primaryLocation = newIssue.newLocation()
        .message("Parse error: " + e.getMessage())
        .on(inputFile)
        .at(inputFile.selectLine(e.getLine()));

    newIssue
        .forRule(parsingErrorRuleKey)
        .at(primaryLocation)
        .save();
}
 

private void saveFileIssue(FileIssue issue) {
  NewIssue newIssue = sensorContext.newIssue();
  InputFile primaryFile = Preconditions.checkNotNull(fileSystem.inputFile(fileSystem.predicates().is(issue.file())));

  NewIssueLocation primaryLocation = newIssue.newLocation()
    .message(issue.message())
    .on(primaryFile);

  newIssue
    .forRule(ruleKey(issue.check()))
    .at(primaryLocation);

  if (issue.cost() != null) {
    newIssue.gap(issue.cost());
  }

  InputFile secondaryFile;
  for (IssueLocation secondary : issue.secondaryLocations()) {
    secondaryFile = fileSystem.inputFile(fileSystem.predicates().is(secondary.file()));
    if (secondaryFile == null) {
      secondaryFile = primaryFile;
    }
    newIssue.addLocation(newLocation(secondaryFile, newIssue, secondary));
  }

  newIssue.save();
}
 

private void saveFileIssue(FileIssue issue) {
  NewIssue newIssue = sensorContext.newIssue();
  InputFile primaryFile = Preconditions.checkNotNull(fileSystem.inputFile(fileSystem.predicates().is(issue.file())));

  NewIssueLocation primaryLocation = newIssue.newLocation()
    .message(issue.message())
    .on(primaryFile);

  newIssue
    .forRule(ruleKey(issue.check()))
    .at(primaryLocation);

  if (issue.cost() != null) {
    newIssue.gap(issue.cost());
  }

  InputFile secondaryFile;
  for (IssueLocation secondary : issue.secondaryLocations()) {
    secondaryFile = fileSystem.inputFile(fileSystem.predicates().is(secondary.file()));
    if (secondaryFile == null) {
      secondaryFile = primaryFile;
    }
    newIssue.addLocation(newLocation(secondaryFile, newIssue, secondary));
  }

  newIssue.save();
}
 

private void processRecognitionException(RecognitionException e, SensorContext sensorContext, InputFile inputFile) {
  if (parsingErrorRuleKey != null) {
    NewIssue newIssue = sensorContext.newIssue();

    NewIssueLocation primaryLocation = newIssue.newLocation()
      .message(e.getMessage())
      .on(inputFile)
      .at(inputFile.selectLine(e.getLine()));

    newIssue
      .forRule(parsingErrorRuleKey)
      .at(primaryLocation)
      .save();
  }
}
 

@Test
public void licenseUnknown()
{
    SensorContext context = createContext();
    NewIssue issue = new DefaultIssue(mock(DefaultInputProject.class), mock(SensorStorage.class));
    when(context.newIssue()).thenReturn(issue);

    validateLicenses.validateLicenses(deps(new Dependency("thing", "1.0", "Mamamia")), context);

    verify(context).newIssue();
    assertThat(issue.toString(), containsString(LicenseCheckMetrics.LICENSE_CHECK_UNLISTED_KEY));
}
 

@Test
public void licenseNull()
{
    SensorContext context = createContext();
    NewIssue issue = new DefaultIssue(mock(DefaultInputProject.class), mock(SensorStorage.class));
    when(context.newIssue()).thenReturn(issue);

    validateLicenses.validateLicenses(deps(new Dependency("thing", "1.0", null)), context);

    verify(context).newIssue();
    assertThat(issue.toString(), containsString(LicenseCheckMetrics.LICENSE_CHECK_UNLISTED_KEY));
}
 

@Test
public void checkSpdxAndCombinationNotFound()
{
    SensorContext context = createContext();
    NewIssue issue = new DefaultIssue(mock(DefaultInputProject.class), mock(SensorStorage.class));
    when(context.newIssue()).thenReturn(issue);

    validateLicenses.validateLicenses(deps(new Dependency("thing", "1.0", "(Apache-2.0 AND Apache-1.1)")), context);

    verify(context).newIssue();
    assertThat(issue.toString(), containsString(LicenseCheckMetrics.LICENSE_CHECK_UNLISTED_KEY));
}
 

@Test
public void checkSpdxAndCombinationNotAllowed()
{
    SensorContext context = createContext();
    NewIssue issue = new DefaultIssue(mock(DefaultInputProject.class), mock(SensorStorage.class));
    when(context.newIssue()).thenReturn(issue);

    validateLicenses.validateLicenses(
        deps(new Dependency("another", "2.0", "LGPL"), new Dependency("thing", "1.0", "(Apache-2.0 AND MIT)")),
        context);

    verify(context).newIssue();
    assertThat(issue.toString(), containsString(LicenseCheckMetrics.LICENSE_CHECK_NOT_ALLOWED_LICENSE_KEY));
}
 

@Test
public void licenseNotAllowed()
{
    SensorContext context = createContext();
    NewIssue issue = new DefaultIssue(mock(DefaultInputProject.class), mock(SensorStorage.class));
    when(context.newIssue()).thenReturn(issue);

    validateLicenses.validateLicenses(deps(new Dependency("thing", "1.0", "MIT")), context);

    verify(context).newIssue();
    assertThat(issue.toString(), containsString(LicenseCheckMetrics.LICENSE_CHECK_NOT_ALLOWED_LICENSE_KEY));
}
 

private static void licenseNotFoundIssue(SensorContext context, Dependency dependency)
{
    LOGGER.info("No License found for Dependency " + dependency.getName());

    NewIssue issue = context
        .newIssue()
        .forRule(RuleKey.of(LicenseCheckMetrics.LICENSE_CHECK_KEY,
            LicenseCheckMetrics.LICENSE_CHECK_UNLISTED_KEY))
        .at(new DefaultIssueLocation()
            .on(context.module())
            .message("No License found for Dependency: " + dependency.getName()));
    issue.save();
}
 

private void licenseNotAllowedIssue(SensorContext context, Dependency dependency, String notAllowedLicense)
{
    LOGGER.info("Dependency " + dependency.getName() + " uses a not allowed license " + notAllowedLicense);

    NewIssue issue = context
        .newIssue()
        .forRule(RuleKey.of(LicenseCheckMetrics.LICENSE_CHECK_KEY,
            LicenseCheckMetrics.LICENSE_CHECK_NOT_ALLOWED_LICENSE_KEY))
        .at(new DefaultIssueLocation().on(context.module()).message(
            "Dependency " + dependency.getName() + " uses a not allowed license " + dependency.getLicense()));
    issue.save();
}
 

private void createNewIssue(IssueAttributes issueAttributes, LocationAttributes locationAttributes, InputFile inputFile) {
    if(issueAttributes == null){
        logger.debug("Problem creating issue for file {} issueAttributes is null", inputFile);
    }
    if(locationAttributes == null){
        logger.debug("Problem creating issue for file {} locationAttributes is null", inputFile);
    }
    if(inputFile==null){
        logger.debug("Problem creating issue for file inputFile is null");
    }
    if(issueAttributes == null || locationAttributes == null || inputFile == null){
        return;
    }

    if(locationAttributes.getLine().isPresent() && locationAttributes.getLine().get()>inputFile.lines()){
        logger
            .error("Problem creating issue for file {}, issue is line {} but file has {} lines", inputFile, locationAttributes.getLine().get(), inputFile.lines());
        return;
    }

    logger.debug("create New Issue {} for file {}", issueAttributes, inputFile.filename());
    final NewIssue issue = sensorContext.newIssue();

    final NewIssueLocation issueLocation = issue.newLocation();
    issueLocation.on(inputFile);
    issueLocation.at(inputFile.selectLine(locationAttributes.getLine().get()));
    issueLocation.message(locationAttributes.getMessage().get());

    issue.forRule(RuleKey.of(ColdFusionPlugin.REPOSITORY_KEY, issueAttributes.getId().get()));
    issue.at(issueLocation);
    issue.save();
}