private static DebtRemediationFunction remediationFunction(DebtRemediationFunction.Type function, @Nullable String coefficient, @Nullable String offset, RulesDefinition.DebtRemediationFunctions functions, String repoKey, String ruleKey) { if (DebtRemediationFunction.Type.LINEAR.equals(function) && coefficient != null) { return functions.linear(coefficient); } else if (DebtRemediationFunction.Type.CONSTANT_ISSUE.equals(function) && offset != null) { return functions.constantPerIssue(offset); } else if (DebtRemediationFunction.Type.LINEAR_OFFSET.equals(function) && coefficient != null && offset != null) { return functions.linearWithOffset(coefficient, offset); } else { throw new IllegalArgumentException(String.format("Debt definition on rule '%s:%s' is invalid", repoKey, ruleKey)); } }
public DebtRemediationFunction remediationFunction(DebtRemediationFunctions drf) { if(func.startsWith("Constant")) { return drf.constantPerIssue(constantCost.replace("mn", "min")); } if("Linear".equals(func)) { return drf.linear(linearFactor.replace("mn", "min")); } return drf.linearWithOffset(linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min")); } }
private DebtRemediationFunction remediationFunction(DebtRemediationFunctions drf) { if (func.startsWith("Constant")) { return drf.constantPerIssue(constantCost.replace("mn", "min")); } if ("Linear".equals(func)) { return drf.linear(linearFactor.replace("mn", "min")); } return drf.linearWithOffset(linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min")); } }
private void setupSqaleModel(NewRule rule, Class<?> ruleClass) { SqaleConstantRemediation constant = AnnotationUtils.getAnnotation(ruleClass, SqaleConstantRemediation.class); SqaleLinearRemediation linear = AnnotationUtils.getAnnotation(ruleClass, SqaleLinearRemediation.class); SqaleLinearWithOffsetRemediation linearWithOffset = AnnotationUtils.getAnnotation(ruleClass, SqaleLinearWithOffsetRemediation.class); Set<Annotation> remediations = Sets.newHashSet(constant, linear, linearWithOffset); if (Iterables.size(Iterables.filter(remediations, Predicates.notNull())) > 1) { throw new IllegalArgumentException("Found more than one SQALE remediation annotations on " + ruleClass); } if (constant != null) { rule.setDebtRemediationFunction(rule.debtRemediationFunctions().constantPerIssue(constant.value())); } if (linear != null) { rule.setDebtRemediationFunction(rule.debtRemediationFunctions().linear(linear.coeff())); rule.setGapDescription(linear.effortToFixDescription()); } if (linearWithOffset != null) { rule.setDebtRemediationFunction( rule.debtRemediationFunctions().linearWithOffset(linearWithOffset.coeff(), linearWithOffset.offset())); rule.setGapDescription(linearWithOffset.effortToFixDescription()); } }
private void setupSqaleModel(NewRule rule, Class<?> ruleClass) { SqaleConstantRemediation constant = AnnotationUtils.getAnnotation(ruleClass, SqaleConstantRemediation.class); SqaleLinearRemediation linear = AnnotationUtils.getAnnotation(ruleClass, SqaleLinearRemediation.class); SqaleLinearWithOffsetRemediation linearWithOffset = AnnotationUtils.getAnnotation(ruleClass, SqaleLinearWithOffsetRemediation.class); Set<Annotation> remediations = Sets.newHashSet(constant, linear, linearWithOffset); if (Iterables.size(Iterables.filter(remediations, Predicates.notNull())) > 1) { throw new IllegalArgumentException("Found more than one SQALE remediation annotations on " + ruleClass); } if (constant != null) { rule.setDebtRemediationFunction(rule.debtRemediationFunctions().constantPerIssue(constant.value())); } if (linear != null) { rule.setDebtRemediationFunction(rule.debtRemediationFunctions().linear(linear.coeff())); rule.setGapDescription(linear.effortToFixDescription()); } if (linearWithOffset != null) { rule.setDebtRemediationFunction( rule.debtRemediationFunctions().linearWithOffset(linearWithOffset.coeff(), linearWithOffset.offset())); rule.setGapDescription(linearWithOffset.effortToFixDescription()); } }
private static void setRemediationFromJson(NewRule rule, Map<String, Object> remediation) { String func = getString(remediation, "func"); DebtRemediationFunctions remediationBuilder = rule.debtRemediationFunctions(); if (func.startsWith("Constant")) { String constantCost = getString(remediation, "constantCost"); rule.setDebtRemediationFunction(remediationBuilder.constantPerIssue(constantCost.replace("mn", "min"))); } else if ("Linear".equals(func)) { String linearFactor = getString(remediation, "linearFactor"); rule.setDebtRemediationFunction(remediationBuilder.linear(linearFactor.replace("mn", "min"))); } else { String linearFactor = getString(remediation, "linearFactor"); String linearOffset = getString(remediation, "linearOffset"); rule.setDebtRemediationFunction(remediationBuilder.linearWithOffset( linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min"))); } if (remediation.get("linearDesc") != null) { rule.setGapDescription(getString(remediation, "linearDesc")); } }
/** * IMPORTANT This method should not be used when SonarQube runtime version is less than 7.2 * because it would trigger calls to {@link org.sonar.api.server.rule.RulesDefinition.Context#createExternalRepository} * which was added in SonarQube 7.2. */ public void createExternalRuleRepository(org.sonar.api.server.rule.RulesDefinition.Context context) { NewRepository externalRepo = context.createExternalRepository(linterKey, languageKey).setName(linterName); for (ExternalRule rule : rulesMap.values()) { NewRule newRule = externalRepo.createRule(rule.key).setName(rule.name); newRule.setHtmlDescription(rule.getDescription(linterKey, linterName)); newRule.setDebtRemediationFunction(newRule.debtRemediationFunctions().constantPerIssue(rule.constantDebtMinutes + "min")); newRule.setType(rule.type); if (rule.tags != null) { newRule.setTags(rule.tags); } if (rule.severity != null) { newRule.setSeverity(rule.severity); } } externalRepo.done(); }
public static void createExternalRuleRepository(Context context, String linterId, String linterName) { NewRepository externalRepo = context.createExternalRepository(linterId, GoLanguage.KEY).setName(linterName); String pathToRulesMeta = "org/sonar/l10n/go/rules/" + linterId + "/rules.json"; try (InputStreamReader inputStreamReader = new InputStreamReader(AbstractReportSensor.class.getClassLoader().getResourceAsStream(pathToRulesMeta), StandardCharsets.UTF_8)) { ExternalRule[] rules = new Gson().fromJson(inputStreamReader, ExternalRule[].class); for (ExternalRule rule : rules) { NewRule newRule = externalRepo.createRule(rule.key).setName(rule.name); newRule.setHtmlDescription(rule.description); newRule.setDebtRemediationFunction(newRule.debtRemediationFunctions().constantPerIssue(DEFAULT_REMEDIATION_COST + "min")); if (linterId.equals(GoVetReportSensor.LINTER_ID)) { newRule.setType(RuleType.BUG); } } } catch (IOException e) { throw new IllegalStateException("Can't read resource: " + pathToRulesMeta, e); } externalRepo.done(); }
@Override public void define(Context context) { NewRepository repository = context.createRepository(repositoryKey(), "php").setName("MyCompany Custom Repository"); // Load rule meta data from annotations RulesDefinitionAnnotationLoader annotationLoader = new RulesDefinitionAnnotationLoader(); checkClasses().forEach(ruleClass -> annotationLoader.load(repository, ruleClass)); // Optionally override html description from annotation with content from html files repository.rules().forEach(rule -> rule.setHtmlDescription(loadResource("/org/sonar/l10n/php/rules/custom/" + rule.key() + ".html"))); // Optionally define remediation costs Map<String, String> remediationCosts = new HashMap<>(); remediationCosts.put(ForbiddenFunctionUseCheck.KEY, "5min"); remediationCosts.put(OtherForbiddenFunctionUseCheck.KEY, "5min"); repository.rules().forEach(rule -> rule.setDebtRemediationFunction( rule.debtRemediationFunctions().constantPerIssue(remediationCosts.get(rule.key())))); repository.done(); }
private void createWarningRule(NewRepository repository, String ruleKey, String name, String remediationCost, Priority priority, String[] tags) { NewRule warning = repository.createRule(ruleKey).setName(name).setSeverity(priority.name()); warning.setTags(tags); warning.setDebtRemediationFunction(warning.debtRemediationFunctions().constantPerIssue(remediationCost)); warning.setType(RuleType.CODE_SMELL); warning.setHtmlDescription(getClass().getResource( String.format(HTML_DOC_PATH, Constants.LANGUAGE_KEY, Constants.STD_REPOSITORY_KEY, warning.key()))); } }
private DebtRemediationFunction remediationFunction(final DebtRemediationFunctions drf) { if (this.func.startsWith("Constant")) { return drf.constantPerIssue(this.constantCost.replace("mn", "min")); } if ("Linear".equals(this.func)) { return drf.linear(this.coeff.replace("mn", "min")); } return drf.linearWithOffset(this.coeff.replace("mn", "min"), this.linearOffset.replace("mn", "min")); } }
public DebtRemediationFunction remediationFunction(DebtRemediationFunctions drf) { if (func.startsWith("Constant")) { return drf.constantPerIssue(constantCost.replace("mn", "min")); } if ("Linear".equals(func)) { return drf.linear(linearFactor.replace("mn", "min")); } return drf.linearWithOffset(linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min")); } }
public DebtRemediationFunction remediationFunction(DebtRemediationFunctions debt) { if (func.startsWith("Constant")) { return debt.constantPerIssue(constantCost.replace("mn", "min")); } if ("Linear".equals(func)) { return debt.linear(linearFactor.replace("mn", "min")); } return debt.linearWithOffset(linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min")); } }
private static void setupSqaleModel(NewRule rule, Class<?> ruleClass) { ConstantRemediation constant = AnnotationUtils.getAnnotation(ruleClass, ConstantRemediation.class); if (constant != null) { rule.setDebtRemediationFunction(rule.debtRemediationFunctions().constantPerIssue(constant.value())); } }
public DebtRemediationFunction remediationFunction(DebtRemediationFunctions drf) { if (func.startsWith("Constant")) { return drf.constantPerIssue(constantCost.replace("mn", "min")); } if ("Linear".equals(func)) { return drf.linear(linearFactor.replace("mn", "min")); } return drf.linearWithOffset(linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min")); } }
private void setTechnicalDebt(RulesDefinition.NewRule rule, Metadata metadataAnnotation) { String technicalDebt = metadataAnnotation.technicalDebt(); if (StringUtils.isNotEmpty(technicalDebt)) { DebtRemediationFunctions remediationFunction = rule.debtRemediationFunctions(); rule.setDebtRemediationFunction(remediationFunction.constantPerIssue(technicalDebt)); } }
private static DebtRemediationFunction remediationFunction(DebtRemediationFunction.Type function, @Nullable String coefficient, @Nullable String offset, RulesDefinition.DebtRemediationFunctions functions, String repoKey, String ruleKey) { if (DebtRemediationFunction.Type.LINEAR.equals(function) && coefficient != null) { return functions.linear(coefficient); } else if (DebtRemediationFunction.Type.CONSTANT_ISSUE.equals(function) && offset != null) { return functions.constantPerIssue(offset); } else if (DebtRemediationFunction.Type.LINEAR_OFFSET.equals(function) && coefficient != null && offset != null) { return functions.linearWithOffset(coefficient, offset); } else { throw new IllegalArgumentException(String.format("Debt definition on rule '%s:%s' is invalid", repoKey, ruleKey)); } }
private DebtRemediationFunction remediationFunction(DebtRemediationFunctions functions, String remediationFunction, String offset, String remediationFactor) { if ("CONSTANT_ISSUE".equalsIgnoreCase(remediationFunction)) { return functions.constantPerIssue(offset); } else if ("LINEAR".equalsIgnoreCase(remediationFunction)) { return functions.linear(remediationFactor); } else if ("LINEAR_OFFSET".equalsIgnoreCase(remediationFunction)) { return functions.linearWithOffset(remediationFactor, offset); } return null; }
@Override public boolean setRemediation(NewRule sonarRule, SqaleRemediation remediation) { if(remediation instanceof SqaleConstantRemediation) { SqaleConstantRemediation constantRemediation = (SqaleConstantRemediation) remediation; sonarRule.setDebtRemediationFunction(sonarRule.debtRemediationFunctions().constantPerIssue(constantRemediation.getOffset())); return true; } else { return false; } }
.setHtmlDescription("Search for a given tag in Xoo files"); hasTag .setDebtRemediationFunction(hasTag.debtRemediationFunctions().constantPerIssue("2min")); hasTag.createParam("tag") .setDefaultValue("xoo") .setHtmlDescription("Search for Security Hotspots in Xoo files"); hotspot .setDebtRemediationFunction(hotspot.debtRemediationFunctions().constantPerIssue("2min"));