use of org.gradle.jvm.tasks.Jar in project gradle by gradle.
the class PublishArtifactToFileBuildOutcomeTransformer method getTypeIdentifier.
private String getTypeIdentifier(PublishArtifact artifact) {
if (artifact instanceof ArchivePublishArtifact) {
ArchivePublishArtifact publishArtifact = (ArchivePublishArtifact) artifact;
AbstractArchiveTask task = publishArtifact.getArchiveTask();
if (task instanceof War) {
return WAR_ARTIFACT.getTypeIdentifier();
} else if (task instanceof Ear) {
return EAR_ARTIFACT.getTypeIdentifier();
} else if (task instanceof Jar) {
return JAR_ARTIFACT.getTypeIdentifier();
} else if (task instanceof Zip) {
return ZIP_ARTIFACT.getTypeIdentifier();
} else if (task instanceof Tar) {
return TAR_ARTIFACT.getTypeIdentifier();
} else {
// we don't know about this kind of archive task
return ARCHIVE_ARTIFACT.getTypeIdentifier();
}
} else {
// The client may try to infer from the file extension.
return UNKNOWN_ARTIFACT.getTypeIdentifier();
}
}
use of org.gradle.jvm.tasks.Jar in project gradle by gradle.
the class PlayDistributionPlugin method createDistributionContentTasks.
@Mutate
void createDistributionContentTasks(ModelMap<Task> tasks, @Path("buildDir") final File buildDir, @Path("distributions") final PlayDistributionContainer distributions, final PlayPluginConfigurations configurations) {
for (final PlayDistribution distribution : distributions.withType(PlayDistribution.class)) {
final PlayApplicationBinarySpec binary = distribution.getBinary();
if (binary == null) {
throw new InvalidUserCodeException(String.format("Play Distribution '%s' does not have a configured Play binary.", distribution.getName()));
}
final File distJarDir = new File(buildDir, "distributionJars/" + distribution.getName());
final String jarTaskName = "create" + StringUtils.capitalize(distribution.getName()) + "DistributionJar";
tasks.create(jarTaskName, Jar.class, new Action<Jar>() {
@Override
public void execute(Jar jar) {
jar.setDescription("Assembles an application jar suitable for deployment for the " + binary + ".");
jar.dependsOn(binary.getTasks().withType(Jar.class));
jar.from(jar.getProject().zipTree(binary.getJarFile()));
jar.setDestinationDir(distJarDir);
jar.setArchiveName(binary.getJarFile().getName());
Map<String, Object> classpath = Maps.newHashMap();
classpath.put("Class-Path", new PlayManifestClasspath(configurations.getPlayRun(), binary.getAssetsJarFile()));
jar.getManifest().attributes(classpath);
}
});
final Task distributionJar = tasks.get(jarTaskName);
final File scriptsDir = new File(buildDir, "scripts/" + distribution.getName());
String createStartScriptsTaskName = "create" + StringUtils.capitalize(distribution.getName() + "StartScripts");
tasks.create(createStartScriptsTaskName, CreateStartScripts.class, new Action<CreateStartScripts>() {
@Override
public void execute(CreateStartScripts createStartScripts) {
createStartScripts.setDescription("Creates OS specific scripts to run the " + binary + ".");
createStartScripts.setClasspath(distributionJar.getOutputs().getFiles());
createStartScripts.setMainClassName("play.core.server.NettyServer");
createStartScripts.setApplicationName(distribution.getName());
createStartScripts.setOutputDir(scriptsDir);
}
});
Task createStartScripts = tasks.get(createStartScriptsTaskName);
CopySpecInternal distSpec = (CopySpecInternal) distribution.getContents();
CopySpec libSpec = distSpec.addChild().into("lib");
libSpec.from(distributionJar);
libSpec.from(binary.getAssetsJarFile());
libSpec.from(configurations.getPlayRun().getAllArtifacts());
libSpec.eachFile(new PrefixArtifactFileNames(configurations.getPlayRun()));
CopySpec binSpec = distSpec.addChild().into("bin");
binSpec.from(createStartScripts);
binSpec.setFileMode(0755);
CopySpec confSpec = distSpec.addChild().into("conf");
confSpec.from("conf").exclude("routes");
distSpec.from("README");
}
}
use of org.gradle.jvm.tasks.Jar in project gradle by gradle.
the class ScalaBasePlugin method configureScalaCompile.
private static void configureScalaCompile(final Project project, JavaBasePlugin javaPlugin, final SourceSet sourceSet) {
String taskName = sourceSet.getCompileTaskName("scala");
final ScalaCompile scalaCompile = project.getTasks().create(taskName, ScalaCompile.class);
scalaCompile.dependsOn(sourceSet.getCompileJavaTaskName());
javaPlugin.configureForSourceSet(sourceSet, scalaCompile);
Convention scalaConvention = (Convention) InvokerHelper.getProperty(sourceSet, "convention");
ScalaSourceSet scalaSourceSet = scalaConvention.findPlugin(ScalaSourceSet.class);
scalaCompile.setDescription("Compiles the " + scalaSourceSet.getScala() + ".");
scalaCompile.setSource(scalaSourceSet.getScala());
project.getTasks().getByName(sourceSet.getClassesTaskName()).dependsOn(taskName);
// cannot use convention mapping because the resulting object won't be serializable
// cannot compute at task execution time because we need association with source set
project.getGradle().addBuildListener(new BuildAdapter() {
@Override
public void projectsEvaluated(Gradle gradle) {
IncrementalCompileOptions incrementalOptions = scalaCompile.getScalaCompileOptions().getIncrementalOptions();
if (incrementalOptions.getAnalysisFile() == null) {
String analysisFilePath = project.getBuildDir().getPath() + "/tmp/scala/compilerAnalysis/" + scalaCompile.getName() + ".analysis";
incrementalOptions.setAnalysisFile(new File(analysisFilePath));
}
if (incrementalOptions.getPublishedCode() == null) {
Jar jarTask = (Jar) project.getTasks().findByName(sourceSet.getJarTaskName());
incrementalOptions.setPublishedCode(jarTask == null ? null : jarTask.getArchivePath());
}
}
});
}
Aggregations