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

   1 /*
   2  * SonarQube
   3  * Copyright (C) 2009-2017 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.server.computation.task.projectanalysis.component;
  21
  22 import java.util.function.Function;
  23 import javax.annotation.CheckForNull;
  24 import javax.annotation.Nullable;
  25 import org.sonar.db.component.SnapshotDto;
  26 import org.sonar.scanner.protocol.output.ScannerReport;
  27 import org.sonar.scanner.protocol.output.ScannerReport.Component.FileStatus;
  28 import org.sonar.server.computation.task.projectanalysis.analysis.Project;
  29
  30 import static com.google.common.base.MoreObjects.firstNonNull;
  31 import static com.google.common.base.Preconditions.checkArgument;
  32 import static java.lang.String.format;
  33 import static org.apache.commons.lang.StringUtils.trimToNull;
  34
  35 public class ComponentTreeBuilder {
  36
  37   private static final String DEFAULT_PROJECT_VERSION = "not provided";
  38
  39   private final ComponentKeyGenerator keyGenerator;
  40   /**
  41    * Will supply the UUID for any component in the tree, given it's key.
  42    * <p>
  43    * The String argument of the {@link Function#apply(Object)} method is the component's key.
  44    * </p>
  45    */
  46   private final Function<String, String> uuidSupplier;
  47
  48   /**
  49    * Will supply the {@link ScannerReport.Component} of all the components in the component tree as we crawl it from the
  50    * root.
  51    * <p>
  52    * The Integer argument of the {@link Function#apply(Object)} method is the component's ref.
  53    * </p>
  54    */
  55   private final Function<Integer, ScannerReport.Component> scannerComponentSupplier;
  56
  57   private final Project project;
  58
  59   @Nullable
  60   private final SnapshotDto baseAnalysis;
  61
  62   public ComponentTreeBuilder(
  63     ComponentKeyGenerator keyGenerator,
  64     Function<String, String> uuidSupplier,
  65     Function<Integer, ScannerReport.Component> scannerComponentSupplier,
  66     Project project,
  67     @Nullable SnapshotDto baseAnalysis) {
  68
  69     this.keyGenerator = keyGenerator;
  70     this.uuidSupplier = uuidSupplier;
  71     this.scannerComponentSupplier = scannerComponentSupplier;
  72     this.project = project;
  73     this.baseAnalysis = baseAnalysis;
  74   }
  75
  76   public Component buildProject(ScannerReport.Component project) {
  77     return buildComponent(project, project);
  78   }
  79
  80   private Component[] buildChildren(ScannerReport.Component component, ScannerReport.Component parentModule) {
  81     return component.getChildRefList()
  82       .stream()
  83       .map(scannerComponentSupplier::apply)
  84       .map(c -> buildComponent(c, parentModule))
  85       .toArray(Component[]::new);
  86   }
  87
  88   private ComponentImpl buildComponent(ScannerReport.Component component, ScannerReport.Component closestModule) {
  89     switch (component.getType()) {
  90       case PROJECT:
  91         String projectKey = keyGenerator.generateKey(component, null);
  92         String uuid = uuidSupplier.apply(projectKey);
  93         return ComponentImpl.builder(Component.Type.PROJECT)
  94           .setUuid(uuid)
  95           .setKey(projectKey)
  96           .setName(nameOfProject(component))
  97           .setStatus(convertStatus(component.getStatus()))
  98           .setDescription(trimToNull(component.getDescription()))
  99           .setReportAttributes(createAttributesBuilder(component)
 100             .setVersion(createProjectVersion(component))
 101             .build())
 102           .addChildren(buildChildren(component, component))
 103           .build();
 104
 105       case MODULE:
 106         String moduleKey = keyGenerator.generateKey(component, null);
 107         return ComponentImpl.builder(Component.Type.MODULE)
 108           .setUuid(uuidSupplier.apply(moduleKey))
 109           .setKey(moduleKey)
 110           .setName(nameOfOthers(component, moduleKey))
 111           .setStatus(convertStatus(component.getStatus()))
 112           .setDescription(trimToNull(component.getDescription()))
 113           .setReportAttributes(createAttributesBuilder(component).build())
 114           .addChildren(buildChildren(component, component))
 115           .build();
 116
 117       case DIRECTORY:
 118       case FILE:
 119         String key = keyGenerator.generateKey(closestModule, component);
 120         return ComponentImpl.builder(convertDirOrFileType(component.getType()))
 121           .setUuid(uuidSupplier.apply(key))
 122           .setKey(key)
 123           .setName(nameOfOthers(component, key))
 124           .setStatus(convertStatus(component.getStatus()))
 125           .setDescription(trimToNull(component.getDescription()))
 126           .setReportAttributes(createAttributesBuilder(component).build())
 127           .setFileAttributes(createFileAttributes(component))
 128           .addChildren(buildChildren(component, closestModule))
 129           .build();
 130
 131       default:
 132         throw new IllegalArgumentException(format("Unsupported component type '%s'", component.getType()));
 133     }
 134   }
 135
 136   private static Component.Status convertStatus(FileStatus status) {
 137     switch(status) {
 138       case ADDED:
 139         return Component.Status.ADDED;
 140       case SAME:
 141         return Component.Status.SAME;
 142       case CHANGED:
 143         return Component.Status.CHANGED;
 144       case UNAVAILABLE:
 145         return Component.Status.UNAVAILABLE;
 146       case UNRECOGNIZED:
 147       default:
 148         throw new IllegalArgumentException("Unsupported ComponentType value " + status);
 149     }
 150   }
 151
 152   private String nameOfProject(ScannerReport.Component component) {
 153     String name = trimToNull(component.getName());
 154     if (name != null) {
 155       return name;
 156     }
 157     return project.getName();
 158   }
 159
 160   private static String nameOfOthers(ScannerReport.Component reportComponent, String defaultName) {
 161     String name = trimToNull(reportComponent.getName());
 162     return name == null ? defaultName : name;
 163   }
 164
 165   private String createProjectVersion(ScannerReport.Component component) {
 166     String version = trimToNull(component.getVersion());
 167     if (version != null) {
 168       return version;
 169     }
 170     if (baseAnalysis != null) {
 171       return firstNonNull(baseAnalysis.getVersion(), DEFAULT_PROJECT_VERSION);
 172     }
 173     return DEFAULT_PROJECT_VERSION;
 174   }
 175
 176   private static ReportAttributes.Builder createAttributesBuilder(ScannerReport.Component component) {
 177     return ReportAttributes.newBuilder(component.getRef())
 178       .setVersion(trimToNull(component.getVersion()))
 179       .setPath(trimToNull(component.getPath()));
 180   }
 181
 182   @CheckForNull
 183   private static FileAttributes createFileAttributes(ScannerReport.Component component) {
 184     if (component.getType() != ScannerReport.Component.ComponentType.FILE) {
 185       return null;
 186     }
 187
 188     checkArgument(component.getLines() > 0, "File '%s' has no line", component.getPath());
 189     return new FileAttributes(
 190       component.getIsTest(),
 191       trimToNull(component.getLanguage()),
 192       component.getLines());
 193   }
 194
 195   private static Component.Type convertDirOrFileType(ScannerReport.Component.ComponentType type) {
 196     switch (type) {
 197       case DIRECTORY:
 198         return Component.Type.DIRECTORY;
 199       case FILE:
 200         return Component.Type.FILE;
 201       default:
 202         throw new IllegalArgumentException("Unsupported ComponentType value " + type);
 203     }
 204   }
 205 }