示例#1
0
 /** Creates the configurations used by plugin. */
 private void addJacocoConfigurations() {
   Configuration agentConf = project.getConfigurations().create(AGENT_CONFIGURATION_NAME);
   agentConf.setVisible(false);
   agentConf.setTransitive(true);
   agentConf.setDescription("The Jacoco agent to use to get coverage data.");
   Configuration antConf = project.getConfigurations().create(ANT_CONFIGURATION_NAME);
   antConf.setVisible(false);
   antConf.setTransitive(true);
   antConf.setDescription("The Jacoco ant tasks to use to get execute Gradle tasks.");
 }
  private ModuleDescriptor findProject(DependencyDescriptor descriptor) {
    String projectPathValue = descriptor.getAttribute(DependencyDescriptorFactory.PROJECT_PATH_KEY);
    if (projectPathValue == null) {
      return null;
    }
    Project project = gradle.getRootProject().project(projectPathValue);
    Module projectModule = ((ProjectInternal) project).getModule();
    ModuleDescriptor projectDescriptor =
        moduleDescriptorConverter.convert(
            project.getConfigurations().getAll(),
            projectModule,
            IvyContext.getContext().getIvy().getSettings());

    for (DependencyArtifactDescriptor artifactDescriptor : descriptor.getAllDependencyArtifacts()) {
      for (Artifact artifact : projectDescriptor.getAllArtifacts()) {
        if (artifact.getName().equals(artifactDescriptor.getName())
            && artifact.getExt().equals(artifactDescriptor.getExt())) {
          String path =
              artifact.getExtraAttribute(DefaultIvyDependencyPublisher.FILE_PATH_EXTRA_ATTRIBUTE);
          ReflectionUtil.invoke(
              artifactDescriptor,
              "setExtraAttribute",
              new Object[] {DefaultIvyDependencyPublisher.FILE_PATH_EXTRA_ATTRIBUTE, path});
        }
      }
    }

    return projectDescriptor;
  }
示例#3
0
 public void apply(String taskName) {
   for (Configuration configuration : project.getConfigurations()) {
     if (taskName.equals(configuration.getUploadTaskName())) {
       createUploadTask(configuration.getUploadTaskName(), configuration, project);
     }
   }
 }
 private void addArtifacts(Project project, List<GradleFileBuildOutcome> outcomes) {
   Configuration configuration = project.getConfigurations().findByName("archives");
   if (configuration != null) {
     for (PublishArtifact artifact : configuration.getArtifacts()) {
       GradleFileBuildOutcome outcome = artifactTransformer.transform(artifact, project);
       outcomes.add(outcome);
     }
   }
 }
示例#5
0
  // @Todo: refactor this task configuration to extend a copy task and use replace tokens
  private void addCreateScriptsTask() {
    CreateStartScripts startScripts =
        project.getTasks().create(TASK_START_SCRIPTS_NAME, CreateStartScripts.class);
    startScripts.setDescription(
        "Creates OS specific scripts to run the project as a JVM application.");
    startScripts.setClasspath(
        project
            .getTasks()
            .getAt(JavaPlugin.JAR_TASK_NAME)
            .getOutputs()
            .getFiles()
            .plus(project.getConfigurations().getByName("runtime")));

    startScripts
        .getConventionMapping()
        .map(
            "mainClassName",
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                return pluginConvention.getMainClassName();
              }
            });

    startScripts
        .getConventionMapping()
        .map(
            "applicationName",
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                return pluginConvention.getApplicationName();
              }
            });

    startScripts
        .getConventionMapping()
        .map(
            "outputDir",
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                return new File(project.getBuildDir(), "scripts");
              }
            });

    startScripts
        .getConventionMapping()
        .map(
            "defaultJvmOpts",
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                return pluginConvention.getApplicationDefaultJvmArgs();
              }
            });
  }
示例#6
0
  public void apply(Project project) {
    JavaBasePlugin javaBasePlugin = project.getPlugins().apply(JavaBasePlugin.class);

    project
        .getConfigurations()
        .add(GROOVY_CONFIGURATION_NAME)
        .setVisible(false)
        .setTransitive(false)
        .setDescription("The groovy libraries to be used for this Groovy project.");

    configureCompileDefaults(project);
    configureSourceSetDefaults(project, javaBasePlugin);

    configureGroovydoc(project);
  }
