Esempio n. 1
0
 public ValidationMessages changeParentProfile(
     Integer profileId, String parentName, String userName) {
   ValidationMessages messages = ValidationMessages.create();
   RulesProfile profile = getSession().getEntity(RulesProfile.class, profileId);
   if (profile != null && !profile.getProvided()) {
     RulesProfile oldParent = getParentProfile(profile);
     RulesProfile newParent = getProfile(profile.getLanguage(), parentName);
     if (isCycle(profile, newParent)) {
       messages.addWarningText("Please do not select a child profile as parent.");
       return messages;
     }
     // Deactivate all inherited rules
     if (oldParent != null) {
       for (ActiveRule activeRule : oldParent.getActiveRules()) {
         deactivate(profile, activeRule.getRule(), userName);
       }
     }
     // Activate all inherited rules
     if (newParent != null) {
       for (ActiveRule activeRule : newParent.getActiveRules()) {
         activateOrChange(profile, activeRule, userName);
       }
     }
     profile.setParentName(newParent == null ? null : newParent.getName());
     getSession().saveWithoutFlush(profile);
     getSession().commit();
   }
   return messages;
 }
Esempio n. 2
0
 /** Rule was deactivated in parent profile. */
 public void deactivated(int parentProfileId, int deactivatedRuleId, String userName) {
   ActiveRule parentActiveRule = getSession().getEntity(ActiveRule.class, deactivatedRuleId);
   RulesProfile profile = getSession().getEntity(RulesProfile.class, parentProfileId);
   ruleDisabled(profile, parentActiveRule, userName);
   for (RulesProfile child : getChildren(parentProfileId)) {
     deactivate(child, parentActiveRule.getRule(), userName);
   }
   getSession().commit();
 }
Esempio n. 3
0
 /**
  * Get the active rules of a specific repository. Only enabled rules are selected. Disabled rules
  * are excluded.
  */
 public List<ActiveRule> getActiveRulesByRepository(String repositoryKey) {
   List<ActiveRule> result = new ArrayList<>();
   for (ActiveRule activeRule : activeRules) {
     if (repositoryKey.equals(activeRule.getRepositoryKey()) && activeRule.isEnabled()) {
       result.add(activeRule);
     }
   }
   return result;
 }
Esempio n. 4
0
 private void appendRuleParameters(ActiveRule activeRule, Writer writer) throws IOException {
   if (activeRule.getActiveRuleParams() != null && !activeRule.getActiveRuleParams().isEmpty()) {
     writer.append("<parameters>");
     for (ActiveRuleParam activeRuleParam : activeRule.getActiveRuleParams()) {
       appendRuleParameter(writer, activeRuleParam);
     }
     writer.append("</parameters>");
   }
 }
Esempio n. 5
0
 /**
  * Note: disabled rules are excluded.
  *
  * @return the list of active rules for a given severity
  */
 public List<ActiveRule> getActiveRules(RulePriority severity) {
   List<ActiveRule> result = new ArrayList<>();
   for (ActiveRule activeRule : activeRules) {
     if (activeRule.getSeverity().equals(severity) && activeRule.isEnabled()) {
       result.add(activeRule);
     }
   }
   return result;
 }
  @Test
  public void testImportingDefaultPriority() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent("/org/sonar/plugins/php/pmd/simple-ruleset.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule activeRule =
        profile.getActiveRuleByConfigKey(REPOSITORY_KEY, "rulesets/codesize.xml/NPathComplexity");
    assertThat(activeRule.getSeverity(), is(RulePriority.MAJOR)); // reuse the rule default priority
  }
Esempio n. 7
0
 /** Note: disabled rules are excluded. */
 @CheckForNull
 public ActiveRule getActiveRuleByConfigKey(String repositoryKey, String configKey) {
   for (ActiveRule activeRule : activeRules) {
     if (StringUtils.equals(activeRule.getRepositoryKey(), repositoryKey)
         && StringUtils.equals(activeRule.getConfigKey(), configKey)
         && activeRule.isEnabled()) {
       return activeRule;
     }
   }
   return null;
 }
