Examples with Jar org.gradle.api.tasks.bundling.Jar used on opensource projects

Example 11 with Jar

use of org.gradle.api.tasks.bundling.Jar in project rest.li by linkedin.

the class PegasusPlugin method configureRestClientGeneration.

// Generate rest client from idl files generated from java source files in the specified source set.
// 
// This generates rest client source files from idl file generated from java source files
// in the source set. The generated rest client source files will be in a new source set.
// It also compiles the rest client source files into classes, and creates both the
// rest model and rest client jar files.
// 
@SuppressWarnings("deprecation")
protected void configureRestClientGeneration(Project project, SourceSet sourceSet) {
    // idl directory for api project
    File idlDir = project.file(getIdlPath(project, sourceSet));
    if (SharedFileUtils.getSuffixedFiles(project, idlDir, IDL_FILE_SUFFIX).isEmpty()) {
        return;
    }
    File generatedRestClientDir = project.file(getGeneratedDirPath(project, sourceSet, REST_GEN_TYPE) + File.separatorChar + "java");
    // always include imported data template jars in compileClasspath of rest client
    FileCollection dataModelConfig = getDataModelConfig(project, sourceSet);
    // if data templates generated from this source set, add the generated data template jar to compileClasspath
    // of rest client.
    String dataTemplateSourceSetName = getGeneratedSourceSetName(sourceSet, DATA_TEMPLATE_GEN_TYPE);
    Jar dataTemplateJarTask = null;
    SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
    FileCollection dataModels;
    if (sourceSets.findByName(dataTemplateSourceSetName) != null) {
        if (debug) {
            System.out.println("sourceSet " + sourceSet.getName() + " has generated sourceSet " + dataTemplateSourceSetName);
        }
        dataTemplateJarTask = (Jar) project.getTasks().getByName(sourceSet.getName() + "DataTemplateJar");
        // FIXME change to #getArchiveFile(); breaks backwards-compatibility before 5.1
        dataModels = dataModelConfig.plus(project.files(dataTemplateJarTask.getArchivePath()));
    } else {
        dataModels = dataModelConfig;
    }
    // create source set for generated rest model, rest client source and class files.
    String targetSourceSetName = getGeneratedSourceSetName(sourceSet, REST_GEN_TYPE);
    SourceSet targetSourceSet = sourceSets.create(targetSourceSetName, ss -> {
        ss.java(sourceDirectorySet -> sourceDirectorySet.srcDir(generatedRestClientDir));
        ss.setCompileClasspath(dataModels.plus(project.getConfigurations().getByName("restClientCompile")));
    });
    project.getPlugins().withType(EclipsePlugin.class, eclipsePlugin -> {
        EclipseModel eclipseModel = (EclipseModel) project.getExtensions().findByName("eclipse");
        eclipseModel.getClasspath().getPlusConfigurations().add(project.getConfigurations().getByName("restClientCompile"));
    });
    // idea plugin needs to know about new rest client source directory and its dependencies
    addGeneratedDir(project, targetSourceSet, Arrays.asList(getDataModelConfig(project, sourceSet), project.getConfigurations().getByName("restClientCompile")));
    // generate the rest client source files
    GenerateRestClientTask generateRestClientTask = project.getTasks().create(targetSourceSet.getTaskName("generate", "restClient"), GenerateRestClientTask.class, task -> {
        task.dependsOn(project.getConfigurations().getByName("dataTemplate"));
        task.setInputDir(idlDir);
        task.setResolverPath(dataModels.plus(project.getConfigurations().getByName("restClientCompile")));
        task.setRuntimeClasspath(project.getConfigurations().getByName("dataModel").plus(project.getConfigurations().getByName("dataTemplate").getArtifacts().getFiles()));
        task.setCodegenClasspath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
        task.setDestinationDir(generatedRestClientDir);
        task.setRestli2FormatSuppressed(project.hasProperty(SUPPRESS_REST_CLIENT_RESTLI_2));
        task.setRestli1FormatSuppressed(project.hasProperty(SUPPRESS_REST_CLIENT_RESTLI_1));
        if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
            task.setEnableArgFile(true);
        }
        if (isPropertyTrue(project, CODE_GEN_PATH_CASE_SENSITIVE)) {
            task.setGenerateLowercasePath(false);
        }
        if (isPropertyTrue(project, ENABLE_FLUENT_API)) {
            task.setGenerateFluentApi(true);
        }
        task.doFirst(new CacheableAction<>(t -> project.delete(generatedRestClientDir)));
    });
    if (dataTemplateJarTask != null) {
        generateRestClientTask.dependsOn(dataTemplateJarTask);
    }
    // TODO: Tighten the types so that _generateSourcesJarTask must be of type Jar.
    ((Jar) _generateSourcesJarTask).from(generateRestClientTask.getDestinationDir());
    _generateSourcesJarTask.dependsOn(generateRestClientTask);
    _generateJavadocTask.source(generateRestClientTask.getDestinationDir());
    _generateJavadocTask.setClasspath(_generateJavadocTask.getClasspath().plus(project.getConfigurations().getByName("restClientCompile")).plus(generateRestClientTask.getResolverPath()));
    _generateJavadocTask.dependsOn(generateRestClientTask);
    // make sure rest client source files have been generated before compiling them
    JavaCompile compileGeneratedRestClientTask = (JavaCompile) project.getTasks().getByName(targetSourceSet.getCompileJavaTaskName());
    compileGeneratedRestClientTask.dependsOn(generateRestClientTask);
    compileGeneratedRestClientTask.getOptions().getCompilerArgs().add("-Xlint:-deprecation");
    // create the rest model jar file
    Task restModelJarTask = project.getTasks().create(sourceSet.getName() + "RestModelJar", Jar.class, task -> {
        task.from(idlDir, copySpec -> {
            copySpec.eachFile(fileCopyDetails -> project.getLogger().info("Add idl file: {}", fileCopyDetails));
            copySpec.setIncludes(Collections.singletonList('*' + IDL_FILE_SUFFIX));
        });
        // FIXME change to #getArchiveAppendix().set(...); breaks backwards-compatibility before 5.1
        task.setAppendix(getAppendix(sourceSet, "rest-model"));
        task.setDescription("Generate rest model jar");
    });
    // create the rest client jar file
    Task restClientJarTask = project.getTasks().create(sourceSet.getName() + "RestClientJar", Jar.class, task -> {
        task.dependsOn(compileGeneratedRestClientTask);
        task.from(idlDir, copySpec -> {
            copySpec.eachFile(fileCopyDetails -> {
                project.getLogger().info("Add interface file: {}", fileCopyDetails);
                fileCopyDetails.setPath("idl" + File.separatorChar + fileCopyDetails.getPath());
            });
            copySpec.setIncludes(Collections.singletonList('*' + IDL_FILE_SUFFIX));
        });
        task.from(targetSourceSet.getOutput());
        // FIXME change to #getArchiveAppendix().set(...); breaks backwards-compatibility before 5.1
        task.setAppendix(getAppendix(sourceSet, "rest-client"));
        task.setDescription("Generate rest client jar");
    });
    // add the rest model jar and the rest client jar to the list of project artifacts.
    if (!isTestSourceSet(sourceSet)) {
        project.getArtifacts().add("restModel", restModelJarTask);
        project.getArtifacts().add("restClient", restClientJarTask);
    } else {
        project.getArtifacts().add("testRestModel", restModelJarTask);
        project.getArtifacts().add("testRestClient", restClientJarTask);
    }
}

