Java Examples for org.gradle.api.Task

@Override
public void apply(final Project project) {
    project.getPlugins().apply(BasePlugin.class);
    // Add "haxe" extension
    final HaxeExtension extension = project.getExtensions().create("haxe", HaxeExtension.class, project, instantiator);
    final ProjectSourceSet projectSourceSet = extension.getSources();
    // Add functional source sets for main code
    final FunctionalSourceSet main = projectSourceSet.maybeCreate("main");
    final FunctionalSourceSet test = projectSourceSet.maybeCreate("test");
    logger.debug("Created {} and {} in {}", main, test, project.getPath());
    final Configuration mainCompile = maybeCreateCompileConfigurationFor(project, "main");
    final Configuration testCompile = maybeCreateCompileConfigurationFor(project, "test");
    testCompile.extendsFrom(mainCompile);
    logger.debug("Created {} and {} in {}", mainCompile, testCompile, project.getPath());
    // For each source set create a configuration and language source sets
    projectSourceSet.all(new Action<FunctionalSourceSet>() {

        @Override
        public void execute(FunctionalSourceSet functionalSourceSet) {
            // Inspired by JavaBasePlugin
            // Add Haxe source set for "src/<name>/haxe"
            Configuration compileConfiguration = project.getConfigurations().getByName(functionalSourceSet.getName());
            DefaultHaxeSourceSet haxeSourceSet = instantiator.newInstance(DefaultHaxeSourceSet.class, HAXE_SOURCE_SET_NAME, functionalSourceSet, compileConfiguration, fileResolver);
            haxeSourceSet.getSource().srcDir(String.format("src/%s/haxe", functionalSourceSet.getName()));
            functionalSourceSet.add(haxeSourceSet);
            logger.debug("Added {} in {}", haxeSourceSet, project.getPath());
            // Add resources if not exists yet
            if (functionalSourceSet.findByName(RESOURCE_SET_NAME) == null) {
                DefaultSourceDirectorySet resourcesDirectorySet = instantiator.newInstance(DefaultSourceDirectorySet.class, String.format("%s resources", functionalSourceSet.getName()), fileResolver, new DefaultDirectoryFileTreeFactory());
                resourcesDirectorySet.srcDir(String.format("src/%s/resources", functionalSourceSet.getName()));
                DefaultResourceSet resourceSet = instantiator.newInstance(DefaultResourceSet.class, RESOURCE_SET_NAME, resourcesDirectorySet, functionalSourceSet);
                functionalSourceSet.add(resourceSet);
                logger.debug("Added {} in {}", resourceSet, project.getPath());
            }
            // Add Haxe resource set to be used for embedded resources
            DefaultHaxeResourceSet haxeResourceSet = instantiator.newInstance(DefaultHaxeResourceSet.class, HAXE_RESOURCE_SET_NAME, functionalSourceSet, fileResolver);
            functionalSourceSet.add(haxeResourceSet);
            logger.debug("Added {} in {}", haxeResourceSet, project.getPath());
        }
    });
    NamedDomainObjectContainer<TargetPlatform> targetPlatforms = extension.getTargetPlatforms();
    // For each target platform add functional source sets
    targetPlatforms.all(new Action<TargetPlatform>() {

        @Override
        public void execute(final TargetPlatform targetPlatform) {
            logger.debug("Configuring {} in {}", targetPlatform, project.getPath());
            // Create platform configurations
            final Configuration platformMainCompile = maybeCreateCompileConfigurationFor(project, targetPlatform.getName());
            final Configuration platformTestCompile = maybeCreateCompileConfigurationFor(project, targetPlatform.getName() + "Test");
            platformMainCompile.extendsFrom(mainCompile);
            platformTestCompile.extendsFrom(testCompile);
            platformTestCompile.extendsFrom(platformMainCompile);
            logger.debug("Added {} and {} in {}", platformMainCompile, platformTestCompile, project.getPath());
            final FunctionalSourceSet platformMain = projectSourceSet.maybeCreate(targetPlatform.getName());
            final FunctionalSourceSet platformTest = projectSourceSet.maybeCreate(targetPlatform.getName() + "Test");
            logger.debug("Added {} and {} in {}", platformMain, platformTest, project.getPath());
            DomainObjectSet<LanguageSourceSet> mainLanguageSets = getLanguageSets(main, platformMain);
            DomainObjectSet<LanguageSourceSet> testLanguageSets = getLanguageSets(test, platformTest);
            createBinaries(project, targetPlatform.getName(), targetPlatform, null, mainLanguageSets, testLanguageSets, platformMainCompile, platformTestCompile);
            // Add some flavor
            targetPlatform.getFlavors().all(new Action<Flavor>() {

                @Override
                public void execute(Flavor flavor) {
                    logger.debug("Configuring {} with {} in {}", targetPlatform, flavor, project.getPath());
                    String flavorName = targetPlatform.getName() + Character.toUpperCase(flavor.getName().charAt(0)) + flavor.getName().substring(1);
                    Configuration flavorMainCompile = maybeCreateCompileConfigurationFor(project, flavorName);
                    Configuration flavorTestCompile = maybeCreateCompileConfigurationFor(project, flavorName + "Test");
                    flavorMainCompile.extendsFrom(platformMainCompile);
                    flavorTestCompile.extendsFrom(platformTestCompile);
                    flavorTestCompile.extendsFrom(flavorMainCompile);
                    logger.debug("Added {} and {} in {}", flavorMainCompile, flavorTestCompile, project.getPath());
                    FunctionalSourceSet flavorMain = projectSourceSet.maybeCreate(flavorName);
                    FunctionalSourceSet flavorTest = projectSourceSet.maybeCreate(flavorName + "Test");
                    logger.debug("Added {} and {} in {}", flavorMain, flavorTest, project.getPath());
                    DomainObjectSet<LanguageSourceSet> flavorMainLanguageSets = getLanguageSets(main, platformMain, flavorMain);
                    DomainObjectSet<LanguageSourceSet> flavorTestLanguageSets = getLanguageSets(test, platformTest, flavorTest);
                    createBinaries(project, flavorName, targetPlatform, flavor, flavorMainLanguageSets, flavorTestLanguageSets, flavorMainCompile, flavorTestCompile);
                }
            });
        }
    });
    // Add checkHaxeVersion task
    final CheckHaxeVersion checkVersionTask = project.getTasks().create(CHECK_HAXE_VERSION_TASK_NAME, CheckHaxeVersion.class);
    checkVersionTask.getConventionMapping().map("compilerVersions", new Callable<Set<Object>>() {

        @Override
        public Set<Object> call() throws Exception {
            return extension.getCompilerVersions();
        }
    });
    checkVersionTask.setDescription("Checks if Haxe compiler is the right version.");
    checkVersionTask.setGroup(VERIFICATION_GROUP);
    project.getTasks().withType(AbstractHaxeCompileTask.class).all(new Action<AbstractHaxeCompileTask>() {

        @Override
        public void execute(AbstractHaxeCompileTask compileTask) {
            compileTask.dependsOn(checkVersionTask);
        }
    });
    // Add compile all task
    Task compileTask = project.getTasks().findByName(COMPILE_TASK_NAME);
    if (compileTask == null) {
        compileTask = project.getTasks().create(COMPILE_TASK_NAME);
        compileTask.setGroup(COMPILE_TASKS_GROUP);
        compileTask.setDescription("Compile all Haxe artifacts");
    }
    final Task _compileTask = compileTask;
    project.getTasks().withType(HaxeCompile.class).all(new Action<HaxeCompile>() {

        @Override
        public void execute(HaxeCompile task) {
            task.setGroup(COMPILE_TASKS_GROUP);
            _compileTask.dependsOn(task);
        }
    });
    // Add test all task
    Task testTask = project.getTasks().findByName(TEST_TASK_NAME);
    if (testTask == null) {
        testTask = project.getTasks().create(TEST_TASK_NAME);
        testTask.setGroup(VERIFICATION_GROUP);
        testTask.setDescription("Runs all unit tests.");
    }
    final Task _testTask = testTask;
    Task checkTask = project.getTasks().findByName(CHECK_TASK_NAME);
    if (checkTask == null) {
        checkTask = project.getTasks().create(CHECK_TASK_NAME);
        checkTask.setGroup(VERIFICATION_GROUP);
        checkTask.setDescription("Runs all checks.");
    }
    checkTask.dependsOn(testTask);
    project.getTasks().withType(MUnit.class).all(new Action<MUnit>() {

        @Override
        public void execute(MUnit task) {
            task.setGroup(VERIFICATION_GROUP);
            if (task.shouldRunAutomatically()) {
                _testTask.dependsOn(task);
            }
        }
    });
    Task buildTask = project.getTasks().findByName(BUILD_TASK_NAME);
    if (buildTask == null) {
        buildTask = project.getTasks().create(BUILD_TASK_NAME);
        buildTask.setDescription("Assembles and tests this project.");
        buildTask.setGroup(BasePlugin.BUILD_GROUP);
    }
    buildTask.dependsOn(BasePlugin.ASSEMBLE_TASK_NAME);
    buildTask.dependsOn(checkTask);
}

