Java Code Examples for org.gradle.api.project#container()

public AtlasExtension createExtendsion(Project project, Instantiator instantiator) {

        AtlasExtension atlasExtension = getExtendsion(project);

        if (null != atlasExtension) {
            return atlasExtension;
        }

        final NamedDomainObjectContainer<TBuildType> buildTypeContainer = project.container(TBuildType.class,
                                                                                            new TBuildTypeFactory(
                                                                                                instantiator, project,
                                                                                                project.getLogger()));
        final NamedDomainObjectContainer<PatchConfig> patchConfigContainer = project.container(PatchConfig.class,
                                                                                               new PatchConfigFactory(
                                                                                                   instantiator,
                                                                                                   project, project
                                                                                                       .getLogger()));
        final NamedDomainObjectContainer<DexConfig>dexConfigContainer = project.container(DexConfig.class,new DexConfigFactory(instantiator,project,project.getLogger()));

        return project.getExtensions().create("atlas", AtlasExtension.class, project, instantiator,
                                              buildTypeContainer, patchConfigContainer,dexConfigContainer);

    }
 

public void apply(Project project) {
    NamedDomainObjectContainer<BeanstalkDeployment> deployments = project.container(BeanstalkDeployment.class);
    BeanstalkPluginExtension beanstalk = project.getExtensions().create("beanstalk", BeanstalkPluginExtension.class);
    ((ExtensionAware) beanstalk).getExtensions().add("deployments", deployments);

    project.afterEvaluate(p -> {
        for (BeanstalkDeployment deployment : deployments) {
            String name = deployment.getName();
            String task = "deploy" + Character.toUpperCase(name.charAt(0)) + name.substring(1);

            p.getTasks().create(task, DeployTask.class, deployTask -> {
                deployTask.setBeanstalk(beanstalk);
                deployTask.setDeployment(deployment);
            });
        }
    });
}
 

@Override
public void apply(Project project) {
  checkState(
      project.getParent() == null,
      "gradle-conda-plugin can only be applied to the root project.");

  project.getPlugins().apply(ToolDownloaderPlugin.class);

  condas =
      project.container(
          CondaExtension.class, name -> CondaExtension.create(name, project.getObjects()));
  project.getExtensions().add("conda", condas);

  condas.configureEach(conda -> addCondaTasks(project, conda));
}
 

public ClojureScriptExtension(Project project) {
  this.outputDir = project.getObjects().directoryProperty();
  this.builds = project.container(ClojureScriptBuild.class, name -> {
    ClojureScriptBuild build = new ClojureScriptBuild(project, name);
    build.getOutputDir().set(outputDir.dir(name));
    return build;
  });
}
 

public ClojureExtension(Project project) {
  this.outputDir = project.getObjects().directoryProperty();
  this.builds = project.container(ClojureBuild.class, name -> {
    ClojureBuild build = new ClojureBuild(project, name);
    build.getOutputDir().set(outputDir.dir(name));
    return build;
  });
}
 

public SamplesExtension(Project project) {
    externalRepos = project.container(ExternalRepo.class, name -> {
        return project.getObjects().newInstance(ExternalRepo.class, name);
    });
    samples = project.container(Sample.class, name -> {
        return project.getObjects().newInstance(Sample.class, name);
    });
}
 

@Override
public void apply(Project project) {
    NamedDomainObjectContainer<Jdk> jdksContainer = project.container(
        Jdk.class,
        name -> new Jdk(name, project.getConfigurations().create("jdk_" + name), project.getObjects())
    );
    project.getExtensions().add(EXTENSION_NAME, jdksContainer);

    project.afterEvaluate(p ->
        jdksContainer.all(jdk -> {
            jdk.finalizeValues();
            // depend on the jdk directory "artifact" from the root project
            var dependencies = project.getDependencies();
            Map<String, Object> depConfig = Map.of(
                "path", ":",
                "configuration", configName(
                    "extract",
                    jdk.vendor(),
                    jdk.version(),
                    jdk.platform()));
            dependencies.add(
                jdk.configuration().getName(),
                dependencies.project(depConfig));

            setupRootJdkDownload(project.getRootProject(), jdk);
        })
    );
}
 

@Inject
public AttachConfiguration(Project project) {
    this.project = project;
    this.services = project.container(AttachServiceDefinition.class);
}
 

@Inject
public DownConfiguration(Project project) {
    this.project = project;
    this.plugins = project.container(DownPluginDefinition.class);
}
 

public static NamedDomainObjectContainer<AndroidSourceSet> createSourceSetsContainer(
        @NonNull final Project project,
        @NonNull Instantiator instantiator,
        final boolean isLibrary) {
    NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer = project.container(
            AndroidSourceSet.class,
            new AndroidSourceSetFactory(instantiator, project, isLibrary));

    sourceSetsContainer.whenObjectAdded(new Action<AndroidSourceSet>() {
        @Override
        public void execute(AndroidSourceSet sourceSet) {
            ConfigurationContainer configurations = project.getConfigurations();

            createConfiguration(
                    configurations,
                    sourceSet.getCompileConfigurationName(),
                    "Classpath for compiling the ${sourceSet.name} sources.");

            String packageConfigDescription;
            if (isLibrary) {
                packageConfigDescription
                        = "Classpath only used when publishing '${sourceSet.name}'.";
            } else {
                packageConfigDescription
                        = "Classpath packaged with the compiled '${sourceSet.name}' classes.";
            }
            createConfiguration(
                    configurations,
                    sourceSet.getPackageConfigurationName(),
                    packageConfigDescription);

            createConfiguration(
                    configurations,
                    sourceSet.getProvidedConfigurationName(),
                    "Classpath for only compiling the ${sourceSet.name} sources.");

            createConfiguration(
                    configurations,
                    sourceSet.getWearAppConfigurationName(),
                    "Link to a wear app to embed for object '${sourceSet.name}'.");

            sourceSet.setRoot(String.format("src/%s", sourceSet.getName()));

        }
    });
    return sourceSetsContainer;
}
 

@Override
public void apply(Project project) {
  checkState(
      project.getParent() == null,
      "gradle-tool-downloader-plugin can only be applied to the root project.");

  var platformHelper = new PlatformHelper();

  tools =
      project.container(
          ToolDownloaderExtension.class, name -> ToolDownloaderExtension.create(name, project));
  project.getExtensions().add("tools", tools);

  toolManager = new DownloadedToolManager(project, tools);

  project
      .getExtensions()
      .getByType(ExtraPropertiesExtension.class)
      .set("toolManager", toolManager);

  var downloadAll = project.getTasks().register("toolsDownloadAll");
  var setupAll = project.getTasks().register("toolsSetupAll");

  tools.configureEach(
      tool -> {
        var taskSuffix = TaskUtil.toTaskSuffix(tool.getName());
        var task =
            project
                .getTasks()
                .register(
                    "toolsDownload" + taskSuffix,
                    DownloadToolTask.class,
                    tool,
                    platformHelper,
                    toolManager);
        var setup =
            project
                .getTasks()
                .register("toolsSetup" + taskSuffix, SetupTask.class, tool.getName());
        setup.configure(t -> t.dependsOn(task));
        downloadAll.configure(t -> t.dependsOn(task));
        setupAll.configure(t -> t.dependsOn(setup));
      });
}