@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; }
@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\"\",\""); }
return multipleListOfValues(StringUtils.split(values, ',')); return new RuleParamType(format); return new RuleParamType(format, multiple, values.split(CSV_SPLIT_REGEX));
@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"); }
@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\"\",\""); }
@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"); } }
private static boolean mergeParam(RuleParamDto paramDto, RulesDefinition.Param paramDef) { boolean changed = false; if (!StringUtils.equals(paramDto.getType(), paramDef.type().toString())) { paramDto.setType(paramDef.type().toString()); changed = true; } if (!StringUtils.equals(paramDto.getDefaultValue(), paramDef.defaultValue())) { paramDto.setDefaultValue(paramDef.defaultValue()); changed = true; } if (!StringUtils.equals(paramDto.getDescription(), paramDef.description())) { paramDto.setDescription(paramDef.description()); changed = true; } return changed; }
public static RuleParamDto newRuleParam(RuleDefinitionDto rule) { return new RuleParamDto() .setRuleId(rule.getId()) .setName("name_" + randomAlphabetic(5)) .setDefaultValue("default_" + randomAlphabetic(5)) .setDescription("description_" + randomAlphabetic(5)) .setType(RuleParamType.STRING.type()); }
public static RuleParamType multipleListOfValues(String... acceptedValues) { // reuse the same type as plugin properties in order to // benefit from shared helpers (validation, HTML component) String type = PropertyType.SINGLE_SELECT_LIST.name(); return new RuleParamType(type, true, acceptedValues); }
private RuleParamType(String type, boolean multiple, String... values) { this.type = type; this.values = asList(values); StringBuilder sb = new StringBuilder(); sb.append(type); if (multiple) { sb.append(OPTION_SEPARATOR); sb.append(MULTIPLE_PARAM + PARAMETER_SEPARATOR); sb.append(Boolean.toString(multiple)); } if (values.length > 0) { sb.append(OPTION_SEPARATOR); sb.append(VALUES_PARAM + PARAMETER_SEPARATOR); sb.append(StringEscapeUtils.escapeCsv(valuesToCsv(values))); } this.key = sb.toString(); this.multiple = multiple; }
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 RuleDefinitionDto createRuleWithParam(String lang, String id) { RuleDefinitionDto rule = createRule(lang, id); RuleParamDto param = RuleParamDto.createFor(rule) .setName("param_" + id) .setType(RuleParamType.STRING.toString()); dbClient.ruleDao().insertRuleParam(session, rule, param); return rule; }
public RuleParamDto insertRuleParam(RuleDto rule) { RuleParamDto param = new RuleParamDto(); param.setRuleId(rule.getId()); param.setName(randomAlphabetic(10)); param.setType(RuleParamType.STRING.type()); db.getDbClient().ruleDao().insertRuleParam(db.getSession(), rule.getDefinition(), param); db.commit(); return param; }
public static RuleParamType singleListOfValues(String... acceptedValues) { // reuse the same type as plugin properties in order to // benefit from shared helpers (validation, HTML component) String type = PropertyType.SINGLE_SELECT_LIST.name(); return new RuleParamType(type, acceptedValues); }
private RuleParamType(String type, boolean multiple, String... values) { this.type = type; this.values = newArrayList(values); StringBuilder sb = new StringBuilder(); sb.append(type); if (multiple) { sb.append(OPTION_SEPARATOR); sb.append(MULTIPLE_PARAM + PARAMETER_SEPARATOR); sb.append(Boolean.toString(multiple)); } if (values.length > 0) { sb.append(OPTION_SEPARATOR); sb.append(VALUES_PARAM + PARAMETER_SEPARATOR); sb.append(StringEscapeUtils.escapeCsv(valuesToCsv(values))); } this.key = sb.toString(); this.multiple = multiple; }
@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()); } } }
newParam.setDefaultValue(param.getDefaultValue()); newParam.setDescription(paramDescription(repository.getKey(), rule.getKey(), param)); newParam.setType(RuleParamType.parse(param.getType()));
.setDescription(param.description()) .setDefaultValue(param.defaultValue()) .setType(param.type().toString()); dbClient.ruleDao().insertRuleParam(session, rule, paramDto); if (StringUtils.isEmpty(param.defaultValue())) {
return multipleListOfValues(StringUtils.split(values, ',')); return new RuleParamType(format); return new RuleParamType(format, multiple, values.split(CSV_SPLIT_REGEX));