001 /* 002 * Sonar, open source software quality management tool. 003 * Copyright (C) 2008-2011 SonarSource 004 * mailto:contact AT sonarsource DOT com 005 * 006 * Sonar is free software; you can redistribute it and/or 007 * modify it under the terms of the GNU Lesser General Public 008 * License as published by the Free Software Foundation; either 009 * version 3 of the License, or (at your option) any later version. 010 * 011 * Sonar is distributed in the hope that it will be useful, 012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 * Lesser General Public License for more details. 015 * 016 * You should have received a copy of the GNU Lesser General Public 017 * License along with Sonar; if not, write to the Free Software 018 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 019 */ 020 package org.sonar.api.checks; 021 022 import org.apache.commons.lang.StringUtils; 023 import org.sonar.api.profiles.RulesProfile; 024 import org.sonar.api.rules.ActiveRule; 025 import org.sonar.api.rules.ActiveRuleParam; 026 import org.sonar.api.utils.SonarException; 027 import org.sonar.check.Check; 028 import org.sonar.check.CheckProperty; 029 import org.sonar.check.Rule; 030 import org.sonar.check.RuleProperty; 031 032 import com.google.common.collect.Maps; 033 034 import java.lang.reflect.Field; 035 import java.util.Collection; 036 import java.util.Map; 037 038 /** 039 * @since 2.3 040 */ 041 public final class AnnotationCheckFactory extends CheckFactory { 042 043 private Map<String, Class> checkClassesByKey = Maps.newHashMap(); 044 045 private AnnotationCheckFactory(RulesProfile profile, String repositoryKey, Collection<Class> checkClasses) { 046 super(profile, repositoryKey); 047 groupClassesByKey(checkClasses); 048 } 049 050 public static AnnotationCheckFactory create(RulesProfile profile, String repositoryKey, Collection<Class> checkClasses) { 051 AnnotationCheckFactory factory = new AnnotationCheckFactory(profile, repositoryKey, checkClasses); 052 factory.init(); 053 return factory; 054 } 055 056 private void groupClassesByKey(Collection<Class> checkClasses) { 057 for (Class checkClass : checkClasses) { 058 String key = getRuleKey(checkClass); 059 if (key != null) { 060 checkClassesByKey.put(key, checkClass); 061 } 062 } 063 } 064 065 protected Object createCheck(ActiveRule activeRule) { 066 Class clazz = checkClassesByKey.get(activeRule.getConfigKey()); 067 if (clazz != null) { 068 return instantiate(activeRule, clazz); 069 } 070 return null; 071 } 072 073 private Object instantiate(ActiveRule activeRule, Class clazz) { 074 try { 075 Object check = clazz.newInstance(); 076 configureFields(activeRule, check); 077 return check; 078 079 } catch (InstantiationException e) { 080 throw new SonarException("Can not instantiate the check related to the rule " + activeRule, e); 081 082 } catch (IllegalAccessException e) { 083 throw new SonarException("Can not instantiate the check related to the rule " + activeRule, e); 084 } 085 } 086 087 private void configureFields(ActiveRule activeRule, Object check) { 088 for (ActiveRuleParam param : activeRule.getActiveRuleParams()) { 089 Field field = getField(check, param.getKey()); 090 if (field == null) { 091 throw new SonarException("The field " + param.getKey() + " does not exist or is not annotated with @RuleProperty in the class " + check.getClass().getName()); 092 } 093 if (StringUtils.isNotBlank(param.getValue())) { 094 configureField(check, field, param.getValue()); 095 } 096 } 097 098 } 099 100 private void configureField(Object check, Field field, String value) { 101 try { 102 field.setAccessible(true); 103 104 if (field.getType().equals(String.class)) { 105 field.set(check, value); 106 107 } else if ("int".equals(field.getType().getSimpleName())) { 108 field.setInt(check, Integer.parseInt(value)); 109 110 } else if ("short".equals(field.getType().getSimpleName())) { 111 field.setShort(check, Short.parseShort(value)); 112 113 } else if ("long".equals(field.getType().getSimpleName())) { 114 field.setLong(check, Long.parseLong(value)); 115 116 } else if ("double".equals(field.getType().getSimpleName())) { 117 field.setDouble(check, Double.parseDouble(value)); 118 119 } else if ("boolean".equals(field.getType().getSimpleName())) { 120 field.setBoolean(check, Boolean.parseBoolean(value)); 121 122 } else if ("byte".equals(field.getType().getSimpleName())) { 123 field.setByte(check, Byte.parseByte(value)); 124 125 } else if (field.getType().equals(Integer.class)) { 126 field.set(check, Integer.parseInt(value)); 127 128 } else if (field.getType().equals(Long.class)) { 129 field.set(check, Long.parseLong(value)); 130 131 } else if (field.getType().equals(Double.class)) { 132 field.set(check, Double.parseDouble(value)); 133 134 } else if (field.getType().equals(Boolean.class)) { 135 field.set(check, Boolean.parseBoolean(value)); 136 137 } else { 138 throw new SonarException("The type of the field " + field + " is not supported: " + field.getType()); 139 } 140 } catch (IllegalAccessException e) { 141 throw new SonarException("Can not set the value of the field " + field + " in the class: " + check.getClass().getName(), e); 142 } 143 } 144 145 private Field getField(Object check, String key) { 146 Field[] fields = check.getClass().getDeclaredFields(); 147 for (Field field : fields) { 148 RuleProperty propertyAnnotation = field.getAnnotation(RuleProperty.class); 149 if (propertyAnnotation != null) { 150 if (StringUtils.equals(key, field.getName()) || StringUtils.equals(key, propertyAnnotation.key())) { 151 return field; 152 } 153 } else { 154 CheckProperty checkAnnotation = field.getAnnotation(CheckProperty.class); 155 if (checkAnnotation != null) { 156 if (StringUtils.equals(key, field.getName()) || StringUtils.equals(key, checkAnnotation.key())) { 157 return field; 158 } 159 } 160 } 161 } 162 return null; 163 } 164 165 private String getRuleKey(Class annotatedClass) { 166 String key = null; 167 Rule ruleAnnotation = (Rule) annotatedClass.getAnnotation(Rule.class); 168 if (ruleAnnotation != null) { 169 key = ruleAnnotation.key(); 170 } else { 171 Check checkAnnotation = (Check) annotatedClass.getAnnotation(Check.class); 172 if (checkAnnotation != null) { 173 key = checkAnnotation.key(); 174 175 } 176 } 177 return StringUtils.defaultIfEmpty(key, annotatedClass.getCanonicalName()); 178 } 179 }