Java ModelMap.named方法代码示例

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Create Checkstyle tasks
 *
 * @param tasks Task container
 * @param checkstyleConfig Checkstyle configuration
 * @param sources Source sets
 * @param files
 * @param context
 */
@Finalize
public void configureCheckstyleTasks(ModelMap<Checkstyle> tasks, CheckstyleConfig checkstyleConfig,
        ProjectSourceSet sources, FileOperations files, ProjectContext context) {
    for (JavaSourceSet source : sources.withType(JavaSourceSet.class)) {
        String taskName = getCheckstyleTaskName(source);

        if (!checkstyleConfig.getIgnoreSourceSets().contains(source.getParentName())) {
            tasks.named(taskName, t -> {
                File checkstyleConfigFile = getCheckstyleConfigFile(source.getParentName(), files);

                t.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
                t.setConfigFile(checkstyleConfigFile);

                if (checkstyleConfigFile.getParentFile() != null) {
                    t.setConfigDir(context.provider(() -> checkstyleConfigFile.getParentFile()));
                }

                t.dependsOn(getUpdateConfigTaskName(source));
            });
        }
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
private static <T extends NativeBinarySpec> void createNativeBinary(
    Class<T> type,
    ModelMap<NativeBinarySpec> binaries,
    final NativeDependencyResolver resolver,
    final FileCollectionFactory fileCollectionFactory,
    final BinaryNamingScheme namingScheme,
    final NativePlatform platform,
    final BuildType buildType,
    final Flavor flavor
) {
    final String name = namingScheme.getBinaryName();
    binaries.create(name, type);

    // TODO:REUSE Refactor after removing reuse
    // This is horrendously bad.
    // We need to set the platform, _before_ the @Defaults rules of NativeBinaryRules assign the toolchain.
    // We can't just assign the toolchain here because the initializer would be closing over the toolchain which is not reusable, and this breaks model reuse.
    // So here we are just closing over the safely reusable things and then using proper dependencies for the tool chain registry.
    // Unfortunately, we can't do it in the create action because that would fire _after_ @Defaults rules.
    // We have to use a @Defaults rule to assign the tool chain because it needs to be there in user @Mutate rules
    // Or at least, the file locations do so that they can be tweaked.
    // LD - 5/6/14
    MutableModelNode backingNode = ((ManagedInstance) binaries).getBackingNode();
    ModelPath binaryPath = backingNode.getPath().child(name);
    backingNode.applyToLink(ModelActionRole.Defaults, DirectNodeNoInputsModelAction.of(
        ModelReference.of(binaryPath, NativeBinarySpec.class),
        new SimpleModelRuleDescriptor("initialize binary " + binaryPath),
        new BiAction<MutableModelNode, NativeBinarySpec>() {
            @Override
            public void execute(MutableModelNode mutableModelNode, NativeBinarySpec nativeBinarySpec) {
                initialize(nativeBinarySpec, namingScheme, resolver, fileCollectionFactory, platform, buildType, flavor);
            }
        }
    ));
    binaries.named(name, NativeBinaryRules.class);
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@Mutate
void attachTestSuitesToCheckTask(ModelMap<Task> tasks, @Path("binaries") final ModelMap<PlayApplicationBinarySpec> playBinaries) {
    // TODO - binaries aren't an input to this rule, they're an input to the action
    tasks.named(LifecycleBasePlugin.CHECK_TASK_NAME, new Action<Task>() {
        @Override
        public void execute(Task checkTask) {
            // TODO Need a better mechanism to wire tasks into lifecycle
            for (PlayApplicationBinarySpec binary : playBinaries) {
                checkTask.dependsOn(binary.getTasks().withType(Test.class));
            }
        }
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Create task to update readme file from template
 *
 * @param tasks Task container to create new tasks
 * @param projectConfig Project configuration
 * @param projectContext Project context
 * @param extensions Extension container
 */
@Mutate
public void createReadmeUpdateTasks(ModelMap<Task> tasks, ProjectConfig projectConfig,
        ProjectContext projectContext, ExtensionContainer extensions) {
    // Create task to update the README
    Map<String, Object> context = new HashMap<>();

    extensions.getExtraProperties().getProperties().forEach((name, value) -> {
        context.put(name, value);
    });

    context.put("project", projectContext);
    context.put("projectConfig", projectConfig);

    tasks.create("readmeUpdate", Copy.class, t -> {
        t.setDescription("Update README from template.");
        t.setGroup("documentation");
        t.from("src/doc/templates");
        t.include("README.template.md");
        t.rename(n -> n.replace(".template.", "."));
        t.expand(context);

        ConventionMapping parameters = t.getConventionMapping();
        parameters.map("destinationDir", () -> projectContext.getProjectDir());
    });

    tasks.named("assemble", t -> {
        t.dependsOn("readmeUpdate");
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Finalize tasks because of {@link JavaPlugin} interference
 *
 * @param tasks Task model
 * @param javaConvention Java conventions
 */
@Finalize
public void finalizeIntegrationTask(ModelMap<Test> tasks, JavaPluginConvention javaConvention) {
    SourceSet source = javaConvention.getSourceSets().getByName(INTEGRATION_SOURCE_SET_NAME);

    tasks.named(INTEGRATION_SOURCE_SET_NAME, t -> {
        t.setClasspath(source.getRuntimeClasspath());
        t.setTestClassesDirs(source.getOutput().getClassesDirs());
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Configure the check task
 *
 * @param tasks Tasks
 */
@Mutate
public void configureCheckTask(ModelMap<Task> tasks) {
    tasks.named(JavaBasePlugin.CHECK_TASK_NAME, t -> {
        t.dependsOn(INTEGRATION_TASK_NAME);
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Create tasks to update Checkstyle configuration
 *
 * @param tasks Task container
 * @param sources Source sets to add tasks for
 * @param files File operations object to resolve file names
 */
@Mutate
public void createUpdateTasks(ModelMap<Task> tasks, ProjectSourceSet sources, FileOperations files) {
    tasks.create(CONFIGURE_CHECKSTYLE_TASK_NAME, Task.class, t -> {
        t.setDescription("Update checkstyle configuration");
        t.setGroup("Build Setup");
    });

    for (JavaSourceSet source : sources.withType(JavaSourceSet.class)) {
        File configFile = getCheckstyleConfigFile(source.getParentName(), files);
        String resourceName = "checkstyle_" + source.getParentName() + ".xml";

        String config = Classes.getResourceString(CheckstyleConfigPlugin.class, resourceName).orElseGet(
                () -> Classes.getResourceString(CheckstyleConfigPlugin.class, "checkstyle.xml").get());

        String taskName = getUpdateConfigTaskName(source);

        tasks.create(taskName, CheckstyleConfigUpdate.class, t -> {
            t.setDescription(String.format("Update checkstyle configuration for source set '%s'",
                    source.getParentName()));
            t.setGroup("Build Setup");
            t.setConfig(config);
            t.setConfigFile(configFile);
        });

        tasks.named(getCheckstyleTaskName(source), t -> {
            t.dependsOn(taskName);
        });

        tasks.named(CONFIGURE_CHECKSTYLE_TASK_NAME, t -> {
            t.dependsOn(taskName);
        });
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Configure the 'eclipse' task
 *
 * @param tasks Task container to manage tasks
 * @param eclipseModel Eclipse configuration to create dependency
 */
@Mutate
public void configureEclipseTasks(ModelMap<Task> tasks, EclipseModel eclipseModel) {
    tasks.named(EclipsePlugin.ECLIPSE_TASK_NAME, t -> {
        t.dependsOn(ECLIPSE_CHECKSTYLE_TASK_NAME);
    });

    tasks.named(Tasks.cleanName(Validate.notNull(EclipsePlugin.ECLIPSE_TASK_NAME)), t -> {
        t.dependsOn(Tasks.cleanName(ECLIPSE_CHECKSTYLE_TASK_NAME));
    });
}