private static BundleModule createBundleTask(final Project project, final BinaryNamingScheme namingScheme, Callable<File> javaScriptFile, Callable<File> sourceMapFile, Callable<File> definitionOverride, Collection<?> dependencies, Task verifyDtsTask) {
    String bundleTaskName = namingScheme.getTaskName("bundle");
    BundleModule bundleTask = project.getTasks().create(bundleTaskName, BundleModule.class);
    bundleTask.setDescription("Bundles " + namingScheme.getDescription() + " module.");
    configureBundleTask(project, bundleTask, namingScheme, javaScriptFile, sourceMapFile, definitionOverride, dependencies, verifyDtsTask, "bundled");
    return bundleTask;
}

@Test
public void testApply() {
    project.apply(Collections.singletonMap("plugin", "java"));
    // project.apply(Collections.singletonMap("plugin", "org.anarres.jnaerator"));
    project.getPlugins().apply(JNAeratorPlugin.class);
    assertTrue("Project is missing plugin", project.getPlugins().hasPlugin(JNAeratorPlugin.class));
    Task task = project.getTasks().findByName("jnaerator");
    assertNotNull("Project is missing jnaerator task", task);
    assertTrue("JNAerator task is the wrong type", task instanceof DefaultTask);
    assertTrue("JNAerator task should be enabled", ((DefaultTask) task).isEnabled());
}

@Test
public void testApply() {
    project.apply(Collections.singletonMap("plugin", "java"));
    project.apply(Collections.singletonMap("plugin", "org.anarres.velocity"));
    assertTrue("Project is missing plugin", project.getPlugins().hasPlugin(VelocityPlugin.class));
    Task task = project.getTasks().findByName("processVelocity");
    assertNotNull("Project is missing velocity task", task);
    assertTrue("Velocity task is the wrong type", task instanceof DefaultTask);
    assertTrue("Velocity task should be enabled", ((DefaultTask) task).isEnabled());
}

@Override
public void apply(final Project project) {
    Task verifyTask = project.task("verifyModuleDependencies");
    verifyTask.dependsOn("jar");
    project.getTasks().getByName("check").dependsOn(verifyTask);
    verifyTask.doLast(new Action<Task>() {

        @Override
        public void execute(Task task) {
            Jar jar = (Jar) project.getTasks().getByName("jar");
            verifyDependencies(project, jar.getArchivePath());
        }
    });
}

public void addToTaskGraph(Collection<? extends Task> tasks) {
    List<TaskInfo> queue = new ArrayList<TaskInfo>();
    List<Task> sortedTasks = new ArrayList<Task>(tasks);
    Collections.sort(sortedTasks);
    for (Task task : sortedTasks) {
        TaskInfo node = graph.addNode(task);
        if (node.isMustNotRun()) {
            requireWithDependencies(node);
        } else if (filter.isSatisfiedBy(task)) {
            node.require();
        }
        entryTasks.add(node);
        queue.add(node);
    }
    Set<TaskInfo> visiting = new HashSet<TaskInfo>();
    CachingTaskDependencyResolveContext context = new CachingTaskDependencyResolveContext();
    while (!queue.isEmpty()) {
        TaskInfo node = queue.get(0);
        if (node.getDependenciesProcessed()) {
            // Have already visited this task - skip it
            queue.remove(0);
            continue;
        }
        TaskInternal task = node.getTask();
        boolean filtered = !filter.isSatisfiedBy(task);
        if (filtered) {
            // Task is not required - skip it
            queue.remove(0);
            node.dependenciesProcessed();
            node.doNotRequire();
            filteredTasks.add(task);
            continue;
        }
        if (visiting.add(node)) {
            // Have not seen this task before - add its dependencies to the head of the queue and leave this
            // task in the queue
            // Make sure it has been configured
            ((TaskContainerInternal) task.getProject().getTasks()).prepareForExecution(task);
            Set<? extends Task> dependsOnTasks = context.getDependencies(task);
            for (Task dependsOnTask : dependsOnTasks) {
                TaskInfo targetNode = graph.addNode(dependsOnTask);
                node.addDependencySuccessor(targetNode);
                if (!visiting.contains(targetNode)) {
                    queue.add(0, targetNode);
                }
            }
            for (Task finalizerTask : task.getFinalizedBy().getDependencies(task)) {
                TaskInfo targetNode = graph.addNode(finalizerTask);
                addFinalizerNode(node, targetNode);
                if (!visiting.contains(targetNode)) {
                    queue.add(0, targetNode);
                }
            }
            for (Task mustRunAfter : task.getMustRunAfter().getDependencies(task)) {
                TaskInfo targetNode = graph.addNode(mustRunAfter);
                node.addMustSuccessor(targetNode);
            }
            for (Task shouldRunAfter : task.getShouldRunAfter().getDependencies(task)) {
                TaskInfo targetNode = graph.addNode(shouldRunAfter);
                node.addShouldSuccessor(targetNode);
            }
            if (node.isRequired()) {
                for (TaskInfo successor : node.getDependencySuccessors()) {
                    if (filter.isSatisfiedBy(successor.getTask())) {
                        successor.require();
                    }
                }
            } else {
                tasksInUnknownState.add(node);
            }
        } else {
            // Have visited this task's dependencies - add it to the graph
            queue.remove(0);
            visiting.remove(node);
            node.dependenciesProcessed();
        }
    }
    resolveTasksInUnknownState();
}

public JavaTestModel getProjectInfo(Project project) {
    if (!project.getPlugins().hasPlugin("java")) {
        return null;
    }
    Class<? extends Task> testClass = GradleClasses.tryGetGradleClass(project, "org.gradle.api.tasks.testing.Test", Task.class);
    if (testClass == null) {
        LOGGER.warning("Cannot find class of Test tasks.");
        return JavaTestModel.getDefaulTestModel(project.getProjectDir());
    }
    TaskCollection<? extends Task> allTests = project.getTasks().withType(testClass);
    List<JavaTestTask> result = new ArrayList<JavaTestTask>(allTests.size());
    XmlOutputDirGetter outputDirGetter = new XmlOutputDirGetter(project);
    for (Task task : allTests) {
        File xmlOutputDir = outputDirGetter.getXmlOutputDir(task);
        JavaTestTask taskInfo = new JavaTestTask(task.getName(), xmlOutputDir);
        result.add(taskInfo);
    }
    return new JavaTestModel(result);
}