Example 12 with Jar

use of org.gradle.api.tasks.bundling.Jar in project rest.li by linkedin.

the class PegasusPlugin method configureAvroSchemaGeneration.

@SuppressWarnings("deprecation")
protected void configureAvroSchemaGeneration(Project project, SourceSet sourceSet) {
    File dataSchemaDir = project.file(getDataSchemaPath(project, sourceSet));
    File avroDir = project.file(getGeneratedDirPath(project, sourceSet, AVRO_SCHEMA_GEN_TYPE) + File.separatorChar + "avro");
    // generate avro schema files from data schema
    Task generateAvroSchemaTask = project.getTasks().create(sourceSet.getTaskName("generate", "avroSchema"), GenerateAvroSchemaTask.class, task -> {
        task.setInputDir(dataSchemaDir);
        task.setDestinationDir(avroDir);
        task.setResolverPath(getDataModelConfig(project, sourceSet));
        task.setCodegenClasspath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
        if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
            task.setEnableArgFile(true);
        }
        task.onlyIf(t -> {
            if (task.getInputDir().exists()) {
                @SuppressWarnings("unchecked") Map<String, PegasusOptions> pegasusOptions = (Map<String, PegasusOptions>) project.getExtensions().getExtraProperties().get("pegasus");
                if (pegasusOptions.get(sourceSet.getName()).hasGenerationMode(PegasusOptions.GenerationMode.AVRO)) {
                    return true;
                }
            }
            return !project.getConfigurations().getByName("avroSchemaGenerator").isEmpty();
        });
        task.doFirst(new CacheableAction<>(t -> deleteGeneratedDir(project, sourceSet, AVRO_SCHEMA_GEN_TYPE)));
    });
    project.getTasks().getByName(sourceSet.getCompileJavaTaskName()).dependsOn(generateAvroSchemaTask);
    // create avro schema jar file
    Task avroSchemaJarTask = project.getTasks().create(sourceSet.getName() + "AvroSchemaJar", Jar.class, task -> {
        // add path prefix to each file in the data schema directory
        task.from(avroDir, copySpec -> copySpec.eachFile(fileCopyDetails -> fileCopyDetails.setPath("avro" + File.separatorChar + fileCopyDetails.getPath())));
        // FIXME change to #getArchiveAppendix().set(...); breaks backwards-compatibility before 5.1
        task.setAppendix(getAppendix(sourceSet, "avro-schema"));
        task.setDescription("Generate an avro schema jar");
    });
    if (!isTestSourceSet(sourceSet)) {
        project.getArtifacts().add("avroSchema", avroSchemaJarTask);
    } else {
        project.getArtifacts().add("testAvroSchema", avroSchemaJarTask);
    }
}

