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

   1 /*
   2  * SonarQube
   3  * Copyright (C) 2009-2019 SonarSource SA
   4  * mailto:info AT sonarsource DOT com
   5  *
   6  * This program 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  * This program 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 License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 package org.sonar.ce.task.projectanalysis.source;
  21
  22 import java.util.List;
  23 import java.util.Optional;
  24 import org.apache.commons.lang.StringUtils;
  25 import org.sonar.ce.task.projectanalysis.component.Component;
  26 import org.sonar.core.hash.LineRange;
  27 import org.sonar.core.hash.SourceLineHashesComputer;
  28 import org.sonar.core.util.CloseableIterator;
  29 import org.sonar.db.source.LineHashVersion;
  30
  31 public class SourceLinesHashRepositoryImpl implements SourceLinesHashRepository {
  32   private final SourceLinesRepository sourceLinesRepository;
  33   private final SignificantCodeRepository significantCodeRepository;
  34   private final SourceLinesHashCache cache;
  35   private final DbLineHashVersion dbLineHashesVersion;
  36
  37   public SourceLinesHashRepositoryImpl(SourceLinesRepository sourceLinesRepository, SignificantCodeRepository significantCodeRepository,
  38     SourceLinesHashCache cache, DbLineHashVersion dbLineHashVersion) {
  39     this.sourceLinesRepository = sourceLinesRepository;
  40     this.significantCodeRepository = significantCodeRepository;
  41     this.cache = cache;
  42     this.dbLineHashesVersion = dbLineHashVersion;
  43   }
  44
  45   @Override
  46   public List<String> getLineHashesMatchingDBVersion(Component component) {
  47     return cache.computeIfAbsent(component, this::createLineHashesMatchingDBVersion);
  48   }
  49
  50   @Override
  51   public int getLineHashesVersion(Component component) {
  52     if (significantCodeRepository.getRangesPerLine(component).isPresent()) {
  53       return LineHashVersion.WITH_SIGNIFICANT_CODE.getDbValue();
  54     } else {
  55       return LineHashVersion.WITHOUT_SIGNIFICANT_CODE.getDbValue();
  56     }
  57   }
  58
  59   @Override
  60   public LineHashesComputer getLineHashesComputerToPersist(Component component) {
  61     boolean cacheHit = cache.contains(component);
  62
  63     // check if line hashes are cached and if we can use it
  64     if (cacheHit && dbLineHashesVersion.hasLineHashesWithSignificantCode(component)) {
  65       return new CachedLineHashesComputer(cache.get(component));
  66     }
  67
  68     Optional<LineRange[]> significantCodePerLine = significantCodeRepository.getRangesPerLine(component);
  69     if (cacheHit && !significantCodePerLine.isPresent()) {
  70       return new CachedLineHashesComputer(cache.get(component));
  71     }
  72
  73     // Generate the line hashes taking into account significant code ranges
  74     return createLineHashesProcessor(component.getFileAttributes().getLines(), significantCodePerLine);
  75   }
  76
  77   private List<String> createLineHashesMatchingDBVersion(Component component) {
  78     if (!dbLineHashesVersion.hasLineHashesWithSignificantCode(component)) {
  79       return createLineHashes(component, Optional.empty());
  80     }
  81
  82     Optional<LineRange[]> significantCodePerLine = significantCodeRepository.getRangesPerLine(component);
  83     return createLineHashes(component, significantCodePerLine);
  84   }
  85
  86   private List<String> createLineHashes(Component component, Optional<LineRange[]> significantCodePerLine) {
  87     LineHashesComputer processor = createLineHashesProcessor(component.getFileAttributes().getLines(), significantCodePerLine);
  88     try (CloseableIterator<String> lines = sourceLinesRepository.readLines(component)) {
  89       while (lines.hasNext()) {
  90         processor.addLine(lines.next());
  91       }
  92       return processor.getResult();
  93     }
  94   }
  95
  96   public interface LineHashesComputer {
  97     void addLine(String line);
  98
  99     List<String> getResult();
 100   }
 101
 102   private static LineHashesComputer createLineHashesProcessor(int numLines, Optional<LineRange[]> significantCodePerLine) {
 103     if (significantCodePerLine.isPresent()) {
 104       return new SignificantCodeLineHashesComputer(new SourceLineHashesComputer(numLines), significantCodePerLine.get());
 105     } else {
 106       return new SimpleLineHashesComputer(numLines);
 107     }
 108   }
 109
 110   static class CachedLineHashesComputer implements LineHashesComputer {
 111     private final List<String> lineHashes;
 112
 113     public CachedLineHashesComputer(List<String> lineHashes) {
 114       this.lineHashes = lineHashes;
 115     }
 116
 117     @Override
 118     public void addLine(String line) {
 119       // no op
 120     }
 121
 122     @Override
 123     public List<String> getResult() {
 124       return lineHashes;
 125     }
 126   }
 127
 128   static class SimpleLineHashesComputer implements LineHashesComputer {
 129     private final SourceLineHashesComputer delegate;
 130
 131     public SimpleLineHashesComputer(int numLines) {
 132       this.delegate = new SourceLineHashesComputer(numLines);
 133     }
 134
 135     @Override
 136     public void addLine(String line) {
 137       delegate.addLine(line);
 138     }
 139
 140     @Override
 141     public List<String> getResult() {
 142       return delegate.getLineHashes();
 143     }
 144   }
 145
 146   static class SignificantCodeLineHashesComputer implements LineHashesComputer {
 147     private final SourceLineHashesComputer delegate;
 148     private final LineRange[] rangesPerLine;
 149
 150     private int i = 0;
 151
 152     public SignificantCodeLineHashesComputer(SourceLineHashesComputer hashComputer, LineRange[] rangesPerLine) {
 153       this.rangesPerLine = rangesPerLine;
 154       this.delegate = hashComputer;
 155     }
 156
 157     @Override
 158     public void addLine(String line) {
 159       LineRange range = null;
 160       if (i < rangesPerLine.length) {
 161         range = rangesPerLine[i];
 162       }
 163
 164       if (range == null) {
 165         delegate.addLine("");
 166       } else {
 167         delegate.addLine(StringUtils.substring(line, range.startOffset(), range.endOffset()));
 168       }
 169       i++;
 170     }
 171
 172     @Override
 173     public List<String> getResult() {
 174       return delegate.getLineHashes();
 175     }
 176   }
 177
 178 }