@BinaryTasks
public void uberjarPrep(ModelMap<Task> tasks, JarBinarySpec binary, GracljInternal internal) {
    if (binary.getLibrary() instanceof ClojureApplicationSpec) {
        boolean uberjar = ((ClojureApplicationSpec) binary.getLibrary()).isUberjar();
        if (uberjar) {
            String taskName = binary.getTasks().taskName("extractDependencies");
            File destinationDir = binary.getResourcesDir();
            tasks.create(taskName,  task -> {
                task.setDescription("Extract binary's dependencies for use in an uberjar.");
                task.doLast( t -> {
                    internal.resolve(binary.getLibrary().getDependencies()).forEach( file -> {
                        if (file.getName().endsWith(".jar")) {
                            FileTree tree = task.getProject().zipTree(file);
                            task.getProject().copy( spec -> {
                                spec.from(tree);
                                spec.into(destinationDir);
                                spec.exclude("project.clj", "META-INF/MANIFEST.MF", "META-INF/NOTICE*", "META-INF/LICENSE*", "META-INF/DEPENDENCIES");
                            });
                        }
                    });
                });
                ((WithJvmAssembly) binary).getAssembly().builtBy(task);
            });
        }
    }
}

@Override
public void apply(final Project target) {
    target.getExtensions().create("bukkit", Bukkit.class);
    target.getTasks().create("listAvailableBukkitVersions", ListAvailableArtifacts.class);
    final Task downloadTask = target.getTasks().create("downloadCraftBukkit", DownloadCraftBukkit.class);
    final Task copyPluginsTask = target.getTasks().create("copyBukkitPlugins", CopyPluginsTask.class);
    target.getTasks().create("runBukkit", RunBukkit.class).dependsOn(downloadTask, copyPluginsTask);
}

@Override
public void apply(Project project) {
    final ParameterContainer parameters = project.getExtensions().create("parameters", ParameterContainer.class);
    project.afterEvaluate(new Action<Project>() {

        @Override
        public void execute(Project project) {
            ExtraPropertiesExtension extraProperties = project.getExtensions().getExtraProperties();
            Reader reader = new InputStreamReader(System.in, Charsets.UTF_8);
            try {
                Map<String, Object> resolved = parameters.resolve(reader);
                for (Map.Entry<String, Object> entry : resolved.entrySet()) {
                    extraProperties.set(entry.getKey(), entry.getValue());
                }
            } catch (IOException e) {
                Throwables.propagate(e);
            }
        }
    });
    ProcessFiles processDefaultTemplateFiles = project.getTasks().create(DEFAULT_PROCESS_FILES_TASK, ProcessFiles.class);
    processDefaultTemplateFiles.setTemplateDirectory(project.file(project.property(TEMPLATE_PROPERTY) + "/" + DEFAULT_TEMPLATE_LOCATION));
    processDefaultTemplateFiles.setTargetDirectory(project.getProjectDir());
    Task generateTask = project.getTasks().create(GENERATE_TASK);
    generateTask.dependsOn(processDefaultTemplateFiles);
}

@Override
public void apply(Gradle gradle) {
    ArtifactRepository repo = new GradleResolver();
    repo.setName("xmvn");
    gradle.allprojects( project -> {
        project.getRepositories().addFirst(repo);
        project.getBuildscript().getRepositories().addFirst(repo);
        Task upload = project.getTasks().create("xmvnInstall", XMvnInstallTask.class);
        upload.setDescription("Installs all artifacts through XMvn");
        upload.setGroup("upload");
    });
}

/**
     * Create tasks before the evaluation (on plugin apply). This is useful for tasks that
     * could be referenced by custom build logic.
     */
public void createTasksBeforeEvaluate(@NonNull TaskFactory tasks) {
    tasks.create(UNINSTALL_ALL, new Action<Task>() {

        @Override
        public void execute(Task uninstallAllTask) {
            uninstallAllTask.setDescription("Uninstall all applications.");
            uninstallAllTask.setGroup(INSTALL_GROUP);
        }
    });
    tasks.create(DEVICE_CHECK, new Action<Task>() {

        @Override
        public void execute(Task deviceCheckTask) {
            deviceCheckTask.setDescription("Runs all device checks using Device Providers and Test Servers.");
            deviceCheckTask.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
        }
    });
    tasks.create(CONNECTED_CHECK, new Action<Task>() {

        @Override
        public void execute(Task connectedCheckTask) {
            connectedCheckTask.setDescription("Runs all device checks on currently connected devices.");
            connectedCheckTask.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
        }
    });
    tasks.create(MAIN_PREBUILD);
    tasks.create(SOURCE_SETS, SourceSetsTask.class, new Action<SourceSetsTask>() {

        @Override
        public void execute(SourceSetsTask sourceSetsTask) {
            sourceSetsTask.setConfig(extension);
            sourceSetsTask.setDescription("Prints out all the source sets defined in this project.");
            sourceSetsTask.setGroup(ANDROID_GROUP);
        }
    });
    tasks.create(ASSEMBLE_ANDROID_TEST, new Action<Task>() {

        @Override
        public void execute(Task assembleAndroidTestTask) {
            assembleAndroidTestTask.setGroup(BasePlugin.BUILD_GROUP);
            assembleAndroidTestTask.setDescription("Assembles all the Test applications.");
        }
    });
    tasks.create(LINT, Lint.class, new Action<Lint>() {

        @Override
        public void execute(Lint lintTask) {
            lintTask.setDescription("Runs lint on all variants.");
            lintTask.setVariantName("");
            lintTask.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
            lintTask.setLintOptions(getExtension().getLintOptions());
            lintTask.setSdkHome(sdkHandler.getSdkFolder());
            lintTask.setToolingRegistry(toolingRegistry);
        }
    });
    tasks.named(JavaBasePlugin.CHECK_TASK_NAME, new Action<Task>() {

        @Override
        public void execute(Task it) {
            it.dependsOn(LINT);
        }
    });
    createLintCompileTask(tasks);
}

@Override
public void execute(final JavaPlugin plugin) {
    final File outputDir = new File(project.getBuildDir(), "snapshot");
    final SourceSetContainer sourceSets = (SourceSetContainer) project.getProperties().get("sourceSets");
    sourceSets.getByName("main").getResources().srcDir(outputDir);
    final Task t = tasks.getByName(JavaPlugin.PROCESS_RESOURCES_TASK_NAME);
    t.dependsOn(task);
}

