<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.0</version>
+ <version>3.1</version>
</plugin>
<plugin>
- <!-- not thread safe -->
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
- <version>2.5.1</version>
+ <version>2.7</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
- <version>2.12</version>
+ <version>2.15</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-plugin-plugin</artifactId>
- <version>2.9</version>
+ <version>3.2</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
- <version>2.12.4</version>
+ <version>2.14.1</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
- <version>2.1.1</version>
+ <version>2.3</version>
</plugin>
<plugin>
<!-- not thread safe -->
<plugin>
<groupId>org.codehaus.sonar</groupId>
<artifactId>sonar-packaging-maven-plugin</artifactId>
- <version>1.6</version>
+ <version>1.7</version>
</plugin>
</plugins>
</pluginManagement>
<dependency>
<groupId>org.apache.maven.shared</groupId>
<artifactId>maven-dependency-tree</artifactId>
- <version>1.2</version>
+ <version>2.1</version>
<exclusions>
<exclusion>
<!-- See SONAR-2455 -->
}
projectReactor = builder.projectReactor;
if (builder.isEnableLoggingConfiguration()) {
- logging = LoggingConfiguration.create().setProperties(bootstrapProperties);
+ logging = LoggingConfiguration.create(builder.environment).setProperties(bootstrapProperties);
}
}
*/
package org.sonar.batch.bootstrapper;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Maps;
import org.apache.commons.lang.StringUtils;
import org.sonar.core.config.Logback;
+import javax.annotation.Nullable;
+
import java.io.File;
import java.util.Map;
public static final String LEVEL_SQL_RESULTS_VERBOSE = "DEBUG";
public static final String LEVEL_SQL_RESULTS_DEFAULT = "WARN";
- public static final String FORMAT_DEFAULT = "%d{HH:mm:ss.SSS} %-5level - %msg%n";
- public static final String FORMAT_MAVEN = "[%level] [%d{HH:mm:ss.SSS}] %msg%n";
+ @VisibleForTesting
+ static final String FORMAT_DEFAULT = "%d{HH:mm:ss.SSS} %-5level - %msg%n";
+ @VisibleForTesting
+ static final String FORMAT_MAVEN = "[%level] [%d{HH:mm:ss.SSS}] %msg%n";
private Map<String, String> substitutionVariables = Maps.newHashMap();
- private LoggingConfiguration() {
+ private LoggingConfiguration(@Nullable EnvironmentInformation environment) {
setVerbose(false);
setShowSql(false);
- setFormat(FORMAT_DEFAULT);
+ if (environment != null && "maven".equalsIgnoreCase(environment.getKey())) {
+ setFormat(FORMAT_MAVEN);
+ }
+ else {
+ setFormat(FORMAT_DEFAULT);
+ }
}
- static LoggingConfiguration create() {
- return new LoggingConfiguration();
+ static LoggingConfiguration create(@Nullable EnvironmentInformation environment) {
+ return new LoggingConfiguration(environment);
}
public LoggingConfiguration setProperties(Map<String, String> properties) {
return addSubstitutionVariable(PROPERTY_SQL_RESULTS_LOGGER_LEVEL, level);
}
- public LoggingConfiguration setFormat(String format) {
+ @VisibleForTesting
+ LoggingConfiguration setFormat(String format) {
return addSubstitutionVariable(PROPERTY_FORMAT, StringUtils.defaultIfBlank(format, FORMAT_DEFAULT));
}
package org.sonar.batch.scan.maven;
import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.lang.StringUtils;
}
public static ProjectDefinition convert(List<MavenProject> poms, MavenProject root) {
+ ProjectDefinition def = ProjectDefinition.create();
+ configure(def, poms, root);
+ return def;
+ }
+
+ public static void configure(ProjectDefinition rootProjectDefinition, List<MavenProject> poms, MavenProject root) {
// projects by canonical path to pom.xml
Map<String, MavenProject> paths = Maps.newHashMap();
Map<MavenProject, ProjectDefinition> defs = Maps.newHashMap();
try {
for (MavenProject pom : poms) {
paths.put(pom.getFile().getCanonicalPath(), pom);
- defs.put(pom, convert(pom));
+ ProjectDefinition def = pom == root ? rootProjectDefinition : ProjectDefinition.create();
+ merge(pom, def);
+ defs.put(pom, def);
}
for (Map.Entry<String, MavenProject> entry : paths.entrySet()) {
if (rootProject == null) {
throw new IllegalStateException(UNABLE_TO_DETERMINE_PROJECT_STRUCTURE_EXCEPTION_MESSAGE);
}
- return rootProject;
}
private static MavenProject findMavenProject(final File modulePath, Map<String, MavenProject> paths) throws IOException {
}
@VisibleForTesting
- static ProjectDefinition convert(MavenProject pom) {
- String key = new StringBuilder().append(pom.getGroupId()).append(":").append(pom.getArtifactId()).toString();
- ProjectDefinition definition = ProjectDefinition.create();
+ static void merge(MavenProject pom, ProjectDefinition definition) {
+ String key = getSonarKey(pom);
// IMPORTANT NOTE : reference on properties from POM model must not be saved,
// instead they should be copied explicitly - see SONAR-2896
definition
- .setProperties(pom.getModel().getProperties())
- .setKey(key)
- .setVersion(pom.getVersion())
- .setName(pom.getName())
- .setDescription(pom.getDescription())
- .addContainerExtension(pom);
+ .setProperties(pom.getModel().getProperties())
+ .setKey(key)
+ .setVersion(pom.getVersion())
+ .setName(pom.getName())
+ .setDescription(pom.getDescription())
+ .addContainerExtension(pom);
guessJavaVersion(pom, definition);
guessEncoding(pom, definition);
convertMavenLinksToProperties(definition, pom);
synchronizeFileSystem(pom, definition);
- return definition;
+ }
+
+ public static String getSonarKey(MavenProject pom) {
+ return new StringBuilder().append(pom.getGroupId()).append(":").append(pom.getArtifactId()).toString();
}
private static void guessEncoding(MavenProject pom, ProjectDefinition definition) {
- //See http://jira.codehaus.org/browse/SONAR-2151
+ // See http://jira.codehaus.org/browse/SONAR-2151
String encoding = MavenUtils.getSourceEncoding(pom);
if (encoding != null) {
definition.setProperty(CoreProperties.ENCODING_PROPERTY, encoding);
public static void synchronizeFileSystem(MavenProject pom, ProjectDefinition into) {
into.setBaseDir(pom.getBasedir());
- File buildDir = resolvePath(pom.getBuild().getDirectory(), pom.getBasedir());
+ File buildDir = getBuildDir(pom);
if (buildDir != null) {
into.setBuildDir(buildDir);
- into.setWorkDir(new File(buildDir, "sonar"));
+ into.setWorkDir(getSonarWorkDir(pom));
}
- into.setSourceDirs((String[]) pom.getCompileSourceRoots().toArray(new String[pom.getCompileSourceRoots().size()]));
- into.setTestDirs((String[]) pom.getTestCompileSourceRoots().toArray(new String[pom.getTestCompileSourceRoots().size()]));
+ List<String> filteredCompileSourceRoots = filterExisting(pom.getCompileSourceRoots(), pom.getBasedir());
+ List<String> filteredTestCompileSourceRoots = filterExisting(pom.getTestCompileSourceRoots(), pom.getBasedir());
+ into.setSourceDirs((String[]) filteredCompileSourceRoots.toArray(new String[filteredCompileSourceRoots.size()]));
+ into.setTestDirs((String[]) filteredTestCompileSourceRoots.toArray(new String[filteredTestCompileSourceRoots.size()]));
File binaryDir = resolvePath(pom.getBuild().getOutputDirectory(), pom.getBasedir());
if (binaryDir != null) {
into.addBinaryDir(binaryDir);
}
}
+ public static File getSonarWorkDir(MavenProject pom) {
+ return new File(getBuildDir(pom), "sonar");
+ }
+
+ private static File getBuildDir(MavenProject pom) {
+ return resolvePath(pom.getBuild().getDirectory(), pom.getBasedir());
+ }
+
+ private static List<String> filterExisting(List<String> filePaths, final File baseDir) {
+ return Lists.newArrayList(Collections2.filter(filePaths, new Predicate<String>() {
+ @Override
+ public boolean apply(String filePath) {
+ File file = resolvePath(filePath, baseDir);
+ return file != null && file.exists();
+ }
+ }));
+ }
+
public static void synchronizeFileSystem(MavenProject pom, DefaultModuleFileSystem into) {
into.resetDirs(
- pom.getBasedir(),
- resolvePath(pom.getBuild().getDirectory(), pom.getBasedir()),
- resolvePaths((List<String>) pom.getCompileSourceRoots(), pom.getBasedir()),
- resolvePaths((List<String>) pom.getTestCompileSourceRoots(), pom.getBasedir()),
- Arrays.asList(resolvePath(pom.getBuild().getOutputDirectory(), pom.getBasedir()))
- );
+ pom.getBasedir(),
+ getBuildDir(pom),
+ resolvePaths((List<String>) pom.getCompileSourceRoots(), pom.getBasedir()),
+ resolvePaths((List<String>) pom.getTestCompileSourceRoots(), pom.getBasedir()),
+ Arrays.asList(resolvePath(pom.getBuild().getOutputDirectory(), pom.getBasedir()))
+ );
}
static File resolvePath(String path, File basedir) {
package org.sonar.batch.bootstrapper;
import com.google.common.collect.Maps;
-import org.hamcrest.core.Is;
import org.junit.Test;
import java.util.Map;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
public class LoggingConfigurationTest {
@Test
public void testSqlLevel() {
- assertThat(LoggingConfiguration.create().setShowSql(true)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_SQL_VERBOSE));
+ assertThat(LoggingConfiguration.create(null).setShowSql(true)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_SQL_VERBOSE);
- assertThat(LoggingConfiguration.create().setShowSql(false)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_SQL_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setShowSql(false)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_SQL_DEFAULT);
- assertThat(LoggingConfiguration.create().setSqlLevel("ERROR")
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL), Is.is("ERROR"));
+ assertThat(LoggingConfiguration.create(null).setSqlLevel("ERROR")
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL)).isEqualTo("ERROR");
}
@Test
public void shouldNotShowSqlByDefault() {
- assertThat(LoggingConfiguration.create()
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_SQL_DEFAULT));
+ assertThat(LoggingConfiguration.create(null)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_SQL_DEFAULT);
}
@Test
public void testSetVerbose() {
- assertThat(LoggingConfiguration.create().setVerbose(true)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_ROOT_VERBOSE));
+ assertThat(LoggingConfiguration.create(null).setVerbose(true)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_ROOT_VERBOSE);
- assertThat(LoggingConfiguration.create().setVerbose(false)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_ROOT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setVerbose(false)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_ROOT_DEFAULT);
- assertThat(LoggingConfiguration.create().setRootLevel("ERROR")
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL), Is.is("ERROR"));
+ assertThat(LoggingConfiguration.create(null).setRootLevel("ERROR")
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL)).isEqualTo("ERROR");
}
@Test
public void shouldNotBeVerboseByDefault() {
- assertThat(LoggingConfiguration.create()
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_ROOT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_ROOT_DEFAULT);
}
@Test
public void testSetVerboseProperty() {
Map<String, String> properties = Maps.newHashMap();
- assertThat(LoggingConfiguration.create().setProperties(properties)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_ROOT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setProperties(properties)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_ROOT_DEFAULT);
properties.put("sonar.verbose", "true");
- assertThat(LoggingConfiguration.create().setProperties(properties)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_ROOT_VERBOSE));
+ assertThat(LoggingConfiguration.create(null).setProperties(properties)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_ROOT_VERBOSE);
properties.put("sonar.verbose", "false");
- assertThat(LoggingConfiguration.create().setProperties(properties)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_ROOT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setProperties(properties)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_ROOT_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_ROOT_DEFAULT);
}
@Test
public void testSetShowSqlProperty() {
Map<String, String> properties = Maps.newHashMap();
- assertThat(LoggingConfiguration.create().setProperties(properties)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_SQL_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setProperties(properties)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_SQL_DEFAULT);
properties.put("sonar.showSql", "true");
- assertThat(LoggingConfiguration.create().setProperties(properties)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_SQL_VERBOSE));
+ assertThat(LoggingConfiguration.create(null).setProperties(properties)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_SQL_VERBOSE);
properties.put("sonar.showSql", "false");
- assertThat(LoggingConfiguration.create().setProperties(properties)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL), Is.is(LoggingConfiguration.LEVEL_SQL_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setProperties(properties)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_SQL_LOGGER_LEVEL)).isEqualTo(LoggingConfiguration.LEVEL_SQL_DEFAULT);
}
@Test
public void testDefaultFormat() {
- assertThat(LoggingConfiguration.create()
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT), Is.is(LoggingConfiguration.FORMAT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT)).isEqualTo(LoggingConfiguration.FORMAT_DEFAULT);
+ }
+
+ @Test
+ public void testMavenFormat() {
+ assertThat(LoggingConfiguration.create(new EnvironmentInformation("maven", "1.0"))
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT)).isEqualTo(LoggingConfiguration.FORMAT_MAVEN);
}
@Test
public void testSetFormat() {
- assertThat(LoggingConfiguration.create().setFormat("%d %level")
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT), Is.is("%d %level"));
+ assertThat(LoggingConfiguration.create(null).setFormat("%d %level")
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT)).isEqualTo("%d %level");
}
@Test
public void shouldNotSetBlankFormat() {
- assertThat(LoggingConfiguration.create().setFormat(null)
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT), Is.is(LoggingConfiguration.FORMAT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setFormat(null)
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT)).isEqualTo(LoggingConfiguration.FORMAT_DEFAULT);
- assertThat(LoggingConfiguration.create().setFormat("")
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT), Is.is(LoggingConfiguration.FORMAT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setFormat("")
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT)).isEqualTo(LoggingConfiguration.FORMAT_DEFAULT);
- assertThat(LoggingConfiguration.create().setFormat(" ")
- .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT), Is.is(LoggingConfiguration.FORMAT_DEFAULT));
+ assertThat(LoggingConfiguration.create(null).setFormat(" ")
+ .getSubstitutionVariable(LoggingConfiguration.PROPERTY_FORMAT)).isEqualTo(LoggingConfiguration.FORMAT_DEFAULT);
}
}
pom.setDescription("just test");
pom.setFile(new File("/foo/pom.xml"));
pom.getBuild().setDirectory("target");
- ProjectDefinition project = MavenProjectConverter.convert(pom);
+ ProjectDefinition project = ProjectDefinition.create();
+ MavenProjectConverter.merge(pom, project);
Properties properties = project.getProperties();
assertThat(properties.getProperty(CoreProperties.PROJECT_KEY_PROPERTY), is("foo:bar"));
<dependency>
<groupId>org.apache.maven.shared</groupId>
<artifactId>maven-dependency-tree</artifactId>
- <version>1.2</version>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.sonar.runner</groupId>
+ <artifactId>sonar-runner-api</artifactId>
+ <version>2.2.2</version>
</dependency>
<dependency>
<groupId>org.codehaus.sonar</groupId>
--- /dev/null
+package org.sonar.maven;
+
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.project.MavenProject;
+import org.sonar.api.batch.bootstrap.ProjectBuilder;
+import org.sonar.api.batch.bootstrap.ProjectBuilderContext;
+import org.sonar.batch.scan.maven.MavenProjectConverter;
+
+import java.util.List;
+
+public class SonarMaven2ProjectBuilder extends ProjectBuilder {
+
+ private MavenSession session;
+
+ public SonarMaven2ProjectBuilder(MavenSession session) {
+ this.session = session;
+ }
+
+ @Override
+ public void build(ProjectBuilderContext context) {
+ List<MavenProject> sortedProjects = session.getSortedProjects();
+ MavenProject topLevelProject = null;
+ for (MavenProject project : sortedProjects) {
+ if (project.isExecutionRoot()) {
+ topLevelProject = project;
+ break;
+ }
+ }
+ MavenProjectConverter.configure(context.getProjectReactor().getRoot(), sortedProjects, topLevelProject);
+ }
+
+}
*/
package org.sonar.maven;
-import com.google.common.collect.Maps;
+import org.apache.commons.lang.ObjectUtils;
+import org.apache.commons.lang.StringUtils;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectBuilder;
import org.apache.maven.shared.dependency.tree.DependencyTreeBuilder;
-import org.sonar.api.batch.bootstrap.ProjectDefinition;
-import org.sonar.api.batch.bootstrap.ProjectReactor;
+import org.sonar.api.batch.maven.MavenUtils;
import org.sonar.batch.scan.maven.MavenProjectConverter;
-import org.sonar.batch.bootstrapper.Batch;
-import org.sonar.batch.bootstrapper.EnvironmentInformation;
-import org.sonar.batch.bootstrapper.LoggingConfiguration;
+import org.sonar.runner.api.EmbeddedRunner;
+import org.sonar.runner.api.RunnerProperties;
+import org.sonar.runner.api.ScanProperties;
+
+import java.util.Map.Entry;
+import java.util.Set;
/**
* @goal sonar
private RuntimeInformation runtimeInformation;
public void execute() throws MojoExecutionException, MojoFailureException {
- ProjectDefinition def = MavenProjectConverter.convert(session.getSortedProjects(), project);
- ProjectReactor reactor = new ProjectReactor(def);
-
- Batch batch = Batch.builder()
- .setEnvironment(getEnvironmentInformation())
- .setProjectReactor(reactor)
- .addComponents(
- session, getLog(), lifecycleExecutor, pluginManager, artifactFactory,
- localRepository, artifactMetadataSource, artifactCollector, dependencyTreeBuilder,
- projectBuilder, Maven2PluginExecutor.class)
- .build();
-
- configureLogging(batch.getLoggingConfiguration());
- batch.execute();
- }
- private void configureLogging(LoggingConfiguration logging) {
- logging.setProperties(Maps.fromProperties(session.getExecutionProperties()));
- logging.setFormat(LoggingConfiguration.FORMAT_MAVEN);
+ EmbeddedRunner runner = EmbeddedRunner.create()
+ .setApp("Maven", getMavenVersion());
+ // Workaround for SONARPLUGINS-2947
+ // TODO remove when it will be fixed
+ runner.setProperty("sonarRunner.userAgent", "Maven");
+ runner.setProperty("sonarRunner.userAgentVersion", getMavenVersion());
+ Set<Entry<Object, Object>> properties = project.getModel().getProperties().entrySet();
+ for (Entry<Object, Object> entry : properties) {
+ runner.setProperty(ObjectUtils.toString(entry.getKey()), ObjectUtils.toString(entry.getValue()));
+ }
+ String encoding = MavenUtils.getSourceEncoding(project);
+ if (encoding != null) {
+ runner.setProperty(ScanProperties.PROJECT_SOURCE_ENCODING, encoding);
+ }
+ runner.setProperty(ScanProperties.PROJECT_KEY, MavenProjectConverter.getSonarKey(project))
+ .setProperty(RunnerProperties.WORK_DIR, MavenProjectConverter.getSonarWorkDir(project).getAbsolutePath())
+ .setProperty(ScanProperties.PROJECT_BASEDIR, project.getBasedir().getAbsolutePath())
+ .setProperty(ScanProperties.PROJECT_VERSION, StringUtils.defaultString(project.getVersion()))
+ .setProperty(ScanProperties.PROJECT_NAME, StringUtils.defaultString(project.getName()))
+ .setProperty(ScanProperties.PROJECT_DESCRIPTION, StringUtils.defaultString(project.getDescription()))
+ .setProperty(ScanProperties.PROJECT_SOURCE_DIRS, ".")
+ // Required to share ProjectBuilder extension between SonarMavenProjectBuilder and Sonar classloader
+ .setUnmaskedPackages("org.sonar.api.batch.bootstrap")
+ .addExtensions(session, getLog(), lifecycleExecutor, artifactFactory, localRepository, artifactMetadataSource, artifactCollector,
+ dependencyTreeBuilder, projectBuilder, Maven2PluginExecutor.class, new SonarMaven2ProjectBuilder(session));
if (getLog().isDebugEnabled()) {
- logging.setVerbose(true);
+ runner.setProperty("sonar.verbose", "true");
}
+ runner.execute();
}
- private EnvironmentInformation getEnvironmentInformation() {
- String mavenVersion = runtimeInformation.getApplicationVersion().toString();
- return new EnvironmentInformation("Maven", mavenVersion);
+ private String getMavenVersion() {
+ return runtimeInformation.getApplicationVersion().toString();
}
}
<dependency>
<groupId>org.apache.maven.shared</groupId>
<artifactId>maven-dependency-tree</artifactId>
- <version>1.2</version>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.sonar.runner</groupId>
+ <artifactId>sonar-runner-api</artifactId>
+ <version>2.2.2</version>
</dependency>
<dependency>
<groupId>org.codehaus.sonar</groupId>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</dependency>
- <dependency>
- <groupId>ch.qos.logback</groupId>
- <artifactId>logback-classic</artifactId>
- </dependency>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-plugin-api</artifactId>
--- /dev/null
+package org.sonar.maven3;
+
+import org.apache.maven.execution.MavenSession;
+import org.sonar.api.batch.bootstrap.ProjectBuilder;
+import org.sonar.api.batch.bootstrap.ProjectBuilderContext;
+import org.sonar.batch.scan.maven.MavenProjectConverter;
+
+public class SonarMaven3ProjectBuilder extends ProjectBuilder {
+
+ private MavenSession session;
+
+ public SonarMaven3ProjectBuilder(MavenSession session) {
+ this.session = session;
+ }
+
+ @Override
+ public void build(ProjectBuilderContext context) {
+ MavenProjectConverter.configure(context.getProjectReactor().getRoot(), session.getProjects(), session.getTopLevelProject());
+ }
+
+}
*/
package org.sonar.maven3;
-import com.google.common.collect.Maps;
+import org.apache.commons.lang.ObjectUtils;
+import org.apache.commons.lang.StringUtils;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectBuilder;
import org.apache.maven.shared.dependency.tree.DependencyTreeBuilder;
-import org.sonar.api.batch.bootstrap.ProjectDefinition;
-import org.sonar.api.batch.bootstrap.ProjectReactor;
+import org.sonar.api.batch.maven.MavenUtils;
import org.sonar.batch.scan.maven.MavenProjectConverter;
-import org.sonar.batch.bootstrapper.Batch;
-import org.sonar.batch.bootstrapper.EnvironmentInformation;
-import org.sonar.batch.bootstrapper.LoggingConfiguration;
+import org.sonar.runner.api.EmbeddedRunner;
+import org.sonar.runner.api.RunnerProperties;
+import org.sonar.runner.api.ScanProperties;
+
+import java.util.Map.Entry;
+import java.util.Set;
/**
* @goal sonar
private RuntimeInformation runtimeInformation;
public void execute() throws MojoExecutionException, MojoFailureException {
- ProjectDefinition def = MavenProjectConverter.convert(session.getProjects(), project);
- ProjectReactor reactor = new ProjectReactor(def);
-
- Batch batch = Batch.builder()
- .setEnvironment(getEnvironmentInformation())
- .setProjectReactor(reactor)
- .addComponents(
- session, getLog(), lifecycleExecutor, artifactFactory, localRepository, artifactMetadataSource, artifactCollector,
- dependencyTreeBuilder, projectBuilder, Maven3PluginExecutor.class)
- .build();
-
- configureLogging(batch.getLoggingConfiguration());
- batch.execute();
- }
- private void configureLogging(LoggingConfiguration logging) {
- logging.setProperties(Maps.fromProperties(session.getSystemProperties()));
- logging.setFormat(LoggingConfiguration.FORMAT_MAVEN);
+ EmbeddedRunner runner = EmbeddedRunner.create()
+ .setApp("Maven", getMavenVersion());
+ // Workaround for SONARPLUGINS-2947
+ // TODO remove when it will be fixed
+ runner.setProperty("sonarRunner.userAgent", "Maven");
+ runner.setProperty("sonarRunner.userAgentVersion", getMavenVersion());
+ Set<Entry<Object, Object>> properties = project.getModel().getProperties().entrySet();
+ for (Entry<Object, Object> entry : properties) {
+ runner.setProperty(ObjectUtils.toString(entry.getKey()), ObjectUtils.toString(entry.getValue()));
+ }
+ String encoding = MavenUtils.getSourceEncoding(project);
+ if (encoding != null) {
+ runner.setProperty(ScanProperties.PROJECT_SOURCE_ENCODING, encoding);
+ }
+ runner.setProperty(ScanProperties.PROJECT_KEY, MavenProjectConverter.getSonarKey(project))
+ .setProperty(RunnerProperties.WORK_DIR, MavenProjectConverter.getSonarWorkDir(project).getAbsolutePath())
+ .setProperty(ScanProperties.PROJECT_BASEDIR, project.getBasedir().getAbsolutePath())
+ .setProperty(ScanProperties.PROJECT_VERSION, StringUtils.defaultString(project.getVersion()))
+ .setProperty(ScanProperties.PROJECT_NAME, StringUtils.defaultString(project.getName()))
+ .setProperty(ScanProperties.PROJECT_DESCRIPTION, StringUtils.defaultString(project.getDescription()))
+ .setProperty(ScanProperties.PROJECT_SOURCE_DIRS, ".")
+ // Required to share ProjectBuilder extension between SonarMavenProjectBuilder and Sonar classloader
+ .setUnmaskedPackages("org.sonar.api.batch.bootstrap")
+ .addExtensions(session, getLog(), lifecycleExecutor, artifactFactory, localRepository, artifactMetadataSource, artifactCollector,
+ dependencyTreeBuilder, projectBuilder, Maven3PluginExecutor.class, new SonarMaven3ProjectBuilder(session));
if (getLog().isDebugEnabled()) {
- logging.setVerbose(true);
+ runner.setProperty("sonar.verbose", "true");
}
+ runner.execute();
}
- private EnvironmentInformation getEnvironmentInformation() {
- String mavenVersion = runtimeInformation.getApplicationVersion().toString();
- return new EnvironmentInformation("Maven", mavenVersion);
+ private String getMavenVersion() {
+ return runtimeInformation.getApplicationVersion().toString();
}
}
projects / sonarqube.git / commitdiff