Java EclipseClasspath类代码示例

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
/**
 * @param eclipseClasspath
 * @param eclipseConfigPlugin
 * @param configurations
 */
@Finalize
public void finalizeEclipseClasspathTask(@Each GenerateEclipseClasspath eclipseClasspath,
        EclipseConfigPlugin eclipseConfigPlugin, ConfigurationContainer configurations) {
    EclipseClasspath classpath = eclipseClasspath.getClasspath();

    Configuration integrationCompileConfiguration = configurations.getAsMap()
            .get(JavaConfigPlugin.INTEGRATION_COMPILE_CLASSPATH_CONFIGURATION);

    if (integrationCompileConfiguration != null) {
        classpath.getPlusConfigurations().add(integrationCompileConfiguration);
    }

    Configuration integrationRuntimeConfiguration = configurations.getAsMap()
            .get(JavaConfigPlugin.INTEGRATION_RUNTIME_CLASSPATH_CONFIGURATION);

    if (integrationRuntimeConfiguration != null) {
        classpath.getPlusConfigurations().add(integrationRuntimeConfiguration);
    }

    classpath.getFile().whenMerged((Classpath c) -> {
        c.getEntries().removeIf(e -> (e instanceof Library)
                && Files.getFileExtension(((Library) e).getPath()).equalsIgnoreCase("pom"));
    });
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
public List<ClasspathEntry> createSourceFolders(final EclipseClasspath classpath) {
    List<ClasspathEntry> entries = Lists.newArrayList();
    Function<File, String> provideRelativePath = new Function<File, String>() {
        @Override
        public String apply(File input) {
            return classpath.getProject().relativePath(input);
        }
    };
    List<SourceFolder> regulars = getRegularSourceFolders(classpath.getSourceSets(), provideRelativePath);
    List<SourceFolder> trimmedExternals = getExternalSourceFolders(classpath.getSourceSets(), provideRelativePath);
    entries.addAll(regulars);
    entries.addAll(trimmedExternals);
    return entries;
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
public List<Library> create(EclipseClasspath classpath) {
    List<Library> out = new LinkedList<Library>();
    FileReferenceFactory fileReferenceFactory = classpath.getFileReferenceFactory();

    if(classpath.getClassFolders() != null) {
        for (File folder : classpath.getClassFolders()) {
            Library library = new Library(fileReferenceFactory.fromFile(folder));
            library.setExported(true);
            out.add(library);
        }
    }

    return out;
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
private static AbstractLibrary createLibraryEntry(File binary, File source, File javadoc, EclipseClasspath classpath, ModuleVersionIdentifier id) {
    FileReferenceFactory referenceFactory = classpath.getFileReferenceFactory();

    FileReference binaryRef = referenceFactory.fromFile(binary);
    FileReference sourceRef = referenceFactory.fromFile(source);
    FileReference javadocRef = referenceFactory.fromFile(javadoc);

    final AbstractLibrary out = binaryRef.isRelativeToPathVariable() ? new Variable(binaryRef) : new Library(binaryRef);

    out.setJavadocPath(javadocRef);
    out.setSourcePath(sourceRef);
    out.setExported(false);
    out.setModuleVersion(id);
    return out;
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
/**
 * Configure the Eclipse classpath task
 *
 * @param eclipseClasspath Eclipse classpath task to configure
 * @param eclipseConfigPlugin Eclipse configuration plugin to configure task
 */
@Mutate
public void configureEclipseClasspathTask(@Each GenerateEclipseClasspath eclipseClasspath,
        EclipseConfigPlugin eclipseConfigPlugin) {
    EclipseClasspath classpath = eclipseClasspath.getClasspath();

    classpath.setDownloadSources(true);
    classpath.setDownloadJavadoc(true);
    classpath.getContainers().remove(EclipseWtpPlugin.WEB_LIBS_CONTAINER);
    classpath.getFile().withXml(xml -> eclipseConfigPlugin.configureClasspathXml(Validate.notNull(xml)));
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
private void configureEclipseClasspath(final Project project, final EclipseModel model) {
    model.setClasspath(instantiator.newInstance(EclipseClasspath.class, project));
    ((IConventionAware) model.getClasspath()).getConventionMapping().map("defaultOutputDir", new Callable<File>() {
        @Override
        public File call() {
            return new File(project.getProjectDir(), "bin");
        }

    });

    final EclipsePlugin eclipsePlugin = this;
    project.getPlugins().withType(JavaBasePlugin.class, new Action<JavaBasePlugin>() {
        @Override
        public void execute(JavaBasePlugin javaBasePlugin) {
            maybeAddTask(project, eclipsePlugin, ECLIPSE_CP_TASK_NAME, GenerateEclipseClasspath.class, new Action<GenerateEclipseClasspath>() {
                @Override
                public void execute(final GenerateEclipseClasspath task) {
                    //task properties:
                    task.setDescription("Generates the Eclipse classpath file.");
                    task.setInputFile(project.file(".classpath"));
                    task.setOutputFile(project.file(".classpath"));

                    //model properties:
                    task.setClasspath(model.getClasspath());
                    task.getClasspath().setFile(new XmlFileContentMerger(task.getXmlTransformer()));
                    task.getClasspath().setSourceSets(project.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets());

                    AfterEvaluateHelper.afterEvaluateOrExecute(project, new Action<Project>() {
                        @Override
                        public void execute(Project p) {
                            // keep the ordering we had in earlier gradle versions
                            Set<String> containers = Sets.newLinkedHashSet();
                            containers.add("org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/" + model.getJdt().getJavaRuntimeName() + "/");
                            containers.addAll(task.getClasspath().getContainers());
                            task.getClasspath().setContainers(containers);
                        }

                    });

                    project.getPlugins().withType(JavaPlugin.class, new Action<JavaPlugin>() {
                        @Override
                        public void execute(JavaPlugin javaPlugin) {
                            configureJavaClasspath(project, task);
                        }

                    });

                    configureScalaDependencies(project, task);
                }

            });
        }

    });
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
public EclipseDependenciesCreator(EclipseClasspath classpath) {
    this.dependenciesExtractor = new IdeDependenciesExtractor();
    this.classpath = classpath;
    ServiceRegistry serviceRegistry = ((ProjectInternal) classpath.getProject()).getServices();
    this.projectDependencyBuilder = new ProjectDependencyBuilder(CompositeBuildIdeProjectResolver.from(serviceRegistry));
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
public ClasspathFactory(EclipseClasspath classpath) {
    this.classpath = classpath;
    this.dependenciesCreator = new EclipseDependenciesCreator(classpath);
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
/**
 * The Eclipse Classpath model containing the information required to generate the classpath file.
 */
@Internal
public EclipseClasspath getClasspath() {
    return classpath;
}
 

import org.gradle.plugins.ide.eclipse.model.EclipseClasspath; //导入依赖的package包/类
public void setClasspath(EclipseClasspath classpath) {
    this.classpath = classpath;
}