@Override
public void apply(final Project project) {
    final File portalRootDir = GradleUtil.getRootDir(project.getRootProject(), "portal-impl");
    GradleUtil.applyPlugin(project, LiferayOSGiPlugin.class);
    final LiferayExtension liferayExtension = GradleUtil.getExtension(project, LiferayExtension.class);
    final GitRepo gitRepo = _getGitRepo(project.getProjectDir());
    final boolean testProject = GradleUtil.isTestProject(project);
    File versionOverrideFile = _getVersionOverrideFile(project, gitRepo);
    boolean syncReleaseVersions = _syncReleaseVersions(project, portalRootDir, versionOverrideFile, testProject);
    _applyVersionOverrides(project, versionOverrideFile);
    Gradle gradle = project.getGradle();
    gradle.addBuildListener(_backupFilesBuildAdapter);
    StartParameter startParameter = gradle.getStartParameter();
    List<String> taskNames = startParameter.getTaskNames();
    final boolean publishing = _isPublishing(project);
    boolean deployToAppServerLibs = false;
    boolean deployToTools = false;
    if (FileUtil.exists(project, ".lfrbuild-app-server-lib")) {
        deployToAppServerLibs = true;
    } else if (FileUtil.exists(project, ".lfrbuild-tool")) {
        deployToTools = true;
    }
    _applyPlugins(project);
    // applyConfigScripts configures the "install" and "uploadArchives"
    // tasks, and this causes the conf2ScopeMappings.mappings convention
    // property to be cloned in a second map. Because we want to change
    // the default mappings, we must call configureMavenConf2ScopeMappings
    // before applyConfigScripts.
    _configureMavenConf2ScopeMappings(project);
    _applyConfigScripts(project);
    _addDependenciesPmd(project);
    if (testProject || _hasTests(project)) {
        GradleUtil.applyPlugin(project, WhipPlugin.class);
        WhipDefaultsPlugin.INSTANCE.apply(project);
        Configuration aspectJWeaverConfiguration = _addConfigurationAspectJWeaver(project);
        Configuration portalConfiguration = GradleUtil.getConfiguration(project, LiferayBasePlugin.PORTAL_CONFIGURATION_NAME);
        Configuration portalTestConfiguration = _addConfigurationPortalTest(project);
        _addDependenciesPortalTest(project);
        _addDependenciesTestCompile(project);
        _configureEclipse(project, portalTestConfiguration);
        _configureIdea(project, portalTestConfiguration);
        _configureSourceSetTest(project, portalConfiguration, portalTestConfiguration);
        _configureSourceSetTestIntegration(project, portalConfiguration, portalTestConfiguration);
        _configureTaskTestAspectJWeaver(project, JavaPlugin.TEST_TASK_NAME, aspectJWeaverConfiguration);
        _configureTaskTestAspectJWeaver(project, TestIntegrationBasePlugin.TEST_INTEGRATION_TASK_NAME, aspectJWeaverConfiguration);
    }
    Task baselineTask = GradleUtil.getTask(project, BaselinePlugin.BASELINE_TASK_NAME);
    Task syncVersionsTask = _addTaskSyncVersions(project);
    baselineTask.finalizedBy(syncVersionsTask);
    if (syncReleaseVersions) {
        _configureTaskBaselineSyncReleaseVersions(baselineTask, versionOverrideFile);
    }
    InstallCacheTask installCacheTask = _addTaskInstallCache(project);
    _addTaskCommitCache(project, installCacheTask);
    _addTaskCopyLibs(project);
    Copy deployDependenciesTask = _addTaskDeployDependencies(project, liferayExtension);
    if (deployToAppServerLibs) {
        _addTaskAlias(project, DEPLOY_APP_SERVER_LIB_TASK_NAME, LiferayBasePlugin.DEPLOY_TASK_NAME);
    } else if (deployToTools) {
        _addTaskAlias(project, DEPLOY_TOOL_TASK_NAME, LiferayBasePlugin.DEPLOY_TASK_NAME);
    }
    final Jar jarJSPsTask = _addTaskJarJSP(project);
    final Jar jarJavadocTask = _addTaskJarJavadoc(project);
    final Jar jarSourcesTask = _addTaskJarSources(project, testProject);
    final Jar jarTLDDocTask = _addTaskJarTLDDoc(project);
    final ReplaceRegexTask updateFileVersionsTask = _addTaskUpdateFileVersions(project, gitRepo);
    final ReplaceRegexTask updateVersionTask = _addTaskUpdateVersion(project);
    _configureBasePlugin(project, portalRootDir);
    _configureBundleDefaultInstructions(project, portalRootDir, publishing);
    _configureConfigurations(project, gitRepo, liferayExtension);
    _configureDependencyChecker(project);
    _configureDeployDir(project, liferayExtension, deployToAppServerLibs, deployToTools);
    _configureEclipse(project);
    _configureJavaPlugin(project);
    _configureLocalPortalTool(project, portalRootDir, SourceFormatterPlugin.CONFIGURATION_NAME, _SOURCE_FORMATTER_PORTAL_TOOL_NAME);
    _configurePmd(project);
    _configureProject(project);
    configureRepositories(project);
    _configureSourceSetMain(project);
    _configureTaskDeploy(project, deployDependenciesTask);
    _configureTaskJar(project, testProject);
    _configureTaskJavadoc(project, portalRootDir);
    _configureTaskTest(project);
    _configureTaskTestIntegration(project);
    _configureTaskTlddoc(project, portalRootDir);
    _configureTasksBaseline(project);
    _configureTasksFindBugs(project);
    _configureTasksJavaCompile(project);
    _configureTasksPmd(project);
    _configureTasksPublishNodeModule(project);
    _addTaskUpdateFileSnapshotVersions(project);
    if (publishing) {
        _configureTasksEnabledIfStaleSnapshot(project, testProject, MavenPlugin.INSTALL_TASK_NAME, BasePlugin.UPLOAD_ARCHIVES_TASK_NAME);
    }
    GradleUtil.withPlugin(project, ServiceBuilderPlugin.class, new Action<ServiceBuilderPlugin>() {

        @Override
        public void execute(ServiceBuilderPlugin serviceBuilderPlugin) {
            _configureLocalPortalTool(project, portalRootDir, ServiceBuilderPlugin.CONFIGURATION_NAME, _SERVICE_BUILDER_PORTAL_TOOL_NAME);
            _configureTaskBuildService(project);
        }
    });
    GradleUtil.withPlugin(project, WSDDBuilderPlugin.class, new Action<WSDDBuilderPlugin>() {

        @Override
        public void execute(WSDDBuilderPlugin wsddBuilderPlugin) {
            _configureTaskBuildWSDD(project);
        }
    });
    project.afterEvaluate(new Action<Project>() {

        @Override
        public void execute(Project project) {
            _checkVersion(project);
            _configureArtifacts(project, jarJSPsTask, jarJavadocTask, jarSourcesTask, jarTLDDocTask);
            _configureTaskJarSources(jarSourcesTask);
            _configureTaskUpdateFileVersions(updateFileVersionsTask, portalRootDir);
            GradleUtil.setProjectSnapshotVersion(project, _SNAPSHOT_PROPERTY_NAMES);
            if (GradleUtil.hasPlugin(project, CachePlugin.class)) {
                _configureTaskUpdateVersionForCachePlugin(updateVersionTask);
            }
            _configureTaskCompileJSP(project, jarJSPsTask, liferayExtension);
            // setProjectSnapshotVersion must be called before
            // configureTaskUploadArchives, because the latter one needs
            // to know if we are publishing a snapshot or not.
            _configureTaskUploadArchives(project, testProject, updateFileVersionsTask, updateVersionTask);
            _configureProjectBndProperties(project, liferayExtension);
        }
    });
    if (taskNames.contains("eclipse") || taskNames.contains("idea")) {
        _forceProjectDependenciesEvaluation(project);
    }
    TaskExecutionGraph taskExecutionGraph = gradle.getTaskGraph();
    taskExecutionGraph.whenReady(new Closure<Void>(project) {

        @SuppressWarnings("unused")
        public void doCall(TaskExecutionGraph taskExecutionGraph) {
            Task jarTask = GradleUtil.getTask(project, JavaPlugin.JAR_TASK_NAME);
            if (taskExecutionGraph.hasTask(jarTask)) {
                _configureBundleInstructions(project, gitRepo);
            }
        }
    });
}

private void addTasksDescription(Project project, final ProjectDescriptor projectDescriptor) {
    project.getTasks().all(new Action<Task>() {

        @Override
        public void execute(Task task) {
            if (task.getGroup() != null) {
                projectDescriptor.addTask(new TaskDescriptor(task.getName(), task.getPath(), task.getGroup(), task.getDescription()));
            }
        }
    });
}

private void createCheckTask(final Project project) {
    project.getTasks().create(GwtCheckTask.NAME, GwtCheckTask.class);
    final PutnamiExtension extension = project.getExtensions().getByType(PutnamiExtension.class);
    final Task checkTask = project.getTasks().getByName(JavaBasePlugin.CHECK_TASK_NAME);
    checkTask.dependsOn(GwtCheckTask.NAME);
    project.getTasks().withType(GwtCheckTask.class, new Action<GwtCheckTask>() {

        @Override
        public void execute(final GwtCheckTask task) {
            task.configure(project, extension);
        }
    });
}

@SuppressWarnings("unchecked")
@Override
public void apply(Project target) {
    // Add config block
    CoroutinesPluginConfiguration config = new CoroutinesPluginConfiguration();
    target.getExtensions().add("coroutines", config);
    Set<Task> compileJavaTasks = target.getTasksByName("compileJava", true);
    for (Task task : compileJavaTasks) {
        addInstrumentActionToTask("main", task, config);
    }
    Set<Task> compileJavaTestTasks = target.getTasksByName("compileTestJava", true);
    for (Task task : compileJavaTestTasks) {
        addInstrumentActionToTask("test", task, config);
    }
}

