Cognifide / AEM-Rules-for-SonarQube / 819

pending completion

Build # 819

Build Type

push

travis-ci

Committed by

toniedzwiedz

Commit Message

<a href="https://github.com/Cognifide/AEM-Rules-for-SonarQube/commit/<a class=hub.com/Cognifide/AEM-Rules-for-SonarQube/commit/08034e474ca6d8b20f708008983d2b4cc45d066f">08034e474<a href="https://github.com/Cognifide/AEM-Rules-for-SonarQube/commit/08034e474ca6d8b20f708008983d2b4cc45d066f">&quot;&gt;Revert &amp;quot;issue-194 | Remove openjdk8 build from travis.yml&quot;

This reverts commit </a><a class="double-link" href="https://github.com/Cognifide/AEM-Rules-for-SonarQube/commit/<a class="double-link" href="https://github.com/Cognifide/AEM-Rules-for-SonarQube/commit/efc963d431ef1c870bdb9fc1c4600b236e085644">efc963d43</a>">efc963d43</a><a href="https://github.com/Cognifide/AEM-Rules-for-SonarQube/commit/08034e474ca6d8b20f708008983d2b4cc45d066f">.

Run Details

1668 of 1762 relevant lines covered (94.67%)

1.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.86

/src/main/java/com/cognifide/aemrules/extensions/RulesLoader.java

/*-
 * #%L
 * AEM Rules for SonarQube
 * %%
 * Copyright (C) 2015-2019 Cognifide Limited
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */
package com.cognifide.aemrules.extensions;

import com.cognifide.aemrules.metadata.Metadata;
import java.io.IOException;
import java.lang.reflect.Field;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.AbstractMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.annotation.CheckForNull;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.server.rule.RuleParamType;
import org.sonar.api.server.rule.RulesDefinition;
import org.sonar.api.server.rule.RulesDefinition.DebtRemediationFunctions;
import org.sonar.api.utils.AnnotationUtils;
import org.sonar.api.utils.FieldUtils2;
import org.sonar.check.Rule;
import org.sonar.check.RuleProperty;


public class RulesLoader {

    private static final Logger LOG = LoggerFactory.getLogger(RulesLoader.class);

    private static final String RULE_DESCRIPTION_FOLDER = "rules";

    private static final String RULE_DESCRIPTION_EXTENSION = "md";

    private static final Map<Class<?>, RuleParamType> TYPE_FOR_CLASS = Stream.of(
            new AbstractMap.SimpleImmutableEntry<>(Integer.class, RuleParamType.INTEGER),
            new AbstractMap.SimpleImmutableEntry<>(int.class, RuleParamType.INTEGER),
            new AbstractMap.SimpleImmutableEntry<>(Float.class, RuleParamType.FLOAT),
            new AbstractMap.SimpleImmutableEntry<>(float.class, RuleParamType.FLOAT),
            new AbstractMap.SimpleImmutableEntry<>(Boolean.class, RuleParamType.BOOLEAN),
            new AbstractMap.SimpleImmutableEntry<>(boolean.class, RuleParamType.BOOLEAN)
    ).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

    private static RuleParamType guessType(Class<?> type) {
        return TYPE_FOR_CLASS.getOrDefault(type, RuleParamType.STRING);
    }

    public <T> void load(RulesDefinition.NewExtendedRepository repo, List<Class<? extends T>> annotatedClasses) {
        for (Class annotatedClass : annotatedClasses) {
            loadRule(repo, annotatedClass);
        }
    }

    @CheckForNull
    private RulesDefinition.NewRule loadRule(RulesDefinition.NewExtendedRepository repo, Class clazz) {
        return Optional.ofNullable(AnnotationUtils.getAnnotation(clazz, Rule.class))
            .map(annotationRule -> createRule(repo, clazz, annotationRule))
            .orElse(null);
    }

    private RulesDefinition.NewRule createRule(RulesDefinition.NewExtendedRepository repo, Class clazz, Rule ruleAnnotation) {
        String ruleKey = StringUtils.defaultIfEmpty(ruleAnnotation.key(), clazz.getCanonicalName());
        String ruleName = StringUtils.defaultIfEmpty(ruleAnnotation.name(), null);
        String description = StringUtils.defaultIfEmpty(loadDescription(ruleKey), "No description yet.");

        RulesDefinition.NewRule rule = repo.createRule(ruleKey);
        rule.setName(ruleName).setMarkdownDescription(description);
        rule.setSeverity(ruleAnnotation.priority().name());
        rule.setStatus(RuleStatus.valueOf(ruleAnnotation.status()));
        rule.setTags(ruleAnnotation.tags());

        setMetadata(rule, clazz);

        List<Field> fields = FieldUtils2.getFields(clazz, true);
        for (Field field : fields) {
            loadParameters(rule, field);
        }

        return rule;
    }