Esempio n. 8
0
 /** Rule was activated/changed in parent profile. */
 private void activatedOrChanged(int parentProfileId, int activeRuleId, String userName) {
   ActiveRule parentActiveRule = getSession().getEntity(ActiveRule.class, activeRuleId);
   if (parentActiveRule.isInherited()) {
     parentActiveRule.setInheritance(ActiveRule.OVERRIDES);
     getSession().saveWithoutFlush(parentActiveRule);
   }
   for (RulesProfile child : getChildren(parentProfileId)) {
     activateOrChange(child, parentActiveRule, userName);
   }
   getSession().commit();
 }
Esempio n. 9
0
 /** @return the list of active rules */
 public List<ActiveRule> getActiveRules(boolean acceptDisabledRules) {
   if (acceptDisabledRules) {
     return activeRules;
   }
   List<ActiveRule> result = new ArrayList<>();
   for (ActiveRule activeRule : activeRules) {
     if (activeRule.isEnabled()) {
       result.add(activeRule);
     }
   }
   return result;
 }
  @Test
  public void importPriorities() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent(
                "/org/sonar/plugins/checkstyle/CheckstyleProfileImporterTest/simple.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule javadocCheck =
        profile.getActiveRuleByConfigKey("checkstyle", "Checker/JavadocPackage");
    assertThat(javadocCheck.getSeverity()).isEqualTo(RulePriority.BLOCKER);
  }
  @Test
  public void priorityIsOptional() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent(
                "/org/sonar/plugins/checkstyle/CheckstyleProfileImporterTest/simple.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule activeRule =
        profile.getActiveRuleByConfigKey("checkstyle", "Checker/TreeWalker/EqualsHashCode");
    assertThat(activeRule.getSeverity())
        .isEqualTo(RulePriority.BLOCKER); // reuse the rule default priority
  }
  @Test
  public void properties_should_be_inherited() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent(
                "/org/sonar/plugins/checkstyle/CheckstyleProfileImporterTest/inheritance_of_properties.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule activeRule =
        profile.getActiveRuleByConfigKey("checkstyle", "Checker/TreeWalker/MissingOverride");
    assertThat(activeRule.getSeverity()).isEqualTo(RulePriority.BLOCKER);
    assertThat(activeRule.getParameter("javaFiveCompatibility")).isEqualTo("true");
  }
  @Test
  public void testImportingParameters() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent("/org/sonar/plugins/php/pmd/simple-ruleset.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule activeRule =
        profile.getActiveRuleByConfigKey(
            REPOSITORY_KEY, "rulesets/codesize.xml/CyclomaticComplexity");
    assertThat(activeRule.getActiveRuleParams().size(), is(1));
    assertThat(activeRule.getParameter("reportLevel"), is("30"));
  }
  private void processRules(
      SMInputCursor rulesCursor, RulesProfile profile, ValidationMessages messages)
      throws XMLStreamException {
    Map<String, String> parameters = new HashMap<>();
    while (rulesCursor.getNext() != null) {
      SMInputCursor ruleCursor = rulesCursor.childElementCursor();

      String repositoryKey = null;
      String key = null;
      RulePriority priority = null;
      parameters.clear();

      while (ruleCursor.getNext() != null) {
        String nodeName = ruleCursor.getLocalName();

        if (StringUtils.equals("repositoryKey", nodeName)) {
          repositoryKey = StringUtils.trim(ruleCursor.collectDescendantText(false));

        } else if (StringUtils.equals("key", nodeName)) {
          key = StringUtils.trim(ruleCursor.collectDescendantText(false));

        } else if (StringUtils.equals("priority", nodeName)) {
          priority =
              RulePriority.valueOf(StringUtils.trim(ruleCursor.collectDescendantText(false)));

        } else if (StringUtils.equals("parameters", nodeName)) {
          SMInputCursor propsCursor = ruleCursor.childElementCursor("parameter");
          processParameters(propsCursor, parameters);
        }
      }

      Rule rule = ruleFinder.findByKey(repositoryKey, key);
      if (rule == null) {
        messages.addWarningText("Rule not found: " + ruleToString(repositoryKey, key));

      } else {
        ActiveRule activeRule = profile.activateRule(rule, priority);
        for (Map.Entry<String, String> entry : parameters.entrySet()) {
          if (rule.getParam(entry.getKey()) == null) {
            messages.addWarningText(
                "The parameter '"
                    + entry.getKey()
                    + "' does not exist in the rule: "
                    + ruleToString(repositoryKey, key));
          } else {
            activeRule.setParameter(entry.getKey(), entry.getValue());
          }
        }
      }
    }
  }