@Override
public final void applyPlugin() {
    // apply the plugins
    this.applyExternalPlugin("java");
    this.applyExternalPlugin("eclipse");
    this.applyExternalPlugin("idea");
    // life cycle tasks
    Task task = makeTask(TASK_SETUP_CI, DefaultTask.class);
    task.setDescription("Sets up the bare minimum to build a minecraft mod. Ideally for CI servers");
    task.setGroup("ForgeGradle");
    task.dependsOn(TASK_DD_PROVIDED, TASK_DD_COMPILE);
    task = makeTask(TASK_SETUP_DEV, DefaultTask.class);
    task.setDescription("CIWorkspace + natives and assets to run and test Minecraft");
    task.setGroup("ForgeGradle");
    task.dependsOn(TASK_DD_PROVIDED, TASK_DD_COMPILE);
    task = makeTask(TASK_SETUP_DECOMP, DefaultTask.class);
    task.setDescription("DevWorkspace + the deobfuscated Minecraft source linked as a source jar.");
    task.setGroup("ForgeGradle");
    task.dependsOn(TASK_DD_PROVIDED, TASK_DD_COMPILE);
    // create configs
    project.getConfigurations().maybeCreate(CONFIG_MC);
    project.getConfigurations().maybeCreate(CONFIG_PROVIDED);
    project.getConfigurations().maybeCreate(CONFIG_START);
    project.getConfigurations().maybeCreate(CONFIG_DEOBF_COMPILE);
    project.getConfigurations().maybeCreate(CONFIG_DEOBF_PROVIDED);
    project.getConfigurations().maybeCreate(CONFIG_DC_RESOLVED);
    project.getConfigurations().maybeCreate(CONFIG_DP_RESOLVED);
    // create the reobf named container
    NamedDomainObjectContainer<IReobfuscator> reobf = project.container(IReobfuscator.class, new ReobfTaskFactory(this));
    project.getExtensions().add(EXT_REOBF, reobf);
    configureCompilation();
    // Quality of life stuff for the users
    createSourceCopyTasks();
    doDevTimeDeobf();
    doDepAtExtraction();
    configureRetromapping();
    makeRunTasks();
    // IDE stuff
    configureEclipse();
    configureIntellij();
    applyUserPlugin();
}

private // NOPMD
void applyTasks(// NOPMD
final Project project) {
    AwsBeanstalkPluginExtension ebExt = project.getExtensions().findByType(AwsBeanstalkPluginExtension.class);
    AWSElasticBeanstalkCreateApplicationTask awsEbMigrateApplication = project.getTasks().create("awsEbMigrateApplication", AWSElasticBeanstalkCreateApplicationTask.class,  task -> {
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
            task.setAppDesc(ebExt.getAppDesc());
        });
    });
    AmazonS3ProgressiveFileUploadTask awsUploadWar = project.getTasks().create("awsEbUploadBundle", AmazonS3ProgressiveFileUploadTask.class,  task -> {
        WarPlugin war = project.getPlugins().findPlugin(WarPlugin.class);
        War warTask = war == null ? null : (War) project.getTasks().getByName(WarPlugin.WAR_TASK_NAME);
        if (war != null) {
            task.dependsOn(warTask);
        }
        task.onlyIf( t -> ebExt.getVersion().getFile() != null || war != null);
        task.doFirst( t -> {
            task.setBucketName(ebExt.getVersion().getBucket());
            task.setKey(ebExt.getVersion().getKey());
            if (warTask != null && ebExt.getVersion().getFile() == null) {
                task.setFile(warTask.getArchivePath());
            } else {
                task.setFile(ebExt.getVersion().getFile());
            }
        });
    });
    AWSElasticBeanstalkCreateApplicationVersionTask awsEbCreateApplicationVersion = project.getTasks().create("awsEbCreateApplicationVersion", AWSElasticBeanstalkCreateApplicationVersionTask.class,  task -> {
        task.dependsOn(awsEbMigrateApplication, awsUploadWar);
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
            task.setVersionLabel(ebExt.getVersion().getLabel());
            task.setBucketName(ebExt.getVersion().getBucket());
            task.setKey(ebExt.getVersion().getKey());
        });
    });
    AWSElasticBeanstalkCreateConfigurationTemplateTask awsEbMigrateConfigurationTemplates = project.getTasks().create("awsEbMigrateConfigurationTemplates", AWSElasticBeanstalkCreateConfigurationTemplateTask.class,  task -> {
        task.dependsOn(awsEbMigrateApplication);
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
            task.setConfigurationTemplates(ebExt.getConfigurationTemplates());
        });
    });
    AWSElasticBeanstalkCreateEnvironmentTask awsEbMigrateEnvironment = project.getTasks().create("awsEbMigrateEnvironment", AWSElasticBeanstalkCreateEnvironmentTask.class,  task -> {
        task.dependsOn(awsEbMigrateConfigurationTemplates, awsEbCreateApplicationVersion);
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
            task.setEnvName(ebExt.getEnvironment().getEnvName());
            task.setEnvDesc(ebExt.getEnvironment().getEnvDesc());
            task.setTemplateName(ebExt.getEnvironment().getTemplateName());
            task.setVersionLabel(ebExt.getEnvironment().getVersionLabel());
            task.setTier(ebExt.getTier() != null ? ebExt.getTier() : Tier.WebServer);
            if (Strings.isNullOrEmpty(ebExt.getEnvironment().getCnamePrefix()) == false) {
                task.setCnamePrefix(ebExt.getEnvironment().getCnamePrefix());
            }
            if (ebExt.getEnvironment().getTags() != null) {
                task.setTags(ebExt.getEnvironment().getTags());
            }
        });
    });
    AWSElasticBeanstalkTerminateEnvironmentTask awsEbTerminateEnvironment = project.getTasks().create("awsEbTerminateEnvironment", AWSElasticBeanstalkTerminateEnvironmentTask.class,  task -> {
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
            task.setEnvName(ebExt.getEnvironment().getEnvName());
        });
    });
    project.getTasks().create("awsEbWaitEnvironmentReady", AWSElasticBeanstalkWaitEnvironmentStatusTask.class,  task -> {
        task.mustRunAfter(awsEbMigrateEnvironment);
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
            task.setEnvName(ebExt.getEnvironment().getEnvName());
        });
    });
    AWSElasticBeanstalkWaitEnvironmentStatusTask awsEbWaitEnvironmentTerminated = project.getTasks().create("awsEbWaitEnvironmentTerminated", AWSElasticBeanstalkWaitEnvironmentStatusTask.class,  task -> {
        task.mustRunAfter(awsEbTerminateEnvironment);
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
            task.setEnvName(ebExt.getEnvironment().getEnvName());
            task.setSuccessStatuses(Arrays.asList("Terminated"));
            task.setWaitStatuses(Arrays.asList("Launching", "Updating", "Terminating", "Ready"));
        });
    });
    Task awsEbTerminateEnvironmentAndWaitTerminated = project.getTasks().create("awsEbTerminateEnvironmentAndWaitTerminated").dependsOn(awsEbTerminateEnvironment, awsEbWaitEnvironmentTerminated);
    project.getTasks().create("awsEbCleanupApplicationVersions", AWSElasticBeanstalkCleanupApplicationVersionTask.class,  task -> {
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
        });
    });
    project.getTasks().create("awsEbDeleteApplication", AWSElasticBeanstalkDeleteApplicationTask.class,  task -> {
        task.dependsOn(awsEbTerminateEnvironmentAndWaitTerminated);
        task.doFirst( t -> {
            task.setAppName(ebExt.getAppName());
        });
    });
}

