diff options
author | simonbrandhof <simon.brandhof@gmail.com> | 2010-09-14 09:59:18 +0000 |
---|---|---|
committer | simonbrandhof <simon.brandhof@gmail.com> | 2010-09-14 09:59:18 +0000 |
commit | 91b4e663c59c2fd03b64ce3746617e44aeab2bdd (patch) | |
tree | e6f5ca160de886d4ade86642d2f572d18de024ff /sonar-deprecated/src/main/java | |
parent | 3a268c327d4cd7dc1e1e2530d2733d42a62e0d09 (diff) | |
download | sonarqube-91b4e663c59c2fd03b64ce3746617e44aeab2bdd.tar.gz sonarqube-91b4e663c59c2fd03b64ce3746617e44aeab2bdd.zip |
move deprecated check api to sonar-deprecated
Diffstat (limited to 'sonar-deprecated/src/main/java')
20 files changed, 1897 insertions, 0 deletions
diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/AnnotationCheckerFactory.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/AnnotationCheckerFactory.java new file mode 100644 index 00000000000..9f8574d9e83 --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/AnnotationCheckerFactory.java @@ -0,0 +1,160 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.checkers; + +import org.apache.commons.lang.StringUtils; +import org.sonar.api.checks.profiles.Check; +import org.sonar.api.checks.profiles.CheckProfile; +import org.sonar.check.AnnotationIntrospector; +import org.sonar.check.CheckProperty; + +import java.lang.reflect.Field; +import java.util.Collection; +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.Map; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated + +public class AnnotationCheckerFactory<CHECKER> extends CheckerFactory<CHECKER> { + + private CheckProfile profile; + private String repositoryKey; + private Collection<Class<CHECKER>> checkerClasses; + + public AnnotationCheckerFactory(CheckProfile profile, String repositoryKey, Collection<Class<CHECKER>> checkerClasses) { + this.profile = profile; + this.repositoryKey = repositoryKey; + this.checkerClasses = checkerClasses; + } + + public Map<Check, CHECKER> create() { + Map<String, Class<CHECKER>> classesByKey = getClassesByKey(checkerClasses); + + Map<Check, CHECKER> map = new IdentityHashMap<Check, CHECKER>(); + for (Check check : profile.getChecks(repositoryKey)) { + Class<CHECKER> clazz = classesByKey.get(check.getTemplateKey()); + if (clazz != null) { + CHECKER checker = instantiate(check, clazz); + if (checker != null) { + map.put(check, checker); + } + } + } + return map; + } + + CHECKER instantiate(Check check, Class<CHECKER> clazz) { + try { + CHECKER checker = clazz.newInstance(); + configureFields(check, checker); + return checker; + + } catch (UnvalidCheckerException e) { + throw e; + + } catch (Exception e) { + throw new UnvalidCheckerException("The checker " + clazz.getCanonicalName() + " can not be created", e); + } + } + + private void configureFields(Check check, CHECKER checker) throws IllegalAccessException { + for (Map.Entry<String, String> entry : check.getProperties().entrySet()) { + Field field = getField(checker, entry.getKey()); + if (field == null) { + throw new UnvalidCheckerException("The field " + entry.getKey() + " does not exist or is not annotated with @CheckProperty"); + } + if (StringUtils.isNotBlank(entry.getValue())) { + configureField(checker, field, entry); + } + } + + } + + private void configureField(Object checker, Field field, Map.Entry<String, String> parameter) throws IllegalAccessException { + field.setAccessible(true); + + if (field.getType().equals(String.class)) { + field.set(checker, parameter.getValue()); + + } else if (field.getType().getSimpleName().equals("int")) { + field.setInt(checker, Integer.parseInt(parameter.getValue())); + + } else if (field.getType().getSimpleName().equals("short")) { + field.setShort(checker, Short.parseShort(parameter.getValue())); + + } else if (field.getType().getSimpleName().equals("long")) { + field.setLong(checker, Long.parseLong(parameter.getValue())); + + } else if (field.getType().getSimpleName().equals("double")) { + field.setDouble(checker, Double.parseDouble(parameter.getValue())); + + } else if (field.getType().getSimpleName().equals("boolean")) { + field.setBoolean(checker, Boolean.parseBoolean(parameter.getValue())); + + } else if (field.getType().getSimpleName().equals("byte")) { + field.setByte(checker, Byte.parseByte(parameter.getValue())); + + } else if (field.getType().equals(Integer.class)) { + field.set(checker, new Integer(Integer.parseInt(parameter.getValue()))); + + } else if (field.getType().equals(Long.class)) { + field.set(checker, new Long(Long.parseLong(parameter.getValue()))); + + } else if (field.getType().equals(Double.class)) { + field.set(checker, new Double(Double.parseDouble(parameter.getValue()))); + + } else if (field.getType().equals(Boolean.class)) { + field.set(checker, Boolean.valueOf(Boolean.parseBoolean(parameter.getValue()))); + + } else { + throw new UnvalidCheckerException("The type of the field " + field + " is not supported: " + field.getType()); + } + } + + private Field getField(Object checker, String key) { + Field[] fields = checker.getClass().getDeclaredFields(); + for (Field field : fields) { + CheckProperty annotation = field.getAnnotation(CheckProperty.class); + if (annotation != null) { + if (key.equals(field.getName()) || key.equals(annotation.key())) { + return field; + } + } + } + return null; + } + + private Map<String, Class<CHECKER>> getClassesByKey(Collection<Class<CHECKER>> checkerClasses) { + Map<String, Class<CHECKER>> result = new HashMap<String, Class<CHECKER>>(); + for (Class<CHECKER> checkerClass : checkerClasses) { + String key = AnnotationIntrospector.getCheckKey(checkerClass); + if (key != null) { + result.put(key, checkerClass); + } + } + return result; + } + +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/CheckerFactory.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/CheckerFactory.java new file mode 100644 index 00000000000..de0a12a738c --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/CheckerFactory.java @@ -0,0 +1,33 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.checkers; + +import org.sonar.api.checks.profiles.Check; + +import java.util.Map; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public abstract class CheckerFactory<CHECKER> { + public abstract Map<Check, CHECKER> create(); +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/MessageDispatcher.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/MessageDispatcher.java new file mode 100644 index 00000000000..7f563920825 --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/MessageDispatcher.java @@ -0,0 +1,111 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.checkers; + +import com.google.common.collect.Maps; +import org.sonar.api.batch.SensorContext; +import org.sonar.api.checks.profiles.Check; +import org.sonar.api.checks.profiles.CheckProfile; +import org.sonar.api.resources.Resource; +import org.sonar.api.rules.Rule; +import org.sonar.api.rules.RulePriority; +import org.sonar.api.rules.Violation; +import org.sonar.check.Message; + +import java.util.Collection; +import java.util.Locale; +import java.util.Map; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class MessageDispatcher { + + private Map<Check, Object> checkersByCheck; + private Map<Object, Check> checksByChecker; + private SensorContext context; + + public MessageDispatcher(SensorContext context) { + this.context = context; + checkersByCheck = Maps.newIdentityHashMap(); + checksByChecker = Maps.newIdentityHashMap(); + } + + public void registerChecker(Check check, Object checker) { + checkersByCheck.put(check, checker); + checksByChecker.put(checker, check); + } + + public void registerCheckers(CheckerFactory factory) { + Map<Check, Object> map = factory.create(); + for (Map.Entry<Check, Object> entry : map.entrySet()) { + registerChecker(entry.getKey(), entry.getValue()); + } + } + + public void registerCheckers(CheckProfile profile) { + for (Check check : profile.getChecks()) { + registerChecker(check, check); + } + } + + public Object getChecker(Check check) { + return checkersByCheck.get(check); + } + + public Check getCheck(Object checker) { + return checksByChecker.get(checker); + } + + public Collection getCheckers() { + return checkersByCheck.values(); + } + + public void unregisterCheck(Check check) { + Object checker = checkersByCheck.remove(check); + if (checker != null) { + checksByChecker.remove(checker); + } + } + + public void unregisterChecks(CheckProfile profile) { + for (Check check : profile.getChecks()) { + unregisterCheck(check); + } + } + + public void log(Resource resource, Message message) { + Object checker = message.getChecker(); + Check check = getCheck(checker); + Violation violation = new Violation(new Rule(check.getRepositoryKey(), check.getTemplateKey()), resource); + violation.setLineId(message.getLine()); + violation.setMessage(message.getText(Locale.ENGLISH)); + violation.setPriority(RulePriority.fromCheckPriority(check.getPriority())); + context.saveViolation(violation); + } + + public void clear() { + checkersByCheck.clear(); + checksByChecker.clear(); + } + +}
\ No newline at end of file diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/UnvalidCheckerException.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/UnvalidCheckerException.java new file mode 100644 index 00000000000..0c98a1fece3 --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/checkers/UnvalidCheckerException.java @@ -0,0 +1,42 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.checkers; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class UnvalidCheckerException extends RuntimeException { + public UnvalidCheckerException() { + } + + public UnvalidCheckerException(String message) { + super(message); + } + + public UnvalidCheckerException(String message, Throwable cause) { + super(message, cause); + } + + public UnvalidCheckerException(Throwable cause) { + super(cause); + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/AnnotationCheckProfileFactory.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/AnnotationCheckProfileFactory.java new file mode 100644 index 00000000000..e5084965d42 --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/AnnotationCheckProfileFactory.java @@ -0,0 +1,72 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.profiles; + +import org.sonar.check.AnnotationIntrospector; +import org.sonar.check.BelongsToProfile; +import org.sonar.check.BelongsToProfiles; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public final class AnnotationCheckProfileFactory { + + private AnnotationCheckProfileFactory() { + } + + public static Collection<CheckProfile> create(String repositoryKey, String language, Collection<Class> checkClasses) { + Map<String, CheckProfile> profilesByTitle = new HashMap<String, CheckProfile>(); + + if (checkClasses != null) { + for (Class aClass : checkClasses) { + BelongsToProfiles belongsToProfiles = (BelongsToProfiles) aClass.getAnnotation(BelongsToProfiles.class); + if (belongsToProfiles != null) { + for (BelongsToProfile belongsToProfile : belongsToProfiles.value()) { + registerProfile(profilesByTitle, aClass, belongsToProfile, repositoryKey, language); + } + } + BelongsToProfile belongsToProfile = (BelongsToProfile) aClass.getAnnotation(BelongsToProfile.class); + registerProfile(profilesByTitle, aClass, belongsToProfile, repositoryKey, language); + } + } + + return profilesByTitle.values(); + } + + private static void registerProfile(Map<String, CheckProfile> profilesByTitle, Class aClass, BelongsToProfile belongsToProfile, String repositoryKey, String language) { + if (belongsToProfile != null) { + String title = belongsToProfile.title(); + CheckProfile profile = profilesByTitle.get(title); + if (profile == null) { + profile = new CheckProfile(title, language); + profilesByTitle.put(title, profile); + } + Check check = new Check(repositoryKey, AnnotationIntrospector.getCheckKey(aClass)); + check.setPriority(belongsToProfile.priority()); + profile.addCheck(check); + } + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/Check.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/Check.java new file mode 100644 index 00000000000..b33c3a11ddc --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/Check.java @@ -0,0 +1,111 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.profiles; + +import org.apache.commons.lang.builder.ToStringBuilder; +import org.sonar.check.Priority; + +import java.util.HashMap; +import java.util.Map; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class Check { + + private String repositoryKey; + private String templateKey; + private Priority priority = null; + private final Map<String, String> properties = new HashMap<String,String>(); + + public Check() { + } + + public Check(String repositoryKey, String templateKey) { + this.repositoryKey = repositoryKey; + this.templateKey = templateKey; + } + + public String getTemplateKey() { + return templateKey; + } + + public String getRepositoryKey() { + return repositoryKey; + } + + public void setRepositoryKey(String repositoryKey) { + this.repositoryKey = repositoryKey; + } + + public void setTemplateKey(String templateKey) { + this.templateKey = templateKey; + } + + public Priority getPriority() { + return priority; + } + + public void setPriority(Priority priority) { + this.priority = priority; + } + + public Map<String, String> getProperties() { + return properties; + } + + public String getProperty(String key) { + return properties.get(key); + } + + public void addProperty(String key, Object value) { + properties.put(key, value.toString()); + } + + public void addProperties(Map<String, String> properties) { + this.properties.putAll(properties); + } + + public void setProperties(Map<String, String> properties) { + this.properties.clear(); + this.properties.putAll(properties); + } + + @Override + public boolean equals(Object o) { + return o == this; + } + + @Override + public int hashCode() { + return super.hashCode(); + } + + @Override + public String toString() { + return new ToStringBuilder(this) + .append("repository", repositoryKey) + .append("template", templateKey) + .append("priority", priority) + .toString(); + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfile.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfile.java new file mode 100644 index 00000000000..2a47f800bdc --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfile.java @@ -0,0 +1,136 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.profiles; + +import org.sonar.api.BatchExtension; +import org.sonar.api.ServerExtension; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class CheckProfile implements BatchExtension, ServerExtension { + + private String name; + private String language; + private List<Check> checks = new ArrayList<Check>(); + + public CheckProfile(String name, String language) { + if (name == null) { + throw new IllegalArgumentException("Name can not be null"); + } + if (language == null) { + throw new IllegalArgumentException("Language can not be null"); + } + this.name = name; + this.language = language; + } + + public String getName() { + return name; + } + + public String getLanguage() { + return language; + } + + public List<Check> getChecks() { + return checks; + } + + public List<Check> getChecks(String repositoryKey) { + List<Check> result = new ArrayList<Check>(); + for (Check check : getChecks()) { + if (check.getRepositoryKey().equals(repositoryKey)) { + result.add(check); + } + } + return result; + } + + public List<Check> getChecks(String repositoryKey, String templateKey) { + List<Check> result = new ArrayList<Check>(); + List<Check> repoChecks = getChecks(repositoryKey); + for (Check repoCheck : repoChecks) { + if (repoCheck.getTemplateKey().equals(templateKey)) { + result.add(repoCheck); + } + } + return result; + } + + /** + * We assume there is only one check for this template + */ + public Check getCheck(String repositoryKey, String templateKey) { + List<Check> repoChecks = getChecks(repositoryKey); + for (Check repoCheck : repoChecks) { + if (repoCheck.getTemplateKey().equals(templateKey)) { + return repoCheck; + } + } + return null; + } + + public void addCheck(Check check) { + checks.add(check); + } + + public void setChecks(Collection<Check> list) { + checks.clear(); + checks.addAll(list); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + CheckProfile profile = (CheckProfile) o; + if (!language.equals(profile.language)) { + return false; + } + if (!name.equals(profile.name)) { + return false; + } + return true; + } + + @Override + public int hashCode() { + int result = name.hashCode(); + result = 31 * result + language.hashCode(); + return result; + } + + @Override + public String toString() { + return name; + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfileProvider.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfileProvider.java new file mode 100644 index 00000000000..0482cf447fd --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfileProvider.java @@ -0,0 +1,35 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.profiles; + +import org.sonar.api.ServerExtension; + +import java.util.Collection; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public abstract class CheckProfileProvider implements ServerExtension { + + public abstract Collection<CheckProfile> provide(); + +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfileXmlMarshaller.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfileXmlMarshaller.java new file mode 100644 index 00000000000..4e7d359643a --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/profiles/CheckProfileXmlMarshaller.java @@ -0,0 +1,156 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.profiles; + +import com.thoughtworks.xstream.XStream; +import com.thoughtworks.xstream.converters.Converter; +import com.thoughtworks.xstream.converters.MarshallingContext; +import com.thoughtworks.xstream.converters.UnmarshallingContext; +import com.thoughtworks.xstream.io.HierarchicalStreamReader; +import com.thoughtworks.xstream.io.HierarchicalStreamWriter; +import com.thoughtworks.xstream.io.xml.CompactWriter; +import com.thoughtworks.xstream.io.xml.XppDriver; +import org.apache.commons.io.IOUtils; +import org.sonar.check.Priority; + +import java.io.InputStreamReader; +import java.io.Reader; +import java.io.Writer; +import java.util.Map; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public final class CheckProfileXmlMarshaller { + + public static void toXml(CheckProfile profile, Writer writer) { + getXStream().toXML(profile, writer); + } + + public static CheckProfile fromXml(Reader xml) { + return (CheckProfile) getXStream().fromXML(xml); + } + + public static CheckProfile fromXmlInClasspath(String pathToXml) { + return fromXmlInClasspath(pathToXml, CheckProfileXmlMarshaller.class); + } + + public static CheckProfile fromXmlInClasspath(String pathToXml, Class clazz) { + Reader reader = new InputStreamReader(clazz.getResourceAsStream(pathToXml)); + try { + return fromXml(reader); + } finally { + IOUtils.closeQuietly(reader); + } + } + + private static XStream getXStream() { + XStream xstream = new XStream(new CompactDriver()); + xstream.setClassLoader(CheckProfileXmlMarshaller.class.getClassLoader()); + xstream.registerConverter(new CheckConverter()); + xstream.alias("profile", CheckProfile.class); + xstream.alias("check", Check.class); + xstream.addImplicitCollection(CheckProfile.class, "checks"); + return xstream; + } + + private static class CompactDriver extends XppDriver { + @Override + public HierarchicalStreamWriter createWriter(Writer out) { + return new XDataPrintWriter(out); + } + } + + + private static class XDataPrintWriter extends CompactWriter { + public XDataPrintWriter(Writer writer) { + super(writer, XML_1_0); + } + } + + private static class CheckConverter implements Converter { + + public boolean canConvert(Class clazz) { + return clazz.equals(Check.class); + } + + public void marshal(Object value, HierarchicalStreamWriter writer, MarshallingContext context) { + Check check = (Check) value; + writer.startNode("repository"); + writer.setValue(check.getRepositoryKey()); + writer.endNode(); + writer.startNode("template"); + writer.setValue(check.getTemplateKey()); + writer.endNode(); + writer.startNode("priority"); + writer.setValue(check.getPriority().toString()); + writer.endNode(); + for (Map.Entry<String, String> entry : check.getProperties().entrySet()) { + if (entry.getValue() != null) { + writer.startNode("property"); + writer.startNode("key"); + writer.setValue(entry.getKey()); + writer.endNode(); + writer.startNode("value"); + // TODO is escaping automatically supported by xstream ? + writer.setValue(entry.getValue()); + writer.endNode(); + writer.endNode(); + } + } + } + + public Object unmarshal(HierarchicalStreamReader reader, + UnmarshallingContext context) { + Check check = new Check(); + while (reader.hasMoreChildren()) { + reader.moveDown(); + readValue(reader, check); + reader.moveUp(); + } + return check; + } + + private void readValue(HierarchicalStreamReader reader, Check check) { + if (reader.getNodeName().equals("repository")) { + check.setRepositoryKey(reader.getValue()); + + } else if (reader.getNodeName().equals("template")) { + check.setTemplateKey(reader.getValue()); + + } else if (reader.getNodeName().equals("priority")) { + check.setPriority(Priority.valueOf(reader.getValue())); + + } else if (reader.getNodeName().equals("property")) { + reader.moveDown(); + String key = reader.getValue(); + reader.moveUp(); + + reader.moveDown(); + String value = reader.getValue(); + reader.moveUp(); + check.addProperty(key, value); + } + } + + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/AnnotationCheckTemplateFactory.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/AnnotationCheckTemplateFactory.java new file mode 100644 index 00000000000..08d21bb6fe3 --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/AnnotationCheckTemplateFactory.java @@ -0,0 +1,114 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.apache.commons.lang.StringUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.sonar.check.AnnotationIntrospector; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class AnnotationCheckTemplateFactory { + + private static final Logger LOG = LoggerFactory.getLogger(AnnotationCheckTemplateFactory.class); + + private Collection<Class> annotatedClasses; + + public AnnotationCheckTemplateFactory(Collection<Class> annotatedClasses) { + this.annotatedClasses = annotatedClasses; + } + + public List<CheckTemplate> create() { + List<CheckTemplate> templates = new ArrayList<CheckTemplate>(); + for (Class annotatedClass : annotatedClasses) { + BundleCheckTemplate template = create(annotatedClass); + if (template != null) { + templates.add(template); + } + } + return templates; + } + + + protected BundleCheckTemplate create(Class annotatedClass) { + org.sonar.check.Check checkAnnotation = AnnotationIntrospector.getCheckAnnotation(annotatedClass); + if (checkAnnotation == null) { + LOG.warn("The class " + annotatedClass.getCanonicalName() + " is not a check template. It should be annotated with " + CheckTemplate.class); + return null; + } + + BundleCheckTemplate check = toTemplate(annotatedClass, checkAnnotation); + Field[] fields = annotatedClass.getDeclaredFields(); + if (fields != null) { + for (Field field : fields) { + BundleCheckTemplateProperty property = toProperty(check, field); + if (property != null) { + check.addProperty(property); + } + } + } + return check; + } + + private static BundleCheckTemplate toTemplate(Class annotatedClass, org.sonar.check.Check checkAnnotation) { + String key = AnnotationIntrospector.getCheckKey(annotatedClass); + String bundle = getBundleBaseName(checkAnnotation, annotatedClass); + + BundleCheckTemplate check = new BundleCheckTemplate(key, bundle); + check.setDefaultDescription(checkAnnotation.description()); + check.setDefaultTitle(checkAnnotation.title()); + check.setIsoCategory(checkAnnotation.isoCategory()); + check.setPriority(checkAnnotation.priority()); + + return check; + } + + private static String getBundleBaseName(org.sonar.check.Check checkAnnotation, Class annotatedClass) { + String bundle = checkAnnotation.bundle(); + if (StringUtils.isBlank(bundle)) { + bundle = annotatedClass.getCanonicalName(); + } + return bundle; + } + + private static BundleCheckTemplateProperty toProperty(BundleCheckTemplate check, Field field) { + org.sonar.check.CheckProperty propertyAnnotation = field.getAnnotation(org.sonar.check.CheckProperty.class); + if (propertyAnnotation != null) { + String fieldKey = propertyAnnotation.key(); + if (fieldKey==null || "".equals(fieldKey)) { + fieldKey = field.getName(); + } + BundleCheckTemplateProperty property = new BundleCheckTemplateProperty(check, fieldKey); + property.setDefaultTitle(propertyAnnotation.title()); + property.setDefaultDescription(propertyAnnotation.description()); + return property; + } + return null; + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/BundleCheckTemplate.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/BundleCheckTemplate.java new file mode 100644 index 00000000000..e54554b84cc --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/BundleCheckTemplate.java @@ -0,0 +1,110 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Locale; +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class BundleCheckTemplate extends CheckTemplate { + private static final Logger LOG = LoggerFactory.getLogger(BundleCheckTemplate.class); + + private String bundleBaseName; + private String defaultTitle; + private String defaultDescription; + + protected BundleCheckTemplate(String key, String bundleBaseName) { + super(key); + this.bundleBaseName = bundleBaseName; + } + + protected BundleCheckTemplate(String key, Class bundleClass) { + this(key, bundleClass.getCanonicalName()); + } + + protected String getDefaultTitle() { + if (defaultTitle == null || "".equals(defaultTitle)) { + return getKey(); + } + return defaultTitle; + } + + protected void setDefaultTitle(String defaultTitle) { + this.defaultTitle = defaultTitle; + } + + protected String getDefaultDescription() { + return defaultDescription; + } + + protected void setDefaultDescription(String defaultDescription) { + this.defaultDescription = defaultDescription; + } + + @Override + public String getTitle(Locale locale) { + return getText("title", locale, getDefaultTitle()); + } + + @Override + public String getDescription(Locale locale) { + return getText("description", locale, getDefaultDescription()); + } + + @Override + public String getMessage(Locale locale, String key, Object... params) { + return null; + } + + protected String getText(String key, Locale locale, String defaultValue) { + String result = null; + ResourceBundle bundle = getBundle(locale); + if (bundle != null) { + try { + result = bundle.getString(key); + } catch (MissingResourceException e) { + LOG.debug(e.getMessage()); + } + } + if (result == null) { + result = defaultValue; + } + return result; + } + + protected ResourceBundle getBundle(Locale locale) { + try { + if (locale != null) { + return ResourceBundle.getBundle(bundleBaseName, locale); + } + } catch (MissingResourceException e) { + // do nothing : use the default values + } + return null; + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/BundleCheckTemplateProperty.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/BundleCheckTemplateProperty.java new file mode 100644 index 00000000000..ac1ebf6795a --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/BundleCheckTemplateProperty.java @@ -0,0 +1,69 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import java.util.Locale; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class BundleCheckTemplateProperty extends CheckTemplateProperty { + + private BundleCheckTemplate check; + private String defaultTitle; + private String defaultDescription; + + public BundleCheckTemplateProperty(BundleCheckTemplate check, String key) { + setKey(key); + this.check = check; + } + + public String getDefaultTitle() { + if (defaultTitle == null || "".equals(defaultTitle)) { + return getKey(); + } + return defaultTitle; + } + + public void setDefaultTitle(String s) { + this.defaultTitle = s; + } + + + @Override + public String getTitle(Locale locale) { + return check.getText("property." + getKey() + ".title", locale, getDefaultTitle()); + } + + public String getDefaultDescription() { + return defaultDescription; + } + + public void setDefaultDescription(String s) { + this.defaultDescription = s; + } + + @Override + public String getDescription(Locale locale) { + return check.getText("property." + getKey() + ".description", locale, getDefaultDescription()); + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplate.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplate.java new file mode 100644 index 00000000000..a6df4a7e73f --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplate.java @@ -0,0 +1,134 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.sonar.check.IsoCategory; +import org.sonar.check.Priority; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Locale; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public abstract class CheckTemplate { + + protected String key; + protected String configKey; + protected Priority priority; + protected IsoCategory isoCategory; + protected List<CheckTemplateProperty> properties; + + public CheckTemplate(String key) { + this.key = key; + } + + public CheckTemplate() { + } + + public String getKey() { + return key; + } + + public void setKey(String s) { + this.key = s; + } + + public Priority getPriority() { + return priority; + } + + public void setPriority(Priority p) { + this.priority = p; + } + + public IsoCategory getIsoCategory() { + return isoCategory; + } + + public void setIsoCategory(IsoCategory c) { + this.isoCategory = c; + } + + public String getConfigKey() { + return configKey; + } + + public void setConfigKey(String configKey) { + this.configKey = configKey; + } + + public abstract String getTitle(Locale locale); + + public abstract String getDescription(Locale locale); + + public abstract String getMessage(Locale locale, String key, Object... params); + + public List<CheckTemplateProperty> getProperties() { + if (properties==null) { + return Collections.emptyList(); + } + return properties; + } + + public void addProperty(CheckTemplateProperty p) { + if (properties==null) { + properties = new ArrayList<CheckTemplateProperty>(); + } + properties.add(p); + } + + public CheckTemplateProperty getProperty(String key) { + if (properties!=null) { + for (CheckTemplateProperty property : properties) { + if (property.getKey().equals(key)) { + return property; + } + } + } + return null; + } + + /** + * Checks are equal within the same plugin. Two plugins can have two different checks with the same key. + */ + @Override + public final boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof CheckTemplate)) { + return false; + } + + CheckTemplate checkTemplate = (CheckTemplate) o; + return key.equals(checkTemplate.key); + } + + @Override + public final int hashCode() { + return key.hashCode(); + } + +}
\ No newline at end of file diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateFactory.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateFactory.java new file mode 100644 index 00000000000..d72dc1db31c --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateFactory.java @@ -0,0 +1,33 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import java.util.Collection; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public abstract class CheckTemplateFactory { + + public abstract Collection<CheckTemplate> create(); + +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateProperty.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateProperty.java new file mode 100644 index 00000000000..34dce342635 --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateProperty.java @@ -0,0 +1,71 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import java.util.Locale; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public abstract class CheckTemplateProperty implements Comparable<CheckTemplateProperty> { + + protected String key; + + public String getKey() { + return key; + } + + public void setKey(String s) { + this.key = s; + } + + public abstract String getTitle(Locale locale); + + public String getDescription() { + return getDescription(Locale.ENGLISH); + } + + + public abstract String getDescription(Locale locale); + + @Override + public final boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof CheckTemplateProperty)) { + return false; + } + + CheckTemplateProperty that = (CheckTemplateProperty) o; + return key.equals(that.key); + } + + @Override + public final int hashCode() { + return key.hashCode(); + } + + public int compareTo(CheckTemplateProperty o) { + return getKey().compareTo(o.getKey()); + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateRepositories.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateRepositories.java new file mode 100644 index 00000000000..6a159a9bd27 --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateRepositories.java @@ -0,0 +1,64 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.sonar.api.ServerExtension; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class CheckTemplateRepositories implements ServerExtension { + + private Map<String, CheckTemplateRepository> repositoriesByKey = new HashMap<String, CheckTemplateRepository>(); + + public CheckTemplateRepositories(CheckTemplateRepository[] repositories) { + if (repositories != null) { + for (CheckTemplateRepository templateRepository : repositories) { + repositoriesByKey.put(templateRepository.getKey(), templateRepository); + } + } + } + + public CheckTemplateRepositories() { + // DO NOT REMOVE THIS CONSTRUCTOR. It is used by Picocontainer when no repositories are available. + } + + public CheckTemplateRepository getRepository(String key) { + return repositoriesByKey.get(key); + } + + public Collection<CheckTemplateRepository> getRepositories() { + return repositoriesByKey.values(); + } + + public CheckTemplate getTemplate(String repositoryKey, String templateKey) { + CheckTemplateRepository repo = getRepository(repositoryKey); + if (repo != null) { + return repo.getTemplate(templateKey); + } + return null; + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateRepository.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateRepository.java new file mode 100644 index 00000000000..fa96311c8db --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/CheckTemplateRepository.java @@ -0,0 +1,203 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.apache.commons.io.IOUtils; +import org.sonar.api.profiles.RulesProfile; +import org.sonar.api.resources.Language; +import org.sonar.api.rules.*; +import org.sonar.check.IsoCategory; + +import java.io.InputStream; +import java.util.*; + +/** + * @since 2.1 (experimental) + * @deprecated since 2.3 + */ +@Deprecated +public class CheckTemplateRepository implements RulesRepository { + + private String key; + private Language language; + private List<CheckTemplate> templates; + private Map<String, CheckTemplate> templatesByKey; + + + public CheckTemplateRepository() { + } + + public CheckTemplateRepository(String key) { + if (key == null) { + throw new IllegalArgumentException("Key can not be null"); + } + this.key = key; + } + + public String getKey() { + return key; + } + + public CheckTemplateRepository setKey(String key) { + this.key = key; + return this; + } + + public Language getLanguage() { + return language; + } + + public CheckTemplateRepository setLanguage(Language l) { + this.language = l; + return this; + } + + public List<CheckTemplate> getTemplates() { + if (templates == null) { + return Collections.emptyList(); + } + return templates; + } + + public CheckTemplateRepository setTemplates(List<CheckTemplate> c) { + this.templates = c; + return this; + } + + public CheckTemplate getTemplate(String key) { + if (templatesByKey == null || templatesByKey.isEmpty()) { + templatesByKey = new HashMap<String, CheckTemplate>(); + for (CheckTemplate template : templates) { + templatesByKey.put(template.getKey(), template); + } + } + return templatesByKey.get(key); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + CheckTemplateRepository that = (CheckTemplateRepository) o; + return key.equals(that.key); + + } + + @Override + public int hashCode() { + return key.hashCode(); + } + + + public static CheckTemplateRepository createFromXml(String repositoryKey, Language language, String pathToXml) { + InputStream input = CheckTemplateRepository.class.getResourceAsStream(pathToXml); + try { + List<CheckTemplate> templates = new XmlCheckTemplateFactory().parse(input); + CheckTemplateRepository repository = new CheckTemplateRepository(repositoryKey); + repository.setTemplates(templates); + repository.setLanguage(language); + return repository; + + } finally { + IOUtils.closeQuietly(input); + } + } + + public static CheckTemplateRepository createFromAnnotatedClasses(String repositoryKey, Language language, Collection<Class> classes) { + AnnotationCheckTemplateFactory factory = new AnnotationCheckTemplateFactory(classes); + CheckTemplateRepository repository = new CheckTemplateRepository(repositoryKey); + repository.setTemplates(factory.create()); + repository.setLanguage(language); + return repository; + } + + + + + + + + + + + /* + + CODE FOR BACKWARD COMPATIBLITY + This class should not extend RulesRepository in next versions + + */ + + + public List<Rule> getInitialReferential() { + List<Rule> rules = new ArrayList<Rule>(); + for (CheckTemplate checkTemplate : getTemplates()) { + rules.add(toRule(checkTemplate)); + } + return rules; + } + + private Rule toRule(CheckTemplate checkTemplate) { + Rule rule = new Rule(getKey(), checkTemplate.getKey()); + rule.setDescription(checkTemplate.getDescription(Locale.ENGLISH)); + rule.setName(checkTemplate.getTitle(Locale.ENGLISH)); + rule.setPriority(RulePriority.fromCheckPriority(checkTemplate.getPriority())); + rule.setRulesCategory(toRuleCategory(checkTemplate.getIsoCategory())); + for (CheckTemplateProperty checkTemplateProperty : checkTemplate.getProperties()) { + RuleParam param = rule.createParameter(checkTemplateProperty.getKey()); + param.setDescription(checkTemplateProperty.getDescription(Locale.ENGLISH)); + param.setType("s"); + } + + return rule; + } + + private RulesCategory toRuleCategory(IsoCategory isoCategory) { + if (isoCategory == IsoCategory.Reliability) { + return Iso9126RulesCategories.RELIABILITY; + } + if (isoCategory == IsoCategory.Efficiency) { + return Iso9126RulesCategories.EFFICIENCY; + } + if (isoCategory == IsoCategory.Maintainability) { + return Iso9126RulesCategories.MAINTAINABILITY; + } + if (isoCategory == IsoCategory.Portability) { + return Iso9126RulesCategories.PORTABILITY; + } + if (isoCategory == IsoCategory.Usability) { + return Iso9126RulesCategories.USABILITY; + } + return null; + } + + + public List<Rule> parseReferential(String fileContent) { + return Collections.emptyList(); + } + + public List<RulesProfile> getProvidedProfiles() { + return Collections.emptyList(); + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/DefaultCheckTemplate.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/DefaultCheckTemplate.java new file mode 100644 index 00000000000..76f6fb6ca4e --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/DefaultCheckTemplate.java @@ -0,0 +1,81 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.apache.commons.lang.builder.ToStringBuilder; + +import java.util.Locale; + +/** + * EXPERIMENTAL - will be used in version 2.2 + * + * Non-internationalized check + * + * @since 2.1 + */ +public class DefaultCheckTemplate extends CheckTemplate { + + private String title; + private String description; + + public DefaultCheckTemplate() { + } + + public DefaultCheckTemplate(String key) { + super(key); + } + + public void setTitle(String title) { + this.title = title; + } + + public void setDescription(String description) { + this.description = description; + } + + @Override + public String getTitle(Locale locale) { + if (title == null || "".equals(title)) { + return getKey(); + } + return title; + } + + @Override + public String getDescription(Locale locale) { + return description; + } + + @Override + public String getMessage(Locale locale, String key, Object... params) { + return null; + } + + @Override + public String toString() { + return new ToStringBuilder(this) + .append("key", key) + .append("title", title) + .append("configKey", configKey) + .append("priority", priority) + .append("isoCategory", isoCategory) + .toString(); + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/DefaultCheckTemplateProperty.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/DefaultCheckTemplateProperty.java new file mode 100644 index 00000000000..142942b8ced --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/DefaultCheckTemplateProperty.java @@ -0,0 +1,62 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.sonar.api.checks.templates.CheckTemplateProperty; + +import java.util.Locale; + +/** + * @since 2.1 + */ +public class DefaultCheckTemplateProperty extends CheckTemplateProperty { + + private String title; + private String description; + + public String getTitle() { + if (title == null || "".equals(title)) { + return getKey(); + } + return title; + } + + @Override + public String getTitle(Locale locale) { + return getTitle(); + } + + public void setTitle(String s) { + this.title = s; + } + + public String getDescription() { + return description; + } + + public void setDescription(String s) { + this.description = s; + } + + @Override + public String getDescription(Locale locale) { + return getDescription(); + } +} diff --git a/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/XmlCheckTemplateFactory.java b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/XmlCheckTemplateFactory.java new file mode 100644 index 00000000000..0b51222c53d --- /dev/null +++ b/sonar-deprecated/src/main/java/org/sonar/api/checks/templates/XmlCheckTemplateFactory.java @@ -0,0 +1,100 @@ +/* + * Sonar, open source software quality management tool. + * Copyright (C) 2009 SonarSource SA + * mailto:contact AT sonarsource DOT com + * + * Sonar is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * Sonar is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Sonar; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 + */ +package org.sonar.api.checks.templates; + +import org.apache.commons.io.IOUtils; +import org.apache.commons.lang.CharEncoding; +import org.sonar.api.rules.Rule; +import org.sonar.api.rules.RuleParam; +import org.sonar.api.rules.StandardRulesXmlParser; +import org.sonar.api.utils.SonarException; + +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; +import java.util.ArrayList; +import java.util.List; + +/** + * EXPERIMENTAL - will be used in version 2.2 + * @since 2.1 + */ +public class XmlCheckTemplateFactory { + + public List<CheckTemplate> parseXml(String xml) { + InputStream input = null; + try { + input = IOUtils.toInputStream(xml, CharEncoding.UTF_8); + return parse(input); + + } catch (IOException e) { + throw new SonarException("Can't parse xml file", e); + + } finally { + IOUtils.closeQuietly(input); + } + } + + public List<CheckTemplate> parse(Reader reader) { + StandardRulesXmlParser parser = new StandardRulesXmlParser(); + List<Rule> rules = parser.parse(reader); + return toCheckTemplates(rules); + + } + + public List<CheckTemplate> parse(InputStream input) { + StandardRulesXmlParser parser = new StandardRulesXmlParser(); + List<Rule> rules = parser.parse(input); + return toCheckTemplates(rules); + + } + + private List<CheckTemplate> toCheckTemplates(List<Rule> rules) { + List<CheckTemplate> templates = new ArrayList<CheckTemplate>(); + if (rules != null) { + for (Rule rule : rules) { + DefaultCheckTemplate template = new DefaultCheckTemplate(rule.getKey()); + templates.add(template); + + template.setConfigKey(rule.getConfigKey()); + template.setDescription(rule.getDescription()); + template.setIsoCategory(rule.getRulesCategory().toIsoCategory()); + template.setPriority(rule.getPriority().toCheckPriority()); + template.setTitle(rule.getName()); + + if (rule.getParams() != null) { + for (RuleParam param : rule.getParams()) { + template.addProperty(toProperty(param)); + } + } + } + } + return templates; + } + + private CheckTemplateProperty toProperty(RuleParam param) { + DefaultCheckTemplateProperty property = new DefaultCheckTemplateProperty(); + property.setKey(param.getKey()); + property.setTitle(param.getKey()); + property.setDescription(param.getDescription()); + return property; + } + +}
\ No newline at end of file |