示例#7
0
 /**
  * Configures the agent dependencies using the 'jacocoAnt' configuration. Uses the version
  * declared in 'toolVersion' of the Jacoco extension if no dependencies are explicitly declared.
  *
  * @param extension the extension that has the tool version to use
  */
 private void configureAgentDependencies(
     JacocoAgentJar jacocoAgentJar, final JacocoPluginExtension extension) {
   Configuration config = project.getConfigurations().getAt(AGENT_CONFIGURATION_NAME);
   ((IConventionAware) jacocoAgentJar)
       .getConventionMapping()
       .map("agentConf", Callables.returning(config));
   config.defaultDependencies(
       new Action<DependencySet>() {
         @Override
         public void execute(DependencySet dependencies) {
           dependencies.add(
               project
                   .getDependencies()
                   .create("org.jacoco:org.jacoco.agent:" + extension.getToolVersion()));
         }
       });
 }
示例#8
0
 /**
  * @param project the project on which we'll call {@link Project#javaexec(Action)}.
  * @param input the JavaExecable which we'll take as input and call run() on.
  * @param settings any extra settings you'd like to set on the JavaExec (e.g. heap)
  * @return the JavaExecable after it has had run() called.
  */
 public static <T extends JavaExecable> T exec(
     Project project, T input, Action<JavaExecSpec> settings) throws Throwable {
   // copy the classpath from the project's buildscript (and its parents)
   List<FileCollection> classpaths =
       TreeStream.toParent(ProjectPlugin.treeDef(), project)
           .map(p -> p.getBuildscript().getConfigurations().getByName(BUILDSCRIPT_CLASSPATH))
           .collect(Collectors.toList());
   // add the gradleApi, workaround from
   // https://discuss.gradle.org/t/gradle-doesnt-add-the-same-dependencies-to-classpath-when-applying-plugins/9759/6?u=ned_twigg
   classpaths.add(
       project.getConfigurations().detachedConfiguration(project.getDependencies().gradleApi()));
   // add stuff from the local classloader too, to fix testkit's classpath
   classpaths.add(JavaExecableImp.fromLocalClassloader());
   // run it
   FileCollection classpath = new UnionFileCollection(classpaths);
   return JavaExecableImp.execInternal(
       input, classpath, settings, execSpec -> JavaExecWinFriendly.javaExec(project, execSpec));
 }
