@Override
  public Measure calculate(FormulaData data, FormulaContext context) {

    Double criticalCount = MeasureUtils.getValue(data.getMeasure(FortifyMetrics.CFPO), null);
    Double highCount = MeasureUtils.getValue(data.getMeasure(FortifyMetrics.HFPO), null);
    Double mediumCount = MeasureUtils.getValue(data.getMeasure(FortifyMetrics.MFPO), null);
    Double lowCount = MeasureUtils.getValue(data.getMeasure(FortifyMetrics.LFPO), null);

    if (criticalCount != null && highCount != null && mediumCount != null && lowCount != null) {
      Double securityRatingLevel;
      if (criticalCount > 0) {
        securityRatingLevel = SecurityRatingFormula.BLOCKER_SECURITY_RATING_LEVEL;
      } else if (highCount > 0) {
        securityRatingLevel = SecurityRatingFormula.CRITICAL_SECURITY_RATING_LEVEL;
      } else if (mediumCount > 0) {
        securityRatingLevel = SecurityRatingFormula.MAJOR_SECURITY_RATING_LEVEL;
      } else if (lowCount > 0) {
        securityRatingLevel = SecurityRatingFormula.MINOR_SECURITY_RATING_LEVEL;
      } else {
        securityRatingLevel = SecurityRatingFormula.DEFAULT_SECURITY_RATING_LEVEL;
      }

      return new Measure(context.getTargetMetric(), securityRatingLevel);
    }
    return null;
  }
  /**
   * @param context the context
   * @return the valid lines of the component, i.e. the real number of lines
   */
  protected double getValidLines(DecoratorContext context) {
    double duplicatedLines =
        MeasureUtils.getValue(context.getMeasure(CoreMetrics.DUPLICATED_LINES), 0.0);
    double totalLines = MeasureUtils.getValue(context.getMeasure(CoreMetrics.NCLOC), 0.0);
    double validLines = totalLines - duplicatedLines;

    return validLines > 0 ? validLines : 1.0;
  }
 @Override
 protected Double countCoveredElements(DecoratorContext context) {
   double uncoveredLines =
       MeasureUtils.getValue(context.getMeasure(JaCoCoItMetrics.IT_UNCOVERED_LINES), 0.0);
   double lines =
       MeasureUtils.getValue(context.getMeasure(JaCoCoItMetrics.IT_LINES_TO_COVER), 0.0);
   return lines - uncoveredLines;
 }
 /** {@inheritDoc} */
 public void decorate(Resource resource, DecoratorContext context) {
   if (!shouldDecorateResource(resource, context)) {
     return;
   }
   Double functions = MeasureUtils.getValue(context.getMeasure(CoreMetrics.FUNCTIONS), null);
   Double complexity = MeasureUtils.getValue(context.getMeasure(CoreMetrics.COMPLEXITY), null);
   if (complexity != null && functions != null && functions > 0.0) {
     context.saveMeasure(CoreMetrics.FUNCTION_COMPLEXITY, complexity / functions);
   }
 }
  private void computeViolationsPerRules(DecoratorContext context) {
    Map<RulePriority, Multiset<Rule>> rulesPerSeverity = Maps.newHashMap();
    for (Violation violation : context.getViolations()) {
      Multiset<Rule> rulesBag = initRules(rulesPerSeverity, violation.getSeverity());
      rulesBag.add(violation.getRule());
    }

    for (RulePriority severity : RulePriority.values()) {
      Metric metric = SeverityUtils.severityToViolationMetric(severity);

      Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.rules(metric));
      for (Measure child : children) {
        RuleMeasure childRuleMeasure = (RuleMeasure) child;
        Rule rule = childRuleMeasure.getRule();
        if (rule != null && MeasureUtils.hasValue(childRuleMeasure)) {
          Multiset<Rule> rulesBag = initRules(rulesPerSeverity, severity);
          rulesBag.add(rule, childRuleMeasure.getIntValue());
        }
      }

      Multiset<Rule> rulesBag = rulesPerSeverity.get(severity);
      if (rulesBag != null) {
        for (Multiset.Entry<Rule> entry : rulesBag.entrySet()) {
          RuleMeasure measure =
              RuleMeasure.createForRule(metric, entry.getElement(), (double) entry.getCount());
          measure.setSeverity(severity);
          context.saveMeasure(measure);
        }
      }
    }
  }
 private void computeTotalViolations(DecoratorContext context) {
   if (context.getMeasure(CoreMetrics.VIOLATIONS) == null) {
     Collection<Measure> childrenViolations = context.getChildrenMeasures(CoreMetrics.VIOLATIONS);
     Double sum = MeasureUtils.sum(true, childrenViolations);
     context.saveMeasure(CoreMetrics.VIOLATIONS, sum + context.getViolations().size());
   }
 }
  /** {@inheritDoc} */
  public void decorate(Resource resource, DecoratorContext context) {
    if (!shouldDecorateResource(context)) {
      return;
    }
    Measure dividend = context.getMeasure(getDividendMetric());
    Measure divisor = context.getMeasure(getDivisorMetric());

    if (MeasureUtils.hasValue(dividend)
        && MeasureUtils.hasValue(divisor)
        && divisor.getValue() > 0.0) {
      context.saveMeasure(
          new Measure(
              getQuotientMetric(),
              compute(dividend, divisor, getQuotientMetric().isPercentageType())));
    }
  }
