/** * Loads descriptions of rules and related rule parameters. Existing descriptions * are overridden if English labels exist in bundles. */ public void load(RulesDefinition.NewRepository repo) { for (RulesDefinition.NewRule rule : repo.rules()) { String name = i18n.getName(repo.key(), rule.key()); if (StringUtils.isNotBlank(name)) { rule.setName(name); } String desc = i18n.getDescription(repo.key(), rule.key()); if (StringUtils.isNotBlank(desc)) { rule.setHtmlDescription(desc); } for (RulesDefinition.NewParam param : rule.params()) { String paramDesc = i18n.getParamDescription(repo.key(), rule.key(), param.key()); if (StringUtils.isNotBlank(paramDesc)) { param.setDescription(paramDesc); } } } } }
@Test public void override_annotation_programmatically() { RulesDefinition.Context context = new RulesDefinition.Context(); RulesDefinition.NewRepository newRepository = context.createRepository("squid", "java"); NewRule newRule = annotationLoader.loadRule(newRepository, RuleWithProperty.class); newRule.setName("Overridden name"); newRule.param("property").setDefaultValue("true"); newRule.param("property").setDescription("Overridden"); newRepository.done(); RulesDefinition.Repository repository = context.repository("squid"); assertThat(repository.rules()).hasSize(1); RulesDefinition.Rule rule = repository.rules().get(0); assertThat(rule.key()).isEqualTo("foo"); assertThat(rule.status()).isEqualTo(RuleStatus.BETA); assertThat(rule.name()).isEqualTo("Overridden name"); assertThat(rule.htmlDescription()).isEqualTo("Foo Bar"); assertThat(rule.severity()).isEqualTo(Severity.BLOCKER); assertThat(rule.params()).hasSize(1); RulesDefinition.Param prop = rule.param("property"); assertThat(prop.key()).isEqualTo("property"); assertThat(prop.description()).isEqualTo("Overridden"); assertThat(prop.defaultValue()).isEqualTo("true"); assertThat(prop.type()).isEqualTo(RuleParamType.STRING); }
@Test public void define_rule_parameters() { RulesDefinition.NewRepository newFindbugs = context.createRepository("findbugs", "java"); RulesDefinition.NewRule newNpe = newFindbugs.createRule("NPE").setName("NPE").setHtmlDescription("NPE"); newNpe.createParam("level").setDefaultValue("LOW").setName("Level").setDescription("The level").setType(RuleParamType.INTEGER); newNpe.createParam("effort"); newFindbugs.done(); RulesDefinition.Rule rule = context.repository("findbugs").rule("NPE"); assertThat(rule.params()).hasSize(2); RulesDefinition.Param level = rule.param("level"); assertThat(level.key()).isEqualTo("level"); assertThat(level.name()).isEqualTo("Level"); assertThat(level.description()).isEqualTo("The level"); assertThat(level.defaultValue()).isEqualTo("LOW"); assertThat(level.type()).isEqualTo(RuleParamType.INTEGER); RulesDefinition.Param effort = rule.param("effort"); assertThat(effort.key()).isEqualTo("effort").isEqualTo(effort.name()); assertThat(effort.description()).isNull(); assertThat(effort.defaultValue()).isNull(); assertThat(effort.type()).isEqualTo(RuleParamType.STRING); // test equals() and hashCode() assertThat(level).isEqualTo(level).isNotEqualTo(effort).isNotEqualTo("level").isNotEqualTo(null); assertThat(level.hashCode()).isEqualTo(level.hashCode()); }
.setDebtRemediationFunction(hasTag.debtRemediationFunctions().constantPerIssue("2min")); hasTag.createParam("tag") .setDefaultValue("xoo") .setDescription("The tag to search for"); ruleWithParameters.createParam("string").setType(RuleParamType.STRING); ruleWithParameters.createParam("text").setType(RuleParamType.TEXT); ruleWithParameters.createParam("boolean").setType(RuleParamType.BOOLEAN); ruleWithParameters.createParam("integer").setType(RuleParamType.INTEGER); ruleWithParameters.createParam("float").setType(RuleParamType.FLOAT);
.setDefaultValue(param.defaultValue) .setType(param.type) .setDescription(param.description);
final String paramDescriptionKey = baseKey + ".param." + param.key(); final String paramDescription = properties.getProperty(paramDescriptionKey); if (Objects.nonNull(paramDescription)) { param.setDescription(paramDescription);
@Override public void define(Context context) { NewRepository repository = context.createRepository(XOO_REPOSITORY, Xoo.KEY).setName("Xoo"); // Load checks new RulesDefinitionAnnotationLoader().load(repository, Check.ALL); // define a single rule programmatically. Note that rules // can be loaded from JSON or XML files too. NewRule x1Rule = repository.createRule("x1") .setName("No empty line") .setMarkdownDescription("Generate an issue on *empty* lines of Xoo source files") // optional tags .setTags("style", "security") // optional status. Default value is READY. .setStatus(RuleStatus.BETA) // default severity when the rule is activated on a Quality profile. Default value is MAJOR. .setSeverity(Severity.MINOR); // debt-related information x1Rule .setDebtSubCharacteristic(SubCharacteristics.INTEGRATION_TESTABILITY) .setDebtRemediationFunction(x1Rule.debtRemediationFunctions().linearWithOffset("1h", "30min")) .setEffortToFixDescription("Effort to fix issue on one line"); x1Rule.createParam("acceptWhitespace") .setDefaultValue("false") .setType(RuleParamType.BOOLEAN) .setDescription("= Accept whitespace (``\\s|\\t``) on the line\nThis property is available so that a line containing only whitespace is not considered empty.\n" + "== Example with property set to ``false``\n``xoo\n <- One issue here\n<- And one here\n``\n\n" + "== Example with property set to ``true``\n``xoo\n <- No issue here\n<- But one here\n``\n"); // don't forget to call done() to finalize the definition repository.done(); }
for (RuleParam param : rule.getParams()) { RulesDefinition.NewParam newParam = newRule.createParam(param.getKey()); newParam.setDefaultValue(param.getDefaultValue()); newParam.setDescription(paramDescription(repository.getKey(), rule.getKey(), param)); newParam.setType(RuleParamType.parse(param.getType()));
@Override public void define(Context context) { NewRepository repository = context .createRepository(DelphiPmdConstants.REPOSITORY_KEY, DelphiLanguage.KEY) .setName(DelphiPmdConstants.REPOSITORY_NAME); List<org.sonar.api.rules.Rule> rules = DelphiRulesUtils.getInitialReferential(); // TODO Review // https://github.com/SonarCommunity/sonar-pmd/blob/master/src/main/java/org/sonar/plugins/pmd/PmdRulesDefinition.java for (org.sonar.api.rules.Rule rule : rules) { NewRule newRule = repository.createRule(rule.getKey()) .setName(rule.getName()) .setHtmlDescription(rule.getDescription()) .setInternalKey(rule.getConfigKey()) .setSeverity(rule.getSeverity().name()); for (RuleParam param : rule.getParams()) { newRule.createParam(param.getKey()) .setDefaultValue(param.getDefaultValue()) .setType(RuleParamType.parse(param.getType())) .setDescription(param.getDescription()); } } SqaleXmlLoader.load(repository, "/org/sonar/plugins/delphi/sqale/delphi-model.xml"); repository.done(); }
private static void loadNames(NewRepository repository) { Properties properties = new Properties(); try (InputStream stream = PmdRulesDefinition.class.getResourceAsStream("/org/sonar/l10n/pmd.properties")) { properties.load(stream); } catch (IOException e) { throw new IllegalArgumentException("Could not read names from properties", e); } for (NewRule rule : repository.rules()) { String baseKey = "rule." + repository.key() + "." + rule.key(); String nameKey = baseKey + ".name"; String ruleName = properties.getProperty(nameKey); if (ruleName != null) { rule.setName(ruleName); } for (NewParam param : rule.params()) { String paramDescriptionKey = baseKey + ".param." + param.key(); String paramDescription = properties.getProperty(paramDescriptionKey); if (paramDescription != null) { param.setDescription(paramDescription); } } } } }
public static void loadNames(NewRepository repository, InputStream stream) { Properties properties = new Properties(); try { properties.load(stream); } catch (IOException e) { throw new IllegalArgumentException("Could not read names from properties", e); } for (NewRule rule : repository.rules()) { String baseKey = "rule." + repository.key() + "." + rule.key(); String nameKey = baseKey + ".name"; String ruleName = properties.getProperty(nameKey); if (ruleName != null) { rule.setName(ruleName); } for (NewParam param : rule.params()) { String paramDescriptionKey = baseKey + ".param." + param.key(); String paramDescription = properties.getProperty(paramDescriptionKey); if (paramDescription != null) { param.setDescription(paramDescription); } } } }
private void setupExternalNames(Collection<NewRule> rules) { ResourceBundle bundle; try { bundle = ResourceBundle.getBundle("org.sonar.l10n." + languageKey, locale); } catch (MissingResourceException e) { return; } for (NewRule rule : rules) { String baseKey = "rule." + repository.key() + "." + rule.key(); String nameKey = baseKey + ".name"; if (bundle.containsKey(nameKey)) { rule.setName(bundle.getString(nameKey)); } for (NewParam param : rule.params()) { String paramDescriptionKey = baseKey + ".param." + param.key(); if (bundle.containsKey(paramDescriptionKey)) { param.setDescription(bundle.getString(paramDescriptionKey)); } } } }
/** * Loads descriptions of rules and related rule parameters. Existing descriptions * are overridden if English labels exist in bundles. */ public void load(RulesDefinition.NewRepository repo) { for (RulesDefinition.NewRule rule : repo.rules()) { String name = i18n.getName(repo.key(), rule.key()); if (StringUtils.isNotBlank(name)) { rule.setName(name); } String desc = i18n.getDescription(repo.key(), rule.key()); if (StringUtils.isNotBlank(desc)) { rule.setHtmlDescription(desc); } for (RulesDefinition.NewParam param : rule.params()) { String paramDesc = i18n.getParamDescription(repo.key(), rule.key(), param.key()); if (StringUtils.isNotBlank(paramDesc)) { param.setDescription(paramDesc); } } } } }
private void setupExternalNames(Collection<NewRule> rules) { URL resource = AnnotationBasedRulesDefinition.class.getResource("/org/sonar/l10n/" + languageKey + ".properties"); if (resource == null) { return; } ResourceBundle bundle = ResourceBundle.getBundle("org.sonar.l10n." + languageKey, Locale.ENGLISH); for (NewRule rule : rules) { String baseKey = "rule." + repository.key() + "." + rule.key(); String nameKey = baseKey + ".name"; if (bundle.containsKey(nameKey)) { rule.setName(bundle.getString(nameKey)); } for (NewParam param : rule.params()) { String paramDescriptionKey = baseKey + ".param." + param.key(); if (bundle.containsKey(paramDescriptionKey)) { param.setDescription(bundle.getString(paramDescriptionKey)); } } } }
private void setupExternalNames(Collection<NewRule> rules) { URL resource = AnnotationBasedRulesDefinition.class.getResource("/org/sonar/l10n/" + languageKey + ".properties"); if (resource == null) { return; } ResourceBundle bundle = ResourceBundle.getBundle("org.sonar.l10n." + languageKey, Locale.ENGLISH); for (NewRule rule : rules) { String baseKey = "rule." + repository.key() + "." + rule.key(); String nameKey = baseKey + ".name"; if (bundle.containsKey(nameKey)) { rule.setName(bundle.getString(nameKey)); } for (NewParam param : rule.params()) { String paramDescriptionKey = baseKey + ".param." + param.key(); if (bundle.containsKey(paramDescriptionKey)) { param.setDescription(bundle.getString(paramDescriptionKey)); } } } }
private void setupExternalNames(Collection<NewRule> rules) { URL resource = AnnotationBasedRulesDefinition.class.getResource("/org/sonar/l10n/" + languageKey + ".properties"); if (resource == null) { return; } ResourceBundle bundle = ResourceBundle.getBundle("org.sonar.l10n." + languageKey, Locale.ENGLISH); for (NewRule rule : rules) { String baseKey = "rule." + repository.key() + "." + rule.key(); String nameKey = baseKey + ".name"; if (bundle.containsKey(nameKey)) { rule.setName(bundle.getString(nameKey)); } for (NewParam param : rule.params()) { String paramDescriptionKey = baseKey + ".param." + param.key(); if (bundle.containsKey(paramDescriptionKey)) { param.setDescription(bundle.getString(paramDescriptionKey)); } } } }
/** * Loads descriptions of rules and related rule parameters. Existing descriptions * are overridden if English labels exist in bundles. */ public void load(RulesDefinition.NewRepository repo) { for (RulesDefinition.NewRule rule : repo.rules()) { String name = i18n.getName(repo.key(), rule.key()); if (StringUtils.isNotBlank(name)) { rule.setName(name); } String desc = i18n.getDescription(repo.key(), rule.key()); if (StringUtils.isNotBlank(desc)) { rule.setHtmlDescription(desc); } for (RulesDefinition.NewParam param : rule.params()) { String paramDesc = i18n.getParamDescription(repo.key(), rule.key(), param.key()); if (StringUtils.isNotBlank(paramDesc)) { param.setDescription(paramDesc); } } } } }
private void loadParameters(RulesDefinition.NewRule rule, Field field) { RuleProperty propertyAnnotation = field.getAnnotation(RuleProperty.class); if (propertyAnnotation != null) { String fieldKey = StringUtils.defaultIfEmpty(propertyAnnotation.key(), field.getName()); RulesDefinition.NewParam param = rule.createParam(fieldKey) .setDescription(propertyAnnotation.description()) .setDefaultValue(propertyAnnotation.defaultValue()); if (!StringUtils.isBlank(propertyAnnotation.type())) { try { param.setType(RuleParamType.parse(propertyAnnotation.type().trim())); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Invalid property type [" + propertyAnnotation.type() + "]", e); } } else { param.setType(guessType(field.getType())); } } }
private static void loadParameters(RulesDefinition.NewRule rule, Field field) { org.sonar.check.RuleProperty propertyAnnotation = field.getAnnotation(org.sonar.check.RuleProperty.class); if (propertyAnnotation != null) { String fieldKey = StringUtils.defaultIfEmpty(propertyAnnotation.key(), field.getName()); RulesDefinition.NewParam param = rule.createParam(fieldKey) .setDescription(propertyAnnotation.description()) .setDefaultValue(propertyAnnotation.defaultValue()); if (!StringUtils.isBlank(propertyAnnotation.type())) { try { param.setType(RuleParamType.parse(propertyAnnotation.type().trim())); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Invalid property type [" + propertyAnnotation.type() + "]", e); } } else { param.setType(guessType(field.getType())); } } }
private void loadParameters(RulesDefinition.NewRule rule, Field field) { org.sonar.check.RuleProperty propertyAnnotation = field.getAnnotation(org.sonar.check.RuleProperty.class); if (propertyAnnotation != null) { String fieldKey = StringUtils.defaultIfEmpty(propertyAnnotation.key(), field.getName()); RulesDefinition.NewParam param = rule.createParam(fieldKey) .setDescription(propertyAnnotation.description()) .setDefaultValue(propertyAnnotation.defaultValue()); if (!StringUtils.isBlank(propertyAnnotation.type())) { try { param.setType(RuleParamType.parse(propertyAnnotation.type().trim())); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Invalid property type [" + propertyAnnotation.type() + "]", e); } } else { param.setType(guessType(field.getType())); } } }