示例#9
0
  private CopySpec configureDistSpec(CopySpec distSpec) {
    Task jar = project.getTasks().getAt(JavaPlugin.JAR_TASK_NAME);
    Task startScripts = project.getTasks().getAt(TASK_START_SCRIPTS_NAME);

    CopySpec libChildSpec = project.copySpec();
    libChildSpec.into("lib");
    libChildSpec.from(jar);
    libChildSpec.from(project.getConfigurations().getByName("runtime"));

    CopySpec binChildSpec = project.copySpec();
    binChildSpec.into("bin");
    binChildSpec.from(startScripts);
    binChildSpec.setFileMode(0755);

    CopySpec childSpec = project.copySpec();
    childSpec.from(project.file("src/dist"));
    childSpec.with(libChildSpec);
    childSpec.with(binChildSpec);

    distSpec.with(childSpec);

    distSpec.with(pluginConvention.getApplicationDistribution());
    return distSpec;
  }
  @Nullable
  @Override
  public Object buildAll(final String modelName, final Project project) {
    final List<IdeaDependency> dependencies = new ArrayList<IdeaDependency>();

    final Map<DependencyVersionId, Scopes> scopesMap =
        new LinkedHashMap<DependencyVersionId, Scopes>();
    final IdeDependenciesExtractor dependenciesExtractor = new IdeDependenciesExtractor();

    boolean offline = false;
    boolean downloadJavadoc = false;
    boolean downloadSources = true;

    final IdeaPlugin ideaPlugin = project.getPlugins().getPlugin(IdeaPlugin.class);
    Map<String, Map<String, Collection<Configuration>>> userScopes = Collections.emptyMap();
    if (ideaPlugin != null) {
      IdeaModel ideaModel = ideaPlugin.getModel();
      if (ideaModel != null && ideaModel.getModule() != null) {
        offline = ideaModel.getModule().isOffline();
        downloadJavadoc = ideaModel.getModule().isDownloadJavadoc();
        downloadSources = ideaModel.getModule().isDownloadSources();
        userScopes = ideaModel.getModule().getScopes();
      }
    }

    for (final Configuration configuration : project.getConfigurations()) {
      Collection<Configuration> plusConfigurations = new ArrayList<Configuration>();
      plusConfigurations.add(configuration);

      final Collection<IdeProjectDependency> ideProjectDependencies =
          dependenciesExtractor.extractProjectDependencies(
              project, plusConfigurations, new ArrayList<Configuration>());

      for (IdeProjectDependency ideProjectDependency : ideProjectDependencies) {
        merge(scopesMap, ideProjectDependency, userScopes);
      }

      if (!offline) {
        final Collection<IdeExtendedRepoFileDependency> ideRepoFileDependencies =
            dependenciesExtractor.extractRepoFileDependencies(
                project.getConfigurations(),
                plusConfigurations,
                new ArrayList<Configuration>(),
                downloadSources,
                downloadJavadoc);
        for (IdeExtendedRepoFileDependency repoFileDependency : ideRepoFileDependencies) {
          merge(scopesMap, repoFileDependency, userScopes);
        }
      }

      final Collection<IdeLocalFileDependency> ideLocalFileDependencies =
          dependenciesExtractor.extractLocalFileDependencies(
              plusConfigurations, new ArrayList<Configuration>());
      for (IdeLocalFileDependency fileDependency : ideLocalFileDependencies) {
        merge(scopesMap, fileDependency, userScopes);
      }
    }

    for (Map.Entry<DependencyVersionId, Scopes> entry : scopesMap.entrySet()) {
      DependencyVersionId versionId = entry.getKey();
      for (GradleDependencyScope scope : entry.getValue().getScopes()) {
        if (versionId.getIdeDependency() instanceof IdeExtendedRepoFileDependency) {
          IdeExtendedRepoFileDependency repoFileDependency =
              (IdeExtendedRepoFileDependency) versionId.getIdeDependency();
          IdeaSingleEntryLibraryDependencyImpl libraryDependency =
              new IdeaSingleEntryLibraryDependencyImpl(
                  new IdeaDependencyScopeImpl(scope),
                  versionId.getName(),
                  versionId.getGroup(),
                  versionId.getVersion(),
                  versionId.getClassifier());
          libraryDependency.setFile(repoFileDependency.getFile());
          libraryDependency.setSource(repoFileDependency.getSourceFile());
          libraryDependency.setJavadoc(repoFileDependency.getJavadocFile());
          dependencies.add(libraryDependency);
        } else if (versionId.getIdeDependency() instanceof IdeProjectDependency) {
          IdeProjectDependency projectDependency =
              (IdeProjectDependency) versionId.getIdeDependency();

          String ideaModuleName = findDeDuplicatedModuleName(projectDependency.getProject());
          if (ideaModuleName == null) {
            ideaModuleName = versionId.getName();
          }

          IdeaModuleDependencyImpl moduleDependency =
              new IdeaModuleDependencyImpl(
                  new IdeaDependencyScopeImpl(scope),
                  ideaModuleName,
                  versionId.getGroup(),
                  versionId.getVersion(),
                  versionId.getClassifier());
          moduleDependency.setIdeaModule(new StubIdeaModule(ideaModuleName));
          dependencies.add(moduleDependency);
        } else if (versionId.getIdeDependency() instanceof IdeLocalFileDependency) {
          IdeLocalFileDependency fileDependency =
              (IdeLocalFileDependency) versionId.getIdeDependency();
          IdeaSingleEntryLibraryDependencyImpl libraryDependency =
              new IdeaSingleEntryLibraryDependencyImpl(
                  new IdeaDependencyScopeImpl(scope),
                  versionId.getName(),
                  versionId.getGroup(),
                  versionId.getVersion(),
                  versionId.getClassifier());
          libraryDependency.setFile(fileDependency.getFile());
          attachGradleSdkSources(libraryDependency, fileDependency);
          dependencies.add(libraryDependency);
        }
      }
    }

    return new ProjectDependenciesModelImpl(project.getPath(), dependencies);
  }