Example 13 with Jar

use of org.gradle.api.tasks.bundling.Jar in project gradle by gradle.

the class DefaultJvmVariantBuilder method configureDocumentationVariantWithArtifact.

public void configureDocumentationVariantWithArtifact(String variantName, @Nullable String name, @Nullable String displayName, String docsType, String jarTaskName, Object artifactSource, @Nullable AdhocComponentWithVariants component) {
    Configuration variant = configurations.maybeCreate(variantName);
    variant.setVisible(false);
    variant.setDescription(docsType + " elements for " + (displayName == null ? "main" : displayName) + ".");
    variant.setCanBeResolved(false);
    variant.setCanBeConsumed(true);
    jvmPluginServices.configureAttributes(variant, attributes -> attributes.documentation(docsType).runtimeUsage().withExternalDependencies());
    capabilities.forEach(variant.getOutgoing()::capability);
    if (!tasks.getNames().contains(jarTaskName)) {
        TaskProvider<Jar> jarTask = tasks.register(jarTaskName, Jar.class, jar -> {
            jar.setDescription("Assembles a jar archive containing the " + (displayName == null ? "main " + docsType + "." : (docsType + " of the '" + displayName + "'.")));
            jar.setGroup(BasePlugin.BUILD_GROUP);
            jar.from(artifactSource);
            jar.getArchiveClassifier().set(TextUtil.camelToKebabCase(name == null ? docsType : (name + "-" + docsType)));
        });
        if (tasks.getNames().contains(LifecycleBasePlugin.ASSEMBLE_TASK_NAME)) {
            tasks.named(LifecycleBasePlugin.ASSEMBLE_TASK_NAME).configure(task -> task.dependsOn(jarTask));
        }
    }
    TaskProvider<Task> jar = tasks.named(jarTaskName);
    variant.getOutgoing().artifact(new LazyPublishArtifact(jar, project.getFileResolver()));
    if (published && component != null) {
        component.addVariantsFromConfiguration(variant, new JavaConfigurationVariantMapping("runtime", true));
    }
}