    private void setMetadata(RulesDefinition.NewRule rule, Class clazz) {
        Optional.ofNullable(AnnotationUtils.getAnnotation(clazz, Metadata.class))
            .ifPresent(metadataAnnotation -> setTechnicalDebt(rule, metadataAnnotation));
    }

    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 String loadDescription(String ruleKey) {
        return loadResource(RULE_DESCRIPTION_FOLDER, ruleKey, RULE_DESCRIPTION_EXTENSION);
    }

    private String loadResource(String resourceFolder, String ruleKey, String fileExtension) {
        String result = null;
        try {
            String path = String.format("/%s/%s.%s", resourceFolder, ruleKey, fileExtension);
            URL url = getClass().getResource(path);
            result = IOUtils.toString(url, StandardCharsets.UTF_8);
        } catch (IOException | IllegalArgumentException e) {
            LOG.error("Cannot read resource file.", e);
        }
        return result;
    }

    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()));
            }
        }
    }

}

1	/*-
2	* #%L
3	* AEM Rules for SonarQube
4	* %%
5	* Copyright (C) 2015-2019 Cognifide Limited
6	* %%
7	* Licensed under the Apache License, Version 2.0 (the "License");
8	* you may not use this file except in compliance with the License.
9	* You may obtain a copy of the License at
10	*
11	* http://www.apache.org/licenses/LICENSE-2.0
12	*
13	* Unless required by applicable law or agreed to in writing, software
14	* distributed under the License is distributed on an "AS IS" BASIS,
15	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	* See the License for the specific language governing permissions and
17	* limitations under the License.
18	* #L%
19	*/
20	package com.cognifide.aemrules.extensions;
21
22	import com.cognifide.aemrules.metadata.Metadata;
23	import java.io.IOException;
24	import java.lang.reflect.Field;
25	import java.net.URL;
26	import java.nio.charset.StandardCharsets;
27	import java.util.AbstractMap;
28	import java.util.List;
29	import java.util.Map;
30	import java.util.Optional;
31	import java.util.stream.Collectors;
32	import java.util.stream.Stream;
33
34	import javax.annotation.CheckForNull;
35
36	import org.apache.commons.io.IOUtils;
37	import org.apache.commons.lang3.StringUtils;
38	import org.slf4j.Logger;
39	import org.slf4j.LoggerFactory;
40	import org.sonar.api.rule.RuleStatus;
41	import org.sonar.api.server.rule.RuleParamType;
42	import org.sonar.api.server.rule.RulesDefinition;
43	import org.sonar.api.server.rule.RulesDefinition.DebtRemediationFunctions;
44	import org.sonar.api.utils.AnnotationUtils;
45	import org.sonar.api.utils.FieldUtils2;
46	import org.sonar.check.Rule;
47	import org.sonar.check.RuleProperty;
48
49
50	public class RulesLoader {	2✔
51
52	private static final Logger LOG = LoggerFactory.getLogger(RulesLoader.class);	2✔
53
54	private static final String RULE_DESCRIPTION_FOLDER = "rules";
55
56	private static final String RULE_DESCRIPTION_EXTENSION = "md";
57
58	private static final Map<Class<?>, RuleParamType> TYPE_FOR_CLASS = Stream.of(	2✔
59	new AbstractMap.SimpleImmutableEntry<>(Integer.class, RuleParamType.INTEGER),
60	new AbstractMap.SimpleImmutableEntry<>(int.class, RuleParamType.INTEGER),
61	new AbstractMap.SimpleImmutableEntry<>(Float.class, RuleParamType.FLOAT),
62	new AbstractMap.SimpleImmutableEntry<>(float.class, RuleParamType.FLOAT),
63	new AbstractMap.SimpleImmutableEntry<>(Boolean.class, RuleParamType.BOOLEAN),
64	new AbstractMap.SimpleImmutableEntry<>(boolean.class, RuleParamType.BOOLEAN)
65	).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));	2✔
66
67	private static RuleParamType guessType(Class<?> type) {
68	return TYPE_FOR_CLASS.getOrDefault(type, RuleParamType.STRING);	2✔
69	}
70
71	public <T> void load(RulesDefinition.NewExtendedRepository repo, List<Class<? extends T>> annotatedClasses) {
72	for (Class annotatedClass : annotatedClasses) {	2✔
73	loadRule(repo, annotatedClass);	2✔
74	}	2✔
75	}	2✔
76
77	@CheckForNull
78	private RulesDefinition.NewRule loadRule(RulesDefinition.NewExtendedRepository repo, Class clazz) {
79	return Optional.ofNullable(AnnotationUtils.getAnnotation(clazz, Rule.class))	2✔
80	.map(annotationRule -> createRule(repo, clazz, annotationRule))	2✔
81	.orElse(null);	2✔
82	}
83
84	private RulesDefinition.NewRule createRule(RulesDefinition.NewExtendedRepository repo, Class clazz, Rule ruleAnnotation) {
85	String ruleKey = StringUtils.defaultIfEmpty(ruleAnnotation.key(), clazz.getCanonicalName());	2✔
86	String ruleName = StringUtils.defaultIfEmpty(ruleAnnotation.name(), null);	2✔
87	String description = StringUtils.defaultIfEmpty(loadDescription(ruleKey), "No description yet.");	2✔
88
89	RulesDefinition.NewRule rule = repo.createRule(ruleKey);	2✔
90	rule.setName(ruleName).setMarkdownDescription(description);	2✔
91	rule.setSeverity(ruleAnnotation.priority().name());	2✔
92	rule.setStatus(RuleStatus.valueOf(ruleAnnotation.status()));	2✔
93	rule.setTags(ruleAnnotation.tags());	2✔
94
95	setMetadata(rule, clazz);	2✔
96
97	List<Field> fields = FieldUtils2.getFields(clazz, true);	2✔
98	for (Field field : fields) {	2✔
99	loadParameters(rule, field);	2✔
100	}	2✔
101
102	return rule;	2✔
103	}
104
105	private void setMetadata(RulesDefinition.NewRule rule, Class clazz) {
106	Optional.ofNullable(AnnotationUtils.getAnnotation(clazz, Metadata.class))	2✔
107	.ifPresent(metadataAnnotation -> setTechnicalDebt(rule, metadataAnnotation));	2✔
108	}	2✔
109
110	private void setTechnicalDebt(RulesDefinition.NewRule rule, Metadata metadataAnnotation) {
111	String technicalDebt = metadataAnnotation.technicalDebt();	2✔
112	if (StringUtils.isNotEmpty(technicalDebt)) {	2✔
113	DebtRemediationFunctions remediationFunction = rule.debtRemediationFunctions();	2✔
114	rule.setDebtRemediationFunction(remediationFunction.constantPerIssue(technicalDebt));	2✔
115	}
116	}	2✔
117
118	private String loadDescription(String ruleKey) {
119	return loadResource(RULE_DESCRIPTION_FOLDER, ruleKey, RULE_DESCRIPTION_EXTENSION);	2✔
120	}
121
122	private String loadResource(String resourceFolder, String ruleKey, String fileExtension) {
123	String result = null;	2✔
124	try {
125	String path = String.format("/%s/%s.%s", resourceFolder, ruleKey, fileExtension);	2✔
126	URL url = getClass().getResource(path);	2✔
127	result = IOUtils.toString(url, StandardCharsets.UTF_8);	2✔
128	} catch (IOException \| IllegalArgumentException e) {	×
129	LOG.error("Cannot read resource file.", e);	×
130	}	2✔
131	return result;	2✔
132	}
133
134	private void loadParameters(RulesDefinition.NewRule rule, Field field) {
135	RuleProperty propertyAnnotation = field.getAnnotation(RuleProperty.class);	2✔
136	if (propertyAnnotation != null) {	2✔
137	String fieldKey = StringUtils.defaultIfEmpty(propertyAnnotation.key(), field.getName());	2✔
138	RulesDefinition.NewParam param = rule.createParam(fieldKey)	2✔
139	.setDescription(propertyAnnotation.description())	2✔
140	.setDefaultValue(propertyAnnotation.defaultValue());	2✔
141
142	if (!StringUtils.isBlank(propertyAnnotation.type())) {	2✔
143	try {
144	param.setType(RuleParamType.parse(propertyAnnotation.type().trim()));	2✔
145	} catch (IllegalArgumentException e) {	×
146	throw new IllegalArgumentException("Invalid property type [" + propertyAnnotation.type() + "]", e);	×
147	}	2✔
148	} else {
149	param.setType(guessType(field.getType()));	2✔
150	}
151	}
152	}	2✔
153
154	}

Cognifide / AEM-Rules-for-SonarQube / 819

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous