git.gumartinm.name Git - JavaForFun/blob

   1 package de.example.plugins.custom.java;
   2
   3 import java.io.IOException;
   4 import java.net.URL;
   5 import java.util.List;
   6
   7 import javax.annotation.Nullable;
   8
   9 import org.sonar.api.rule.RuleStatus;
  10 import org.sonar.api.server.debt.DebtRemediationFunction;
  11 import org.sonar.api.server.rule.RulesDefinition;
  12 import org.sonar.api.server.rule.RulesDefinitionAnnotationLoader;
  13 import org.sonar.api.utils.AnnotationUtils;
  14 import org.sonar.plugins.java.Java;
  15 import org.sonar.squidbridge.annotations.RuleTemplate;
  16
  17 import com.google.common.annotations.VisibleForTesting;
  18 import com.google.common.base.Charsets;
  19 import com.google.common.base.Strings;
  20 import com.google.common.collect.Iterables;
  21 import com.google.common.io.Resources;
  22 import com.google.gson.Gson;
  23
  24 import de.example.custom.java.checks.CheckList;
  25
  26 /**
  27  * Definition of rules.
  28  */
  29 public class CustomRulesDefinition implements RulesDefinition {
  30         private static final String RESOURCE_BASE_PATH = "/de/example/l10n/java/rules/custom";
  31
  32         private final Gson gson = new Gson();
  33
  34         @Override
  35         public void define(Context context) {
  36                 NewRepository repository = context
  37                                 .createRepository(CheckList.REPOSITORY_KEY, Java.KEY)
  38                                 .setName(CheckList.REPOSITORY_NAME);
  39                 List<Class> checks = CheckList.getChecks();
  40                 new RulesDefinitionAnnotationLoader().load(repository, Iterables.toArray(checks, Class.class));
  41                 for (Class ruleClass : checks) {
  42                         newRule(ruleClass, repository);
  43                 }
  44                 repository.done();
  45         }
  46
  47   @VisibleForTesting
  48   protected void newRule(Class<?> ruleClass, NewRepository repository) {
  49
  50     org.sonar.check.Rule ruleAnnotation = AnnotationUtils.getAnnotation(ruleClass, org.sonar.check.Rule.class);
  51     if (ruleAnnotation == null) {
  52       throw new IllegalArgumentException("No Rule annotation was found on " + ruleClass);
  53     }
  54     String ruleKey = ruleAnnotation.key();
  55     if (Strings.isNullOrEmpty(ruleKey)) {
  56       throw new IllegalArgumentException("No key is defined in Rule annotation of " + ruleClass);
  57     }
  58     NewRule rule = repository.rule(ruleKey);
  59     if (rule == null) {
  60       throw new IllegalStateException("No rule was created for " + ruleClass + " in " + repository.key());
  61     }
  62
  63     // Check whether it is a Rule Template.
  64     rule.setTemplate(AnnotationUtils.getAnnotation(ruleClass, RuleTemplate.class) != null);
  65     ruleMetadata(ruleClass, rule);
  66   }
  67
  68   private void ruleMetadata(Class<?> ruleClass, NewRule rule) {
  69     String metadataKey = rule.key();
  70     addHtmlDescription(rule, metadataKey);
  71     addMetadata(rule, metadataKey);
  72
  73   }
  74
  75   private void addMetadata(NewRule rule, String metadataKey) {
  76     URL resource = CustomRulesDefinition.class.getResource(RESOURCE_BASE_PATH + "/" + metadataKey + "_java.json");
  77     if (resource != null) {
  78       RuleMetatada metatada = gson.fromJson(readResource(resource), RuleMetatada.class);
  79       rule.setSeverity(metatada.defaultSeverity.toUpperCase());
  80       rule.setName(metatada.title);
  81       rule.addTags(metatada.tags);
  82       rule.setStatus(RuleStatus.valueOf(metatada.status.toUpperCase()));
  83       if(metatada.remediation != null) {
  84         rule.setDebtRemediationFunction(metatada.remediation.remediationFunction(rule.debtRemediationFunctions()));
  85         rule.setGapDescription(metatada.remediation.linearDesc);
  86       }
  87     }
  88   }
  89
  90   private void addHtmlDescription(NewRule rule, String metadataKey) {
  91     URL resource = CustomRulesDefinition.class.getResource(RESOURCE_BASE_PATH + "/" + metadataKey + "_java.html");
  92     if (resource != null) {
  93       rule.setHtmlDescription(readResource(resource));
  94     }
  95   }
  96
  97   private String readResource(URL resource) {
  98     try {
  99       return Resources.toString(resource, Charsets.UTF_8);
 100     } catch (IOException e) {
 101       throw new IllegalStateException("Failed to read: " + resource, e);
 102     }
 103   }
 104
 105   private static class RuleMetatada {
 106     String title;
 107     String status;
 108     @Nullable
 109     Remediation remediation;
 110
 111     String[] tags;
 112     String defaultSeverity;
 113   }
 114
 115   private static class Remediation {
 116     String func;
 117     String constantCost;
 118     String linearDesc;
 119     String linearOffset;
 120     String linearFactor;
 121
 122     public DebtRemediationFunction remediationFunction(DebtRemediationFunctions drf) {
 123       if(func.startsWith("Constant")) {
 124         return drf.constantPerIssue(constantCost.replace("mn", "min"));
 125       }
 126       if("Linear".equals(func)) {
 127         return drf.linear(linearFactor.replace("mn", "min"));
 128       }
 129       return drf.linearWithOffset(linearFactor.replace("mn", "min"), linearOffset.replace("mn", "min"));
 130     }
 131   }
 132
 133 }