@Test public void support_deprecated_formats() { assertThat(RuleParamType.parse("b")).isEqualTo(RuleParamType.BOOLEAN); assertThat(RuleParamType.parse("i")).isEqualTo(RuleParamType.INTEGER); assertThat(RuleParamType.parse("i{}")).isEqualTo(RuleParamType.INTEGER); assertThat(RuleParamType.parse("s")).isEqualTo(RuleParamType.STRING); assertThat(RuleParamType.parse("s{}")).isEqualTo(RuleParamType.STRING); assertThat(RuleParamType.parse("r")).isEqualTo(RuleParamType.STRING); assertThat(RuleParamType.parse("TEXT")).isEqualTo(RuleParamType.TEXT); assertThat(RuleParamType.parse("STRING")).isEqualTo(RuleParamType.STRING); assertThat(RuleParamType.parse("REGULAR_EXPRESSION")).isEqualTo(RuleParamType.STRING); RuleParamType list = RuleParamType.parse("s[FOO,BAR]"); assertThat(list.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(list.values()).containsOnly("FOO", "BAR"); } }
@CheckForNull private void validateParam(RuleParamDto ruleParam, @Nullable String value) { if (value != null) { RuleParamType ruleParamType = RuleParamType.parse(ruleParam.getType()); if (ruleParamType.multiple()) { List<String> values = newArrayList(Splitter.on(",").split(value)); typeValidations.validate(values, ruleParamType.type(), ruleParamType.values()); } else { typeValidations.validate(value, ruleParamType.type(), ruleParamType.values()); } } }
@CheckForNull private String validateParam(RuleParamDto ruleParam, String value) { RuleParamType ruleParamType = RuleParamType.parse(ruleParam.getType()); if (ruleParamType.multiple()) { List<String> values = newArrayList(Splitter.on(",").split(value)); typeValidations.validate(values, ruleParamType.type(), ruleParamType.values()); } else { typeValidations.validate(value, ruleParamType.type(), ruleParamType.values()); } return value; }
@CheckForNull private String validateParam(RuleParamDto ruleParam, @Nullable String value) { if (value != null) { RuleParamType ruleParamType = RuleParamType.parse(ruleParam.getType()); if (ruleParamType.multiple()) { List<String> values = Splitter.on(",").splitToList(value); typeValidations.validate(values, ruleParamType.type(), ruleParamType.values()); } else { typeValidations.validate(value, ruleParamType.type(), ruleParamType.values()); } } return value; }
@Test public void testInteger() throws Exception { RuleParamType type = RuleParamType.INTEGER; assertThat(type.toString()).isEqualTo("INTEGER"); assertThat(RuleParamType.parse(type.toString()).type()).isEqualTo("INTEGER"); assertThat(RuleParamType.parse(type.toString()).values()).isEmpty(); assertThat(RuleParamType.parse(type.toString()).toString()).isEqualTo("INTEGER"); }
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())); } } }
@Test public void testMultipleListOfValues() throws Exception { RuleParamType selectList = RuleParamType.parse("SINGLE_SELECT_LIST,values=\"foo,bar\",multiple=true"); assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(selectList.values()).containsOnly("foo", "bar"); assertThat(selectList.multiple()).isTrue(); assertThat(selectList.toString()).isEqualTo("SINGLE_SELECT_LIST,multiple=true,values=\"foo,bar,\""); RuleParamType.parse("SINGLE_SELECT_LIST,\"values=foo,bar\",\"multiple=true\""); assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(selectList.values()).containsOnly("foo", "bar"); assertThat(selectList.multiple()).isTrue(); assertThat(selectList.toString()).isEqualTo("SINGLE_SELECT_LIST,multiple=true,values=\"foo,bar,\""); // escape values selectList = RuleParamType.multipleListOfValues("foo", "one,two|three,four"); assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(selectList.values()).containsOnly("foo", "one,two|three,four"); assertThat(selectList.multiple()).isTrue(); assertThat(selectList.toString()).isEqualTo("SINGLE_SELECT_LIST,multiple=true,values=\"foo,\"\"one,two|three,four\"\",\""); }
@Test public void testListOfValues() throws Exception { RuleParamType selectList = RuleParamType.parse("SINGLE_SELECT_LIST,values=\"foo,bar\","); assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(selectList.values()).containsOnly("foo", "bar"); assertThat(selectList.multiple()).isFalse(); assertThat(selectList.toString()).isEqualTo("SINGLE_SELECT_LIST,values=\"foo,bar,\""); RuleParamType.parse("SINGLE_SELECT_LIST,values=\"foo,bar\",multiple=false"); assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(selectList.values()).containsOnly("foo", "bar"); assertThat(selectList.multiple()).isFalse(); assertThat(selectList.toString()).isEqualTo("SINGLE_SELECT_LIST,values=\"foo,bar,\""); RuleParamType.parse("SINGLE_SELECT_LIST,\"values=foo,bar\",\"multiple=false\""); assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(selectList.values()).containsOnly("foo", "bar"); assertThat(selectList.multiple()).isFalse(); assertThat(selectList.toString()).isEqualTo("SINGLE_SELECT_LIST,values=\"foo,bar,\""); // escape values selectList = RuleParamType.singleListOfValues("foo", "one,two|three,four"); assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST"); assertThat(selectList.values()).containsOnly("foo", "one,two|three,four"); assertThat(selectList.multiple()).isFalse(); assertThat(selectList.toString()).isEqualTo("SINGLE_SELECT_LIST,values=\"foo,\"\"one,two|three,four\"\",\""); }
newParam.setDefaultValue(param.getDefaultValue()); newParam.setDescription(paramDescription(repository.getKey(), rule.getKey(), param)); newParam.setType(RuleParamType.parse(param.getType()));
@CheckForNull private void validateParam(RuleParamDto ruleParam, @Nullable String value) { if (value != null) { RuleParamType ruleParamType = RuleParamType.parse(ruleParam.getType()); if (ruleParamType.multiple()) { List<String> values = newArrayList(Splitter.on(",").split(value)); typeValidations.validate(values, ruleParamType.type(), ruleParamType.values()); } else { typeValidations.validate(value, ruleParamType.type(), ruleParamType.values()); } } }
@CheckForNull private String validateParam(RuleParamDto ruleParam, String value) { RuleParamType ruleParamType = RuleParamType.parse(ruleParam.getType()); if (ruleParamType.multiple()) { List<String> values = newArrayList(Splitter.on(",").split(value)); typeValidations.validate(values, ruleParamType.type(), ruleParamType.values()); } else { typeValidations.validate(value, ruleParamType.type(), ruleParamType.values()); } return value; }
@CheckForNull private String validateParam(RuleParamDto ruleParam, @Nullable String value) { if (value != null) { RuleParamType ruleParamType = RuleParamType.parse(ruleParam.getType()); if (ruleParamType.multiple()) { List<String> values = Splitter.on(",").splitToList(value); typeValidations.validate(values, ruleParamType.type(), ruleParamType.values()); } else { typeValidations.validate(value, ruleParamType.type(), ruleParamType.values()); } } return value; }
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 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 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())); } } }
@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(); }
newParam.setDefaultValue(param.getDefaultValue()); newParam.setDescription(paramDescription(repository.getKey(), rule.getKey(), param)); newParam.setType(RuleParamType.parse(param.getType()));