private void configureProjectCollectors(Set<Project> projects) {
    for (Project project : projects) {
        TaskContainer tasks = project.getTasks();
        for (String name : tasks.getNames()) {
            Task task = tasks.getByName(name);
            if (task instanceof Test) {
                GradleTestSuiteCollector suiteCollector = new GradleTestSuiteCollector(dispatcherSupplier, (Test) task);
                ((Test) task).addTestListener(suiteCollector);
            }
        }
    }
}

private void configureJoobyRun(final Project project) throws IOException {
    project.getTasks().withType(JoobyTask.class,  joobyRun -> {
        ConventionMapping mapping = joobyRun.getConventionMapping();
        mapping.map("classpath", () -> new JoobyProject(project).classpath());
        mapping.map("src", () -> new JoobyProject(project).sources());
        mapping.map("mainClassName", () -> project.getProperties().get("mainClassName"));
        mapping.map("compiler", () -> {
            File eclipseClasspath = new File(project.getProjectDir(), ".classpath");
            return eclipseClasspath.exists() ? "off" : "on";
        });
        Gradle gradle = project.getGradle();
        mapping.map("block", () -> !gradle.getStartParameter().isContinuous());
        mapping.map("logLevel", () -> gradle.getStartParameter().getLogLevel().name());
    });
    Map<String, Object> options = new HashMap<>();
    options.put(Task.TASK_TYPE, JoobyTask.class);
    options.put(Task.TASK_DEPENDS_ON, "classes");
    options.put(Task.TASK_NAME, "joobyRun");
    options.put(Task.TASK_DESCRIPTION, "Run, debug and hot reload applications");
    options.put(Task.TASK_GROUP, "jooby");
    project.getTasks().create(options);
}

@SuppressWarnings("rawtypes")
void createTasks() throws Exception {
    Task rootCheckTask = project.task(EXTENSION + CHECK);
    rootCheckTask.setGroup(TASK_GROUP);
    rootCheckTask.setDescription(CHECK_DESCRIPTION);
    Task rootApplyTask = project.task(EXTENSION + APPLY);
    rootApplyTask.setGroup(TASK_GROUP);
    rootApplyTask.setDescription(APPLY_DESCRIPTION);
    spotlessExtension.formats.forEach(( key,  value) -> {
        // create the task that does the work
        String taskName = EXTENSION + capitalize(key);
        SpotlessTask spotlessTask = project.getTasks().create(taskName, SpotlessTask.class);
        value.setupTask(spotlessTask);
        // create the check and apply control tasks
        Task checkTask = project.getTasks().create(taskName + CHECK);
        Task applyTask = project.getTasks().create(taskName + APPLY);
        // the root tasks depend on them
        rootCheckTask.dependsOn(checkTask);
        rootApplyTask.dependsOn(applyTask);
        // and they depend on the work task
        checkTask.dependsOn(spotlessTask);
        applyTask.dependsOn(spotlessTask);
        // when the task graph is ready, we'll configure the spotlessTask appropriately
        project.getGradle().getTaskGraph().whenReady(new Closure(null) {

            private static final long serialVersionUID = 1L;

            // called by gradle
            @SuppressFBWarnings("UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS")
            public Object doCall(TaskExecutionGraph graph) {
                if (graph.hasTask(checkTask)) {
                    spotlessTask.setCheck();
                }
                if (graph.hasTask(applyTask)) {
                    spotlessTask.setApply();
                }
                return Closure.DONE;
            }
        });
    });
    // task doesn't exist at the time this call is made
    if (spotlessExtension.enforceCheck) {
        project.getTasks().matching( task -> task.getName().equals(JavaBasePlugin.CHECK_TASK_NAME)).all( task -> task.dependsOn(rootCheckTask));
    }
    // clear spotless' cache when the user does a clean
    project.getTasks().matching( task -> task.getName().equals("clean")).all( task -> task.doLast( unused -> SpotlessCache.clear()));
}

/**
     * Task creation entry point.
     */
public void createAndroidTasks(@Nullable SigningConfig signingOverride) {
    variantFactory.validateModel(this);
    if (!productFlavors.isEmpty()) {
        // there'll be more than one test app, so we need a top level assembleTest
        Task assembleTest = project.getTasks().create("assembleTest");
        assembleTest.setGroup(org.gradle.api.plugins.BasePlugin.BUILD_GROUP);
        assembleTest.setDescription("Assembles all the Test applications");
        basePlugin.setAssembleTest(assembleTest);
    }
    if (variantDataList.isEmpty()) {
        populateVariantDataList(signingOverride);
    }
    for (BaseVariantData variantData : variantDataList) {
        createTasksForVariantData(project.getTasks(), variantData);
    }
    // create the lint tasks.
    basePlugin.createLintTasks();
    // create the test tasks.
    basePlugin.createCheckTasks(!productFlavors.isEmpty(), false);
    // Create the variant API objects after the tasks have been created!
    createApiObjects();
}

@Override
public void execute(Task task) {
    ByteBuddyLogHandler byteBuddyLogHandler = ByteBuddyLogHandler.initialize(project);
    try {
        processOutputDirectory(this.task.getDestinationDir(), this.task.getClasspath());
    } catch (IOException exception) {
        throw new GradleException("Error accessing file system", exception);
    } finally {
        byteBuddyLogHandler.reset();
    }
}

@Override
public void execute(Task task) {
    final ClassLoader runtimeScopeClassLoader = buildRuntimeScopeClassLoader();
    loaderClassPath = new LoaderClassPath(runtimeScopeClassLoader);
    classPool = new ClassPool(true);
    classPool.appendClassPath(loaderClassPath);
    try {
        performInjections();
    } finally {
        loaderClassPath.close();
    }
}

@Override
public boolean isSatisfiedBy(Task task) {
    // destination already exists
    if (getProject().getGradle().getStartParameter().isOffline()) {
        for (File f : getOutputFiles()) {
            if (f.exists()) {
                if (!isQuiet()) {
                    getProject().getLogger().info("Skipping existing file '" + f.getName() + "' in offline mode.");
                }
            } else {
                throw new IllegalStateException("Unable to download file '" + f.getName() + "' in offline mode.");
            }
        }
        return false;
    }
    return true;
}

private void compileXtend(Task t) {
    XtendCompile c = (XtendCompile) t;
    List<File> existed = new ArrayList<>();
    // Existing jars
    c.getXtendClasspath().forEach(existed::add);
    c.getClasspath().forEach(existed::add);
    List<File> collect = collectAllJars(t, existed);
    collect.sort(( f1,  f2) -> f1.getName().compareTo(f2.getName()));
    FileCollection allJars = project.files(collect);
    c.setClasspath(allJars);
}

@Override
public void execute(Task task) {
    final ClassLoader runtimeScopeClassLoader = buildRuntimeScopeClassLoader();
    loaderClassPath = new LoaderClassPath(runtimeScopeClassLoader);
    classPool = new ClassPool(true);
    classPool.appendClassPath(loaderClassPath);
    try {
        performInjections();
    } finally {
        loaderClassPath.close();
    }
}

