import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
@Override
public void triggerWhenEmptyActionsIfNecessary() {
    if (!defaultDependencyActions.isEmpty()) {
        for (Action<? super DependencySet> action : defaultDependencyActions) {
            if (!dependencies.isEmpty()) {
                break;
            }
            action.execute(dependencies);
        }
    }
    // Discard actions
    defaultDependencyActions.clear();
    for (Configuration superConfig : extendsFrom) {
        ((ConfigurationInternal) superConfig).triggerWhenEmptyActionsIfNecessary();
    }
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
/**
 * Configures the classpath for Jacoco tasks using the 'jacocoAnt' configuration. Uses the version information declared in 'toolVersion' of the Jacoco extension if no dependencies are explicitly
 * declared.
 *
 * @param extension the JacocoPluginExtension
 */
private void configureTaskClasspathDefaults(final JacocoPluginExtension extension) {
    final Configuration config = this.project.getConfigurations().getAt(ANT_CONFIGURATION_NAME);
    project.getTasks().withType(JacocoBase.class, new Action<JacocoBase>() {
        @Override
        public void execute(JacocoBase task) {
            ((IConventionAware) task).getConventionMapping().map("jacocoClasspath", Callables.returning(config));
        }
    });
    config.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet dependencies) {
            dependencies.add(project.getDependencies().create("org.jacoco:org.jacoco.ant:" + extension.getToolVersion()));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private Collection<File> listProjectDepsSrcDirs(Project project) {
	ConfigurationContainer configs = project.getConfigurations();
	Configuration compileConf = configs.getByName(JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME);
	DependencySet depSet = compileConf.getAllDependencies();

	List<File> result = Lists.newArrayList();
	for (Dependency dep : depSet) {
		if (dep instanceof ProjectDependency) {
			Project projectDependency = ((ProjectDependency) dep).getDependencyProject();
			if (projectDependency.getPlugins().hasPlugin(PwtLibPlugin.class)) {
				JavaPluginConvention javaConvention = projectDependency.getConvention().getPlugin(JavaPluginConvention.class);
				SourceSet mainSourceSet = javaConvention.getSourceSets().getByName(SourceSet.MAIN_SOURCE_SET_NAME);

				result.addAll(mainSourceSet.getAllSource().getSrcDirs());
			}
		}
	}
	return result;
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private void addConfiguration(final Project project, final SonarRunnerRootExtension rootExtension) {
    final Configuration configuration = project.getConfigurations().create(SonarRunnerExtension.SONAR_RUNNER_CONFIGURATION_NAME);
    configuration
            .setVisible(false)
            .setTransitive(false)
            .setDescription("The SonarRunner configuration to use to run analysis")
            .getIncoming()
            .beforeResolve(new Action<ResolvableDependencies>() {
                public void execute(ResolvableDependencies resolvableDependencies) {
                    DependencySet dependencies = resolvableDependencies.getDependencies();
                    if (dependencies.isEmpty()) {
                        String toolVersion = rootExtension.getToolVersion();
                        DependencyHandler dependencyHandler = project.getDependencies();
                        Dependency dependency = dependencyHandler.create("org.codehaus.sonar.runner:sonar-runner-dist:" + toolVersion);
                        configuration.getDependencies().add(dependency);
                    }
                }
            });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private Set<ResolvedDependency> doResolve(final Collection<ArtifactSpec> deps) {
    final Configuration config = this.project.getConfigurations().detachedConfiguration();
    final DependencySet dependencySet = config.getDependencies();

    deps.forEach(spec -> {
        final DefaultExternalModuleDependency d =
                new DefaultExternalModuleDependency(spec.groupId(), spec.artifactId(), spec.version());
        final DefaultDependencyArtifact da =
                new DefaultDependencyArtifact(spec.artifactId(), spec.type(), spec.type(), spec.classifier(), null);
        d.addArtifact(da);
        d.getExcludeRules().add(new DefaultExcludeRule());
        dependencySet.add(d);
    });

    return config.getResolvedConfiguration().getFirstLevelModuleDependencies();
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private static void dependencies(Node node, Project project) {
    final Configuration runtime = project.getConfigurations().findByName("runtime");
    if (runtime != null) {
        final DependencySet allDependencies = runtime.getAllDependencies();
        if (!allDependencies.isEmpty()) {
            final Node dependenciesNode = node.appendNode("dependencies");
            for (Dependency dependency : allDependencies) {
                if (dependency.getGroup() != null) {
                    final Node dependencyNode = dependenciesNode.appendNode("dependency");
                    dependencyNode.appendNode("groupId", dependency.getGroup());
                    dependencyNode.appendNode("artifactId", dependency.getName());
                    dependencyNode.appendNode("version", dependency.getVersion());
                }
                else {
                    LOG.warn("There is a \"null\" dependency (likely pointing directly to a file): ignoring it for the POM generation for {}", project);
                }
            }
        }
        else {
            LOG.info("There are no dependencies in the \"runtime\" configuration for {}", project);
        }
    }
    else {
        LOG.info("There is no \"runtime\" configuration, so not adding any dependencies to the generated POM for {}", project);
    }
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private void configureDefaultDependencies(Configuration configuration) {
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet dependencies) {
            dependencies.add(project.getDependencies().create("jdepend:jdepend:" + extension.getToolVersion()));
            dependencies.add(project.getDependencies().create("org.apache.ant:ant-jdepend:1.9.6"));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private void configureDefaultDependencies(Configuration configuration) {
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet dependencies) {
            VersionNumber version = VersionNumber.parse(extension.getToolVersion());
            String dependency = calculateDefaultDependencyNotation(version);
            dependencies.add(project.getDependencies().create(dependency));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private void configureDefaultDependencies(Configuration configuration) {
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet dependencies) {
            dependencies.add(project.getDependencies().create("com.google.code.findbugs:findbugs:" + extension.getToolVersion()));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private void configureDefaultDependencies(Configuration configuration) {
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet dependencies) {
            dependencies.add(project.getDependencies().create("com.puppycrawl.tools:checkstyle:" + extension.getToolVersion()));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private void configureDefaultDependencies(Configuration configuration) {
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet dependencies) {
            dependencies.add(project.getDependencies().create("org.codenarc:CodeNarc:" + extension.getToolVersion()));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
public void configureDefaultRhinoDependency(Configuration configuration, final DependencyHandler dependencyHandler, final RhinoExtension extension) {
    configuration.defaultDependencies(new Action<DependencySet>() {
        public void execute(DependencySet dependencies) {
            Dependency dependency = dependencyHandler.create(RhinoExtension.DEFAULT_RHINO_DEPENDENCY_GROUP + ":" + RhinoExtension.DEFAULT_RHINO_DEPENDENCY_MODULE + ":" + extension.getVersion());
            dependencies.add(dependency);
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
public Configuration addConfiguration(ConfigurationContainer configurations, final DependencyHandler dependencies, final JsHintExtension extension) {
    Configuration configuration = configurations.create(JsHintExtension.CONFIGURATION_NAME);
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet configDependencies) {
            String notation = JsHintExtension.DEFAULT_DEPENDENCY_GROUP + ":" + JsHintExtension.DEFAULT_DEPENDENCY_MODULE + ":" + extension.getVersion() + "@js";
            Dependency dependency = dependencies.create(notation);
            configDependencies.add(dependency);
        }
    });
    return configuration;
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
public Configuration addConfiguration(ConfigurationContainer configurations, final DependencyHandler dependencies, final EnvJsExtension extension) {
    Configuration configuration = configurations.create(EnvJsExtension.CONFIGURATION_NAME);
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet configDependencies) {
            String notation = EnvJsExtension.DEFAULT_DEPENDENCY_GROUP + ":" + EnvJsExtension.DEFAULT_DEPENDENCY_MODULE + ":" + extension.getVersion() + "@js";
            Dependency dependency = dependencies.create(notation);
            configDependencies.add(dependency);
        }

    });
    return configuration;
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private Configuration addJsConfiguration(ConfigurationContainer configurations, final DependencyHandler dependencies, final CoffeeScriptExtension extension) {
    Configuration configuration = configurations.create(CoffeeScriptExtension.JS_CONFIGURATION_NAME);
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet configDependencies) {
            String notation = CoffeeScriptExtension.DEFAULT_JS_DEPENDENCY_GROUP + ":" + CoffeeScriptExtension.DEFAULT_JS_DEPENDENCY_MODULE + ":" + extension.getVersion() + "@js";
            Dependency dependency = dependencies.create(notation);
            configDependencies.add(dependency);
        }
    });
    return configuration;
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
/**
 * 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()));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private Map<String, DependencyExtraInfo> getExtraMap() {

        Map<String, DependencyExtraInfo> dependencyExtraInfoMap = new HashMap<>();

        DependencySet dependencies = project.getConfigurations().getByName("compile").getDependencies();

        dependencies.forEach(new Consumer<Dependency>() {
            @Override
            public void accept(Dependency dependency) {

                String group = dependency.getGroup();
                String name = dependency.getName();
                String scope = "compile";
                String type = "";
                if (dependency instanceof DefaultProjectDependency) {
                    DefaultProjectDependency projectDependency = (DefaultProjectDependency)dependency;
                    if (projectDependency.getDependencyProject().getPlugins().hasPlugin(LibraryPlugin.class)) {
                        type = "aar";
                    }
                }

                dependencyExtraInfoMap.put(group + ":" + name, new DependencyExtraInfo(type, scope));

            }
        });

        return dependencyExtraInfoMap;

    }
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private Collection<ResolvedArtifact> doResolve(final Collection<ArtifactSpec> deps, boolean transitive) {
    final Configuration config = this.project.getConfigurations().detachedConfiguration().setTransitive(transitive);
    final DependencySet dependencySet = config.getDependencies();

    deps.forEach(spec -> {
        if (projects.containsKey(spec.groupId() + ":" + spec.artifactId() + ":" + spec.version())) {
            dependencySet.add(new DefaultProjectDependency((ProjectInternal) projects.get(spec.groupId() + ":" + spec.artifactId() + ":" + spec.version()), new DefaultProjectAccessListener(), false));
        } else {
            final DefaultExternalModuleDependency d =
                    new DefaultExternalModuleDependency(spec.groupId(), spec.artifactId(), spec.version());
            final DefaultDependencyArtifact da =
                    new DefaultDependencyArtifact(spec.artifactId(), spec.type(), spec.type(), spec.classifier(), null);
            d.addArtifact(da);
            dependencySet.add(d);
        }
    });

    if (transitive) {
        return config
                .getResolvedConfiguration()
                .getResolvedArtifacts();
    }

    return config
            .getResolvedConfiguration()
            .getFirstLevelModuleDependencies()
            .stream()
            .map(dep -> dep.getModuleArtifacts())
            .flatMap(artifacts -> artifacts.stream())
            .collect(Collectors.toList());
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
private void configureDefaultJavaccDependency(final Project project, Configuration configuration) {
    configuration.defaultDependencies(new Action<DependencySet>() {
        @Override
        public void execute(DependencySet dependencies) {
            dependencies.add(project.getDependencies().create("net.java.dev.javacc:javacc:6.1.2"));
        }
    });
}
 

import org.gradle.api.artifacts.DependencySet; //导入依赖的package包/类
public TasksFromProjectDependencies(String taskName, DependencySet dependencies, ProjectAccessListener projectAccessListener) {
    this.taskName = taskName;
    this.dependencies = dependencies;
    this.projectAccessListener = projectAccessListener;
}