Example #8
0
 private int saveValue(DecoratorContext context, Metric metric, String ruleKey) {
   int result;
   result = MeasureUtils.sum(true, context.getChildrenMeasures(metric)).intValue();
   for (Violation violation : context.getViolations()) {
     if (violation.getRule().getKey().equals(ruleKey)) {
       result++;
     }
   }
   context.saveMeasure(metric, (double) result);
   return result;
 }
  @Override
  public void checkResource(
      Resource resource,
      DecoratorContext context,
      RuleKey rule,
      ResourcePerspectives perspectives) {
    double lineCoverage =
        MeasureUtils.getValue(context.getMeasure(CoreMetrics.BRANCH_COVERAGE), 0.0);
    if (context.getMeasure(CoreMetrics.BRANCH_COVERAGE) != null
        && lineCoverage < minimumBranchCoverageRatio) {
      double uncoveredConditions =
          MeasureUtils.getValue(context.getMeasure(CoreMetrics.UNCOVERED_CONDITIONS), 0.0);
      double conditionsToCover =
          MeasureUtils.getValue(context.getMeasure(CoreMetrics.CONDITIONS_TO_COVER), 0.0);
      double conditionsToCoverToReachThreshold =
          Math.ceil(
              (conditionsToCover * minimumBranchCoverageRatio / 100)
                  - (conditionsToCover - uncoveredConditions));

      createIssue(resource, rule, conditionsToCoverToReachThreshold, perspectives);
    }
  }
  private void computeViolationsPerSeverities(DecoratorContext context) {
    Multiset<RulePriority> severitiesBag = HashMultiset.create();
    for (Violation violation : context.getViolations()) {
      severitiesBag.add(violation.getSeverity());
    }

    for (RulePriority severity : RulePriority.values()) {
      Metric metric = SeverityUtils.severityToViolationMetric(severity);
      if (context.getMeasure(metric) == null) {
        Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.metric(metric));
        int sum = MeasureUtils.sum(true, children).intValue() + severitiesBag.count(severity);
        context.saveMeasure(metric, (double) sum);
      }
    }
  }
 private boolean shouldDecorateResource(Resource resource, DecoratorContext context) {
   return !MeasureUtils.hasValue(context.getMeasure(CoreMetrics.FUNCTION_COMPLEXITY));
 }
 @Override
 protected Double countElements(DecoratorContext context) {
   return MeasureUtils.getValue(context.getMeasure(JaCoCoItMetrics.IT_LINES_TO_COVER), 0.0);
 }
 private int sumChildren(DecoratorContext context, Metric metric) {
   return MeasureUtils.sum(true, context.getChildrenMeasures(metric)).intValue();
 }