Example 14 with Jar

use of org.gradle.api.tasks.bundling.Jar in project gradle by gradle.

the class JvmPluginsHelper method configureDocumentationVariantWithArtifact.

public static void configureDocumentationVariantWithArtifact(String variantName, @Nullable String featureName, String docsType, List<Capability> capabilities, String jarTaskName, Object artifactSource, @Nullable AdhocComponentWithVariants component, ConfigurationContainer configurations, TaskContainer tasks, ObjectFactory objectFactory, FileResolver fileResolver) {
    Configuration variant = maybeCreateInvisibleConfig(configurations, variantName, docsType + " elements for " + (featureName == null ? "main" : featureName) + ".", true);
    AttributeContainer attributes = variant.getAttributes();
    attributes.attribute(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, Usage.JAVA_RUNTIME));
    attributes.attribute(Category.CATEGORY_ATTRIBUTE, objectFactory.named(Category.class, Category.DOCUMENTATION));
    attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, objectFactory.named(Bundling.class, Bundling.EXTERNAL));
    attributes.attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objectFactory.named(DocsType.class, docsType));
    capabilities.forEach(variant.getOutgoing()::capability);
    if (!tasks.getNames().contains(jarTaskName)) {
        TaskProvider<Jar> jarTask = tasks.register(jarTaskName, Jar.class, jar -> {
            jar.setDescription("Assembles a jar archive containing the " + (featureName == null ? "main " + docsType + "." : (docsType + " of the '" + featureName + "' feature.")));
            jar.setGroup(BasePlugin.BUILD_GROUP);
            jar.from(artifactSource);
            jar.getArchiveClassifier().set(camelToKebabCase(featureName == null ? docsType : (featureName + "-" + docsType)));
        });
        if (tasks.getNames().contains(LifecycleBasePlugin.ASSEMBLE_TASK_NAME)) {
            tasks.named(LifecycleBasePlugin.ASSEMBLE_TASK_NAME).configure(task -> task.dependsOn(jarTask));
        }
    }
    TaskProvider<Task> jar = tasks.named(jarTaskName);
    variant.getOutgoing().artifact(new LazyPublishArtifact(jar, fileResolver));
    if (component != null) {
        component.addVariantsFromConfiguration(variant, new JavaConfigurationVariantMapping("runtime", true));
    }
}

Example 15 with Jar

use of org.gradle.api.tasks.bundling.Jar in project gradle by gradle.

the class JavaGradlePluginPlugin method configureJarTask.

private void configureJarTask(Project project, GradlePluginDevelopmentExtension extension) {
    Jar jarTask = (Jar) project.getTasks().getByName(JAR_TASK);
    List<PluginDescriptor> descriptors = new ArrayList<PluginDescriptor>();
    Set<String> classList = new HashSet<String>();
    PluginDescriptorCollectorAction pluginDescriptorCollector = new PluginDescriptorCollectorAction(descriptors);
    ClassManifestCollectorAction classManifestCollector = new ClassManifestCollectorAction(classList);
    PluginValidationAction pluginValidationAction = new PluginValidationAction(extension.getPlugins(), descriptors, classList);
    jarTask.filesMatching(PLUGIN_DESCRIPTOR_PATTERN, pluginDescriptorCollector);
    jarTask.filesMatching(CLASSES_PATTERN, classManifestCollector);
    jarTask.appendParallelSafeAction(pluginValidationAction);
}