@Override
public void execute(Task task) {
    project.getLogger().debug("Starting Hibernate enhancement on SourceSet.{}", sourceSet.getName());
    final ClassLoader classLoader = toClassLoader(sourceSet.getRuntimeClasspath());
    EnhancementContext enhancementContext = new DefaultEnhancementContext() {

        @Override
        public ClassLoader getLoadingClassLoader() {
            return classLoader;
        }

        @Override
        public boolean doBiDirectionalAssociationManagement(UnloadedField field) {
            return hibernateExtension.enhance.getEnableAssociationManagement();
        }

        @Override
        public boolean doDirtyCheckingInline(UnloadedClass classDescriptor) {
            return hibernateExtension.enhance.getEnableDirtyTracking();
        }

        @Override
        public boolean hasLazyLoadableAttributes(UnloadedClass classDescriptor) {
            return hibernateExtension.enhance.getEnableLazyInitialization();
        }

        @Override
        public boolean isLazyLoadable(UnloadedField field) {
            return hibernateExtension.enhance.getEnableLazyInitialization();
        }

        @Override
        public boolean doExtendedEnhancement(UnloadedClass classDescriptor) {
            return hibernateExtension.enhance.getEnableExtendedEnhancement();
        }
    };
    if (hibernateExtension.enhance.getEnableExtendedEnhancement()) {
        logger.warn("Extended enhancement is enabled. Classes other than entities may be modified. You should consider access the entities using getter/setter methods and disable this property. Use at your own risk.");
    }
    final Enhancer enhancer = Environment.getBytecodeProvider().getEnhancer(enhancementContext);
    final FileTree fileTree = project.fileTree(sourceSet.getOutput().getClassesDir());
    for (File file : fileTree) {
        if (!file.getName().endsWith(".class")) {
            continue;
        }
        final byte[] enhancedBytecode = doEnhancement(sourceSet.getOutput().getClassesDir(), file, enhancer);
        if (enhancedBytecode != null) {
            writeOutEnhancedClass(enhancedBytecode, file);
            logger.info("Successfully enhanced class [" + file + "]");
        } else {
            logger.info("Skipping class [" + file.getAbsolutePath() + "], not an entity nor embeddable");
        }
    }
}

@Nullable
@Override
public Object buildAll(String modelName, Project project) {
    final String moduleName = project.getName();
    final String moduleGroup = project.getGroup().toString();
    final String moduleVersion = project.getVersion().toString();
    final File buildDir = project.getBuildDir();
    String javaSourceCompatibility = null;
    for (Task task : project.getTasks()) {
        if (task instanceof JavaCompile) {
            JavaCompile javaCompile = (JavaCompile) task;
            javaSourceCompatibility = javaCompile.getSourceCompatibility();
            if (task.getName().equals("compileJava"))
                break;
        }
    }
    final ModuleExtendedModelImpl moduleVersionModel = new ModuleExtendedModelImpl(moduleName, moduleGroup, moduleVersion, buildDir, javaSourceCompatibility);
    final List<File> artifacts = new ArrayList<File>();
    for (Task task : project.getTasks()) {
        if (task instanceof Jar) {
            Jar jar = (Jar) task;
            artifacts.add(jar.getArchivePath());
        }
    }
    moduleVersionModel.setArtifacts(artifacts);
    final Set<String> sourceDirectories = new HashSet<String>();
    final Set<String> testDirectories = new HashSet<String>();
    final Set<String> resourceDirectories = new HashSet<String>();
    final Set<String> testResourceDirectories = new HashSet<String>();
    final List<File> testClassesDirs = new ArrayList<File>();
    for (Task task : project.getTasks()) {
        if (task instanceof Test) {
            Test test = (Test) task;
            testClassesDirs.add(test.getTestClassesDir());
            if (test.hasProperty(TEST_SRC_DIRS_PROPERTY)) {
                Object testSrcDirs = test.property(TEST_SRC_DIRS_PROPERTY);
                if (testSrcDirs instanceof Iterable) {
                    for (Object dir : Iterable.class.cast(testSrcDirs)) {
                        addFilePath(testDirectories, dir);
                    }
                }
            }
        }
    }
    IdeaCompilerOutputImpl compilerOutput = new IdeaCompilerOutputImpl();
    if (project.hasProperty(SOURCE_SETS_PROPERTY)) {
        Object sourceSets = project.property(SOURCE_SETS_PROPERTY);
        if (sourceSets instanceof SourceSetContainer) {
            SourceSetContainer sourceSetContainer = (SourceSetContainer) sourceSets;
            for (SourceSet sourceSet : sourceSetContainer) {
                SourceSetOutput output = sourceSet.getOutput();
                if (SourceSet.TEST_SOURCE_SET_NAME.equals(sourceSet.getName())) {
                    compilerOutput.setTestClassesDir(output.getClassesDir());
                    compilerOutput.setTestResourcesDir(output.getResourcesDir());
                }
                if (SourceSet.MAIN_SOURCE_SET_NAME.equals(sourceSet.getName())) {
                    compilerOutput.setMainClassesDir(output.getClassesDir());
                    compilerOutput.setMainResourcesDir(output.getResourcesDir());
                }
                for (File javaSrcDir : sourceSet.getAllJava().getSrcDirs()) {
                    boolean isTestDir = isTestDir(sourceSet, testClassesDirs);
                    addFilePath(isTestDir ? testDirectories : sourceDirectories, javaSrcDir);
                }
                for (File resourcesSrcDir : sourceSet.getResources().getSrcDirs()) {
                    boolean isTestDir = isTestDir(sourceSet, testClassesDirs);
                    addFilePath(isTestDir ? testResourceDirectories : resourceDirectories, resourcesSrcDir);
                }
            }
        }
    }
    File projectDir = project.getProjectDir();
    IdeaContentRootImpl contentRoot = new IdeaContentRootImpl(projectDir);
    final Set<String> ideaSourceDirectories = new HashSet<String>();
    final Set<String> ideaTestDirectories = new HashSet<String>();
    final Set<String> ideaGeneratedDirectories = new HashSet<String>();
    final Set<File> excludeDirectories = new HashSet<File>();
    enrichDataFromIdeaPlugin(project, excludeDirectories, ideaSourceDirectories, ideaTestDirectories, ideaGeneratedDirectories);
    if (ideaSourceDirectories.isEmpty()) {
        sourceDirectories.clear();
        resourceDirectories.clear();
    }
    if (ideaTestDirectories.isEmpty()) {
        testDirectories.clear();
        testResourceDirectories.clear();
    }
    ideaSourceDirectories.removeAll(resourceDirectories);
    sourceDirectories.removeAll(ideaTestDirectories);
    sourceDirectories.addAll(ideaSourceDirectories);
    ideaTestDirectories.removeAll(testResourceDirectories);
    testDirectories.addAll(ideaTestDirectories);
    // ensure disjoint directories with different type
    resourceDirectories.removeAll(sourceDirectories);
    testDirectories.removeAll(sourceDirectories);
    testResourceDirectories.removeAll(testDirectories);
    for (String javaDir : sourceDirectories) {
        contentRoot.addSourceDirectory(new IdeaSourceDirectoryImpl(new File(javaDir), ideaGeneratedDirectories.contains(javaDir)));
    }
    for (String testDir : testDirectories) {
        contentRoot.addTestDirectory(new IdeaSourceDirectoryImpl(new File(testDir), ideaGeneratedDirectories.contains(testDir)));
    }
    for (String resourceDir : resourceDirectories) {
        contentRoot.addResourceDirectory(new IdeaSourceDirectoryImpl(new File(resourceDir)));
    }
    for (String testResourceDir : testResourceDirectories) {
        contentRoot.addTestResourceDirectory(new IdeaSourceDirectoryImpl(new File(testResourceDir)));
    }
    for (File excludeDir : excludeDirectories) {
        contentRoot.addExcludeDirectory(excludeDir);
    }
    moduleVersionModel.setContentRoots(Collections.<ExtIdeaContentRoot>singleton(contentRoot));
    moduleVersionModel.setCompilerOutput(compilerOutput);
    ConfigurationContainer configurations = project.getConfigurations();
    SortedMap<String, Configuration> configurationsByName = configurations.getAsMap();
    Map<String, Set<File>> artifactsByConfiguration = new HashMap<String, Set<File>>();
    for (Map.Entry<String, Configuration> configurationEntry : configurationsByName.entrySet()) {
        Set<File> files = configurationEntry.getValue().getAllArtifacts().getFiles().getFiles();
        artifactsByConfiguration.put(configurationEntry.getKey(), files);
    }
    moduleVersionModel.setArtifactsByConfiguration(artifactsByConfiguration);
    return moduleVersionModel;
}

@Override
public void execute(Task task) {
    ByteBuddyLogHandler byteBuddyLogHandler = ByteBuddyLogHandler.initialize(project);
    try {
        processOutputDirectory(this.task.getDestinationDir(), this.task.getClasspath());
    } catch (IOException exception) {
        throw new GradleException("Error accessing file system", exception);
    } finally {
        byteBuddyLogHandler.reset();
    }
}

private void createBuildThumbnailTask(Project project) {
    WarPluginConvention warConvention = project.getConvention().getPlugin(WarPluginConvention.class);
    ThemePluginExtension themeExtension = project.getExtensions().getByType(ThemePluginExtension.class);
    Task mergeTask = project.getTasks().getByName(MERGE_THEME_TASK_NAME);
    BuildThumbnail task = project.getTasks().create(BUILD_THUMBNAIL_TASK_NAME, BuildThumbnail.class);
    project.getGradle().addBuildListener(new BuildThumbnailTaskBuildListener(task, themeExtension, warConvention));
    task.dependsOn(mergeTask);
    task.onlyIf(new ThumbnailTaskOnlyIfSpec(themeExtension));
    Task warTask = project.getTasks().getByName(WarPlugin.WAR_TASK_NAME);
    warTask.dependsOn(task);
}

@Override
public void apply(final Project project) {
    Task verifyTask = project.task("verifyModuleDependencies");
    verifyTask.dependsOn("jar");
    project.getTasks().getByName("check").dependsOn(verifyTask);
    verifyTask.doLast(new Action<Task>() {

        @Override
        public void execute(Task task) {
            Jar jar = (Jar) project.getTasks().getByName("jar");
            verifyDependencies(project, jar.getArchivePath());
        }
    });
}

@Override
public void execute(final DataBindingProcessLayoutsTask task) {
    processLayoutsTasks[0] = task;
    task.setXmlProcessor(xmlProcessor);
    task.setSdkDir(sdkDir);
    task.setXmlOutFolder(xmlOutDir);
    task.setMinSdk(minSdkVersion.getApiLevel());
    logD("TASK adding dependency on %s for %s", task, processResTask);
    processResTask.dependsOn(task);
    processResTask.getInputs().dir(xmlOutDir);
    for (Object dep : processResTask.getDependsOn()) {
        if (dep == task) {
            continue;
        }
        logD("adding dependency on %s for %s", dep, task);
        task.dependsOn(dep);
    }
    processResTask.doLast(new Action<Task>() {

        @Override
        public void execute(Task unused) {
            try {
                task.writeLayoutXmls();
            } catch (JAXBException e) {
                logE(e, "cannot write layout xmls %s", ExceptionUtils.getStackTrace(e));
            }
        }
    });
}

@Override
public void execute(Task task) {
    GlobalScope globalScope = variantScope.getGlobalScope();
    File proguardOut = new File(Joiner.on(File.separatorChar).join(String.valueOf(globalScope.getBuildDir()), FD_OUTPUTS, "mapping", variantScope.getVariantConfiguration().getDirName()));
    //为了方便排查,先把configuration打�到目录
    proGuardTransform.printconfiguration(new File(proguardOut, "tmp_config.cfg"));
    final File outConfigFile = new File(proguardOut, "awb_config.cfg");
    //增加awb的�置
    AtlasDependencyTree dependencyTree = AtlasBuildContext.androidDependencyTrees.get(variantScope.getVariantConfiguration().getFullName());
    if (null == dependencyTree) {
        throw new StopExecutionException("DependencyTree cannot be null!");
    }
    if (dependencyTree.getAwbBundles().size() > 0) {
        BaseVariantOutputData vod = appVariantContext.getVariantData().getOutputs().get(0);
        AppVariantOutputContext appVariantOutputContext = getAppVariantOutputContext(appVariantContext, vod);
        File awbObfuscatedDir = new File(globalScope.getIntermediatesDir(), "/classes-proguard/" + variantScope.getVariantConfiguration().getDirName());
        AwbProguardConfiguration awbProguardConfiguration = new AwbProguardConfiguration(appVariantOutputContext.getAwbTransformMap().values(), awbObfuscatedDir, appVariantOutputContext);
        try {
            awbProguardConfiguration.printConfigFile(outConfigFile);
        } catch (IOException e) {
            throw new GradleException("", e);
        }
        proGuardTransform.setConfigurationFiles(new Supplier<Collection<File>>() {

            @Override
            public Collection<File> get() {
                Set<File> proguardFiles = new HashSet<File>();
                ((HashSet<File>) proguardFiles).add(outConfigFile);
                return proguardFiles;
            }
        });
    }
    File mappingFile = null;
    if (null != appVariantContext.apContext.getApExploredFolder() && appVariantContext.apContext.getApExploredFolder().exists()) {
        mappingFile = new File(appVariantContext.apContext.getApExploredFolder(), "mapping.txt");
    } else {
        mappingFile = new File(appVariantContext.getScope().getGlobalScope().getProject().getProjectDir(), "mapping.txt");
    }
    if (null != mappingFile && mappingFile.exists()) {
        proGuardTransform.applyTestedMapping(mappingFile);
    }
}

protected void setDefaultIvyDescriptor() {
    Project project = getProject();
    TaskContainer tasks = project.getTasks();
    Configuration archiveConfig = project.getConfigurations().findByName(Dependency.ARCHIVES_CONFIGURATION);
    if (archiveConfig == null) {
        log.warn("Cannot publish Ivy descriptor if ivyDescriptor not set in task '{}' " + "and no '{}' configuration exists in project '{}'.", Dependency.ARCHIVES_CONFIGURATION, project.getPath());
    } else {
        // Flag to publish the Ivy XML file, but no ivy descriptor file inputted, activate default upload${configuration}.
        // ATTENTION: Tasks not part of the execution graph have withType(Upload.class) false ?!? Need to check for type our self.
        Task candidateUploadTask = tasks.findByName(archiveConfig.getUploadTaskName());
        if (candidateUploadTask == null) {
            log.warn("Cannot publish Ivy descriptor if ivyDescriptor not set in task '{}' " + "and task '{}' does not exist." + "\nAdding \"apply plugin: 'java'\" or any other plugin extending the 'base' plugin" + "will solve this issue.", new Object[] { getPath(), archiveConfig.getUploadTaskName() });
        } else {
            if (!(candidateUploadTask instanceof Upload)) {
                log.warn("Cannot publish Ivy descriptor if ivyDescriptor not set in task '{}' " + "and task '{}' is not an Upload task." + "\nYou'll need to set publishIvy=false or provide a path to the ivy file to " + "publish to solve this issue.", new Object[] { getPath(), archiveConfig.getUploadTaskName() });
            } else {
                Upload uploadTask = (Upload) candidateUploadTask;
                if (!uploadTask.isUploadDescriptor()) {
                    log.info("Forcing task '{}' to upload its Ivy descriptor (uploadDescriptor was false).", uploadTask.getPath());
                    uploadTask.setUploadDescriptor(true);
                }
                artifactoryTask.ivyDescriptor = uploadTask.getDescriptorDestination();
                dependsOn(candidateUploadTask);
            }
        }
    }
}

@Override
public boolean isSatisfiedBy(Task element) {
    return false;
}

@Override
public boolean isSatisfiedBy(Task task) {
    return false;
}

@Override
public Set<? extends Task> getDependencies(Task task) {
    return Collections.emptySet();
}

@Override
public Set<? extends Task> getDependencies(Task task) {
    return Collections.emptySet();
}

@Override
public Set<? extends Task> getDependencies(Task task) {
    return Collections.emptySet();
}

@Override
public Set<? extends Task> getDependencies(Task task) {
    return Collections.emptySet();
}

protected Task getTask() {
    return task;
}

protected Task getTask() {
    return task;
}

public boolean isSatisfiedBy(Task element) {
    return apolloPackageFile.isFile() && isSameCodegenVersion;
}

public Task jarTask(Jar jarTask) {
    this.jarTask = jarTask;
    return this;
}