source.dussan.org Git - sonarqube.git/blob

   1 /*
   2  * Sonar, open source software quality management tool.
   3  * Copyright (C) 2008-2011 SonarSource
   4  * mailto:contact AT sonarsource DOT com
   5  *
   6  * Sonar is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * Sonar is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Sonar; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
  19  */
  20 package org.sonar.plugins.cobertura.api;
  21
  22 import static java.util.Locale.ENGLISH;
  23 import static org.sonar.api.utils.ParsingUtils.parseNumber;
  24 import static org.sonar.api.utils.ParsingUtils.scaleValue;
  25
  26 import org.apache.commons.io.FilenameUtils;
  27 import org.apache.commons.lang.StringUtils;
  28 import org.codehaus.staxmate.in.SMHierarchicCursor;
  29 import org.codehaus.staxmate.in.SMInputCursor;
  30 import org.sonar.api.batch.SensorContext;
  31 import org.sonar.api.measures.CoreMetrics;
  32 import org.sonar.api.measures.Measure;
  33 import org.sonar.api.measures.PersistenceMode;
  34 import org.sonar.api.measures.PropertiesBuilder;
  35 import org.sonar.api.resources.Resource;
  36 import org.sonar.api.utils.StaxParser;
  37 import org.sonar.api.utils.XmlParserException;
  38
  39 import java.io.File;
  40 import java.text.ParseException;
  41 import java.util.ArrayList;
  42 import java.util.HashMap;
  43 import java.util.List;
  44 import java.util.Map;
  45
  46 import javax.xml.stream.XMLStreamException;
  47
  48 /**
  49  * @since 2.4
  50  */
  51 public abstract class AbstractCoberturaParser {
  52   public void parseReport(File xmlFile, final SensorContext context) {
  53     try {
  54       StaxParser parser = new StaxParser(new StaxParser.XmlStreamHandler() {
  55
  56         public void stream(SMHierarchicCursor rootCursor) throws XMLStreamException {
  57           try {
  58             rootCursor.advance();
  59             collectPackageMeasures(rootCursor.descendantElementCursor("package"), context);
  60           } catch (ParseException e) {
  61             throw new XMLStreamException(e);
  62           }
  63         }
  64       });
  65       parser.parse(xmlFile);
  66     } catch (XMLStreamException e) {
  67       throw new XmlParserException(e);
  68     }
  69   }
  70
  71   private void collectPackageMeasures(SMInputCursor pack, SensorContext context) throws ParseException, XMLStreamException {
  72     while (pack.getNext() != null) {
  73       Map<String, FileData> fileDataPerFilename = new HashMap<String, FileData>();
  74       collectFileMeasures(pack.descendantElementCursor("class"), fileDataPerFilename);
  75       for (FileData cci : fileDataPerFilename.values()) {
  76         if (isFileExist(context, cci.getFile())) {
  77           for (Measure measure : cci.getMeasures()) {
  78             context.saveMeasure(cci.getFile(), measure);
  79           }
  80         }
  81       }
  82     }
  83   }
  84
  85   private boolean isFileExist(SensorContext context, Resource<?> file) {
  86     return context.getResource(file) != null;
  87   }
  88
  89   private void collectFileMeasures(SMInputCursor clazz, Map<String, FileData> dataPerFilename) throws ParseException, XMLStreamException {
  90     while (clazz.getNext() != null) {
  91       String fileName = FilenameUtils.removeExtension(clazz.getAttrValue("filename"));
  92       fileName = fileName.replace('/', '.').replace('\\', '.');
  93       FileData data = dataPerFilename.get(fileName);
  94       if (data == null) {
  95         data = new FileData(getResource(fileName));
  96         dataPerFilename.put(fileName, data);
  97       }
  98       collectFileData(clazz, data);
  99     }
 100   }
 101
 102   private void collectFileData(SMInputCursor clazz, FileData data) throws ParseException, XMLStreamException {
 103     SMInputCursor line = clazz.childElementCursor("lines").advance().childElementCursor("line");
 104     while (line.getNext() != null) {
 105       String lineId = line.getAttrValue("number");
 106       data.addLine(lineId, (int) parseNumber(line.getAttrValue("hits"), ENGLISH));
 107
 108       String isBranch = line.getAttrValue("branch");
 109       String text = line.getAttrValue("condition-coverage");
 110       if (StringUtils.equals(isBranch, "true") && StringUtils.isNotBlank(text)) {
 111         String[] conditions = StringUtils.split(StringUtils.substringBetween(text, "(", ")"), "/");
 112         data.addConditionLine(lineId, Integer.parseInt(conditions[0]), Integer.parseInt(conditions[1]), StringUtils.substringBefore(text, " "));
 113       }
 114     }
 115   }
 116
 117   private class FileData {
 118
 119     private int lines = 0;
 120     private int conditions = 0;
 121     private int coveredLines = 0;
 122     private int coveredConditions = 0;
 123
 124     private Resource<?> file;
 125     private PropertiesBuilder<String, Integer> lineHitsBuilder = new PropertiesBuilder<String, Integer>(CoreMetrics.COVERAGE_LINE_HITS_DATA);
 126     private PropertiesBuilder<String, String> branchHitsBuilder = new PropertiesBuilder<String, String>(CoreMetrics.BRANCH_COVERAGE_HITS_DATA);
 127
 128     public void addLine(String lineId, int lineHits) {
 129       lines++;
 130       if (lineHits > 0) {
 131         coveredLines++;
 132       }
 133       lineHitsBuilder.add(lineId, lineHits);
 134     }
 135
 136     public void addConditionLine(String lineId, int coveredConditions, int conditions, String label) {
 137       this.conditions += conditions;
 138       this.coveredConditions += coveredConditions;
 139       branchHitsBuilder.add(lineId, label);
 140     }
 141
 142     public FileData(Resource<?> file) {
 143       this.file = file;
 144     }
 145
 146     public List<Measure> getMeasures() {
 147       List<Measure> measures = new ArrayList<Measure>();
 148       if (lines > 0) {
 149         measures.add(new Measure(CoreMetrics.COVERAGE, calculateCoverage(coveredLines + coveredConditions, lines + conditions)));
 150
 151         measures.add(new Measure(CoreMetrics.LINE_COVERAGE, calculateCoverage(coveredLines, lines)));
 152         measures.add(new Measure(CoreMetrics.LINES_TO_COVER, (double) lines));
 153         measures.add(new Measure(CoreMetrics.UNCOVERED_LINES, (double) lines - coveredLines));
 154         measures.add(lineHitsBuilder.build().setPersistenceMode(PersistenceMode.DATABASE));
 155
 156         if (conditions > 0) {
 157           measures.add(new Measure(CoreMetrics.BRANCH_COVERAGE, calculateCoverage(coveredConditions, conditions)));
 158           measures.add(new Measure(CoreMetrics.CONDITIONS_TO_COVER, (double) conditions));
 159           measures.add(new Measure(CoreMetrics.UNCOVERED_CONDITIONS, (double) conditions - coveredConditions));
 160           measures.add(branchHitsBuilder.build().setPersistenceMode(PersistenceMode.DATABASE));
 161         }
 162       }
 163       return measures;
 164     }
 165
 166     public Resource<?> getFile() {
 167       return file;
 168     }
 169   }
 170
 171   private double calculateCoverage(int coveredElements, int elements) {
 172     if (elements > 0) {
 173       return scaleValue(100.0 * ((double) coveredElements / (double) elements));
 174     }
 175     return 0.0;
 176   }
 177
 178   protected abstract Resource<?> getResource(String fileName);
 179 }