Esempio n. 15
0
  private void activateOrChange(
      RulesProfile profile, ActiveRule parentActiveRule, String userName) {
    ActiveRule oldActiveRule = profile.getActiveRule(parentActiveRule.getRule());
    if (oldActiveRule != null) {
      if (oldActiveRule.isInherited()) {
        removeActiveRule(profile, oldActiveRule);
      } else {
        oldActiveRule.setInheritance(ActiveRule.OVERRIDES);
        getSession().saveWithoutFlush(oldActiveRule);
        return; // no need to change in children
      }
    }
    ActiveRule newActiveRule = (ActiveRule) parentActiveRule.clone();
    newActiveRule.setRulesProfile(profile);
    newActiveRule.setInheritance(ActiveRule.INHERITED);
    profile.addActiveRule(newActiveRule);
    getSession().saveWithoutFlush(newActiveRule);

    if (oldActiveRule != null) {
      ruleChanged(profile, oldActiveRule, newActiveRule, userName);
    } else {
      ruleEnabled(profile, newActiveRule, userName);
    }

    for (RulesProfile child : getChildren(profile)) {
      activateOrChange(child, newActiveRule, userName);
    }
  }
Esempio n. 16
0
 private void appendRule(ActiveRule activeRule, Writer writer) throws IOException {
   writer.append("<rule><repositoryKey>");
   writer.append(activeRule.getRepositoryKey());
   writer.append("</repositoryKey><key>");
   StringEscapeUtils.escapeXml(writer, activeRule.getRuleKey());
   writer.append("</key>");
   if (activeRule.getSeverity() != null) {
     writer.append("<priority>");
     writer.append(activeRule.getSeverity().name());
     writer.append("</priority>");
   }
   appendRuleParameters(activeRule, writer);
   writer.append("</rule>");
 }
Esempio n. 17
0
  /** Rule severity was changed */
  public void ruleSeverityChanged(
      int profileId,
      int activeRuleId,
      RulePriority oldSeverity,
      RulePriority newSeverity,
      String userName) {
    ActiveRule activeRule = getSession().getEntity(ActiveRule.class, activeRuleId);
    RulesProfile profile = getSession().getEntity(RulesProfile.class, profileId);

    ruleSeverityChanged(profile, activeRule.getRule(), oldSeverity, newSeverity, userName);

    // Notify child profiles
    activatedOrChanged(profileId, activeRuleId, userName);
  }
Esempio n. 18
0
 /** Deal with creation of ActiveRuleChange item when a rule is disabled on a profile */
 private void ruleDisabled(RulesProfile profile, ActiveRule disabledRule, String userName) {
   incrementProfileVersionIfNeeded(profile);
   ActiveRuleChange rc = new ActiveRuleChange(userName, profile, disabledRule.getRule());
   rc.setEnabled(false);
   rc.setOldSeverity(disabledRule.getSeverity());
   if (disabledRule.getRule().getParams() != null) {
     for (RuleParam p : disabledRule.getRule().getParams()) {
       String oldParam = disabledRule.getParameter(p.getKey());
       if (oldParam != null) {
         rc.setParameterChange(p.getKey(), oldParam, null);
       }
     }
   }
   getSession().saveWithoutFlush(rc);
 }
Esempio n. 19
0
  /** Rule param was changed */
  public void ruleParamChanged(
      int profileId,
      int activeRuleId,
      String paramKey,
      String oldValue,
      String newValue,
      String userName) {
    ActiveRule activeRule = getSession().getEntity(ActiveRule.class, activeRuleId);
    RulesProfile profile = getSession().getEntity(RulesProfile.class, profileId);

    ruleParamChanged(profile, activeRule.getRule(), paramKey, oldValue, newValue, userName);

    // Notify child profiles
    activatedOrChanged(profileId, activeRuleId, userName);
  }
 private LintProfile createLintProfile(List<ActiveRule> activeRules) {
   LintProfile profile = new LintProfile();
   Map<String, RulePriority> activeKeys = new HashMap<>();
   List<LintIssue> issues = Lists.newArrayList();
   for (ActiveRule rule : activeRules) {
     activeKeys.put(rule.getRuleKey(), rule.getSeverity());
   }
   for (String ruleKey : ruleKeys) {
     issues.add(getLintIssue(ruleKey, activeKeys));
   }
   // ensure order of issues in output, sort by key.
   Collections.sort(issues, new IssueComparator());
   profile.issues = issues;
   return profile;
 }
  @Test
  public void testUnsupportedProperty() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent("/org/sonar/plugins/php/pmd/simple-ruleset.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule check =
        profile.getActiveRuleByConfigKey(
            REPOSITORY_KEY, "rulesets/codesize.xml/CyclomaticComplexity");
    // The mock rulefinder contains only one param for the rule, but the ruleset file contains 2, so
    // we should get a warning about that.
    assertThat(check.getParameter("threshold"), nullValue());
    assertThat(messages.getWarnings().size(), is(1));
  }
Esempio n. 22
0
 /** Deal with creation of ActiveRuleChange item when a rule is enabled on a profile */
 private void ruleEnabled(RulesProfile profile, ActiveRule newActiveRule, String userName) {
   incrementProfileVersionIfNeeded(profile);
   ActiveRuleChange rc = new ActiveRuleChange(userName, profile, newActiveRule.getRule());
   rc.setEnabled(true);
   rc.setNewSeverity(newActiveRule.getSeverity());
   if (newActiveRule.getRule().getParams() != null) {
     for (RuleParam p : newActiveRule.getRule().getParams()) {
       String newParam = newActiveRule.getParameter(p.getKey());
       if (newParam != null) {
         rc.setParameterChange(p.getKey(), null, newParam);
       }
     }
   }
   getSession().saveWithoutFlush(rc);
 }
  @Test
  public void importParameters() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent(
                "/org/sonar/plugins/checkstyle/CheckstyleProfileImporterTest/simple.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule javadocCheck =
        profile.getActiveRuleByConfigKey("checkstyle", "Checker/JavadocPackage");
    assertThat(javadocCheck.getActiveRuleParams()).hasSize(2);
    assertThat(javadocCheck.getParameter("format")).isEqualTo("abcde");
    assertThat(javadocCheck.getParameter("ignore")).isEqualTo("true");
    assertThat(javadocCheck.getParameter("severity")).isNull(); // checkstyle internal parameter
  }
Esempio n. 24
0
 protected Object createCheck(ActiveRule activeRule) {
   Class clazz = checkClassesByKey.get(activeRule.getConfigKey());
   if (clazz != null) {
     return instantiate(activeRule, clazz);
   }
   return null;
 }
  @Test
  public void testImportingPriority() {
    Reader reader =
        new StringReader(
            TestUtils.getResourceContent("/org/sonar/plugins/php/pmd/simple-ruleset.xml"));
    RulesProfile profile = importer.importProfile(reader, messages);

    ActiveRule activeRule =
        profile.getActiveRuleByConfigKey(
            REPOSITORY_KEY, "rulesets/codesize.xml/CyclomaticComplexity");
    assertThat(activeRule.getSeverity(), is(RulePriority.MINOR));

    activeRule =
        profile.getActiveRuleByConfigKey(
            REPOSITORY_KEY, "rulesets/codesize.xml/ExcessiveMethodLength");
    assertThat(activeRule.getSeverity(), is(RulePriority.CRITICAL));
  }
Esempio n. 26
0
  private void deactivate(RulesProfile profile, Rule rule, String userName) {
    ActiveRule activeRule = profile.getActiveRule(rule);
    if (activeRule != null) {
      if (activeRule.isInherited()) {
        ruleDisabled(profile, activeRule, userName);
        removeActiveRule(profile, activeRule);
      } else {
        activeRule.setInheritance(null);
        getSession().saveWithoutFlush(activeRule);
        return; // no need to change in children
      }

      for (RulesProfile child : getChildren(profile)) {
        deactivate(child, rule, userName);
      }
    }
  }
Esempio n. 27
0
  private List<ProfileDefinition> loadFromDeprecatedRepository(RulesRepository repository) {
    List<ProfileDefinition> result = new ArrayList<ProfileDefinition>();

    for (int index = 0; index < repository.getProvidedProfiles().size(); index++) {
      RulesProfile deprecated = (RulesProfile) repository.getProvidedProfiles().get(index);
      DefaultProfileDefinition providedProfile =
          DefaultProfileDefinition.create(deprecated.getName(), repository.getLanguage().getKey());
      for (ActiveRule deprecatedActiveRule : deprecated.getActiveRules(true)) {
        String repositoryKey = deprecatedActiveRule.getRepositoryKey();
        if (StringUtils.isBlank(repositoryKey)) {
          repositoryKey = getPluginKey(repository);
        }
        Rule rule = ruleFinder.findByKey(repositoryKey, deprecatedActiveRule.getRuleKey());
        if (rule != null) {
          ActiveRule activeRule =
              providedProfile.activateRule(rule, deprecatedActiveRule.getSeverity());
          for (ActiveRuleParam arp : deprecatedActiveRule.getActiveRuleParams()) {
            activeRule.setParameter(arp.getKey(), arp.getValue());
          }
        }
      }
      result.add(providedProfile);
    }
    return result;
  }
 private void processProperties(SMInputCursor ruleCursor, ActiveRule activeRule)
     throws XMLStreamException {
   SMInputCursor propertyCursor = ruleCursor.childElementCursor(PROPERTY_NODE);
   while (propertyCursor.getNext() != null) {
     String key = propertyCursor.getAttrValue(PROPERTY_NAME_ATTR);
     String value = propertyCursor.getAttrValue(PROPERTY_VALUE_ATTR);
     activeRule.setParameter(key, value);
   }
 }
Esempio n. 29
0
 private ProfileDefinition loadFromDeprecatedCheckProfile(CheckProfile cp) {
   DefaultProfileDefinition definition =
       DefaultProfileDefinition.create(cp.getName(), cp.getLanguage());
   for (Check check : cp.getChecks()) {
     RulePriority priority = null;
     if (check.getPriority() != null) {
       priority = RulePriority.fromCheckPriority(check.getPriority());
     }
     Rule rule = ruleFinder.findByKey(check.getRepositoryKey(), check.getTemplateKey());
     if (rule != null) {
       ActiveRule activeRule = definition.activateRule(rule, priority);
       for (Map.Entry<String, String> entry : check.getProperties().entrySet()) {
         activeRule.setParameter(entry.getKey(), entry.getValue());
       }
     }
   }
   return definition;
 }
  /**
   * Matches to something like: (ATOM:ATOM/NUMBER)(WHITESPACES)(SOMETHING NOT
   * WHITESPACES)(:WHITESPACES)(NUMBER,NUMBER-NUMBER,NUMBER) like: game:start/0
   * /home/dev/project/erlang/game.erl: 4,1-5,12 means: 'application name':'function name'/'number
   * of parameters' 'URL to the file': 'starting row','starting col'-'ending row','ending col'
   */
  public ViolationReport refactorErl(Project project, RulesProfile profile) {
    ViolationReport report = new ViolationReport();
    List<ActiveRule> activeRules = profile.getActiveRulesByRepository("Erlang");

    /** Read refactorErl results */
    File basedir =
        new File(
            project.getFileSystem().getBasedir()
                + File.separator
                + ((Erlang) project.getLanguage()).getEunitFolder());
    LOG.debug("Parsing refactorErl reports from folder {}", basedir.getAbsolutePath());

    String refactorErlPattern = ((Erlang) project.getLanguage()).getRefactorErlFilenamePattern();

    String[] list = getFileNamesByPattern(basedir, refactorErlPattern);

    if (list.length == 0) {
      LOG.warn("no file matches to : ", refactorErlPattern);
      return report;
    }

    for (String file : list) {
      try {
        List<ViolationReportUnit> units = readRefactorErlReportUnits(basedir, file);
        for (ViolationReportUnit refactorErlReportUnit : units) {
          ActiveRule activeRule =
              ActiveRuleFilter.getActiveRuleByRuleName(
                  activeRules, refactorErlReportUnit.getMetricKey());
          if (activeRule != null
              && ViolationUtil.checkIsValid(activeRule, refactorErlReportUnit.getMetricValue())) {
            refactorErlReportUnit.setDescription(
                ViolationUtil.getMessageForMetric(
                    activeRule, refactorErlReportUnit.getMetricValue()));
            /** Replace key coming from activeProfile because it contains the name originaly */
            refactorErlReportUnit.setMetricKey(activeRule.getRuleKey());
            report.addUnit(refactorErlReportUnit);
          }
        }
      } catch (FileNotFoundException e) {
      } catch (IOException e) {
      }
    }
    return report;
  }