private void configureApiTool(final Project project) { project.getTasks() .withType(ApiToolTask.class, task -> { ConventionMapping mapping = task.getConventionMapping(); mapping.map("mainClassName", () -> project.getProperties().get("mainClassName")); }); Map<String, Object> options = new HashMap<>(); options.put(Task.TASK_TYPE, ApiToolTask.class); options.put(Task.TASK_DEPENDS_ON, "classes"); options.put(Task.TASK_NAME, "joobyApiTool"); options .put(Task.TASK_DESCRIPTION, "Export your HTTP API to open standards like Swagger and RAML"); options.put(Task.TASK_GROUP, "jooby"); project.getTasks().create(options); }
@Override public TestOptions getTestOptions() { String testTaskName = VariantType.UNIT_TEST_PREFIX + StringUtils.capitalize(getName()) + VariantType.UNIT_TEST_SUFFIX; List<Test> testTasks = ImmutableList.copyOf(getProject().getTasks().withType(Test.class)); Optional<Test> optionalTest = testTasks.stream().filter(test -> test.getName().equals(testTaskName)).findFirst(); List<String> jvmArgs = optionalTest.map(Test::getAllJvmArgs).orElseGet(Collections::<String>emptyList); Map<String, Object> env = optionalTest.map(Test::getEnvironment).orElseGet(Collections::emptyMap); System.getenv().keySet().forEach(env::remove); return new TestOptions(jvmArgs, env); }
private void configureJoobyAssets(final Project project) { project.getTasks() .withType(AssetTask.class, task -> { ConventionMapping mapping = task.getConventionMapping(); mapping.map("env", () -> "dist"); mapping.map("maxAge", () -> "365d"); mapping.map("mainClassName", () -> project.getProperties().get("mainClassName")); mapping.map("output", () -> new JoobyProject(project).classes()); mapping.map("assemblyOutput", () -> new File(project.getBuildDir(), "__public_")); }); Map<String, Object> options = new HashMap<>(); options.put(Task.TASK_TYPE, AssetTask.class); options.put(Task.TASK_DEPENDS_ON, "classes"); options.put(Task.TASK_NAME, "joobyAssets"); options.put(Task.TASK_DESCRIPTION, "Process, optimize and compress static files"); options.put(Task.TASK_GROUP, "jooby"); project.getTasks().create(options); }
.withType(KotlinCompile.class) .stream() .findFirst();
private void configureJoobyRun(final Project project) { 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("srcExtensions", () -> Arrays.asList(".java", ".conf", ".properties", ".kt")); 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); }
clean.doLast(unused -> SpotlessCache.clear()); project.getTasks() .withType(SpotlessTask.class) .all(task -> task.mustRunAfter(clean));
private void _configureTasksExecuteNpm( Project project, final NodeExtension nodeExtension) { TaskContainer taskContainer = project.getTasks(); taskContainer.withType( ExecuteNpmTask.class, new Action<ExecuteNpmTask>() { @Override public void execute(ExecuteNpmTask executeNpmTask) { _configureTaskExecuteNpm(executeNpmTask, nodeExtension); } }); }
private void _configureTasksBuildTheme( Project project, final FileCollection classpath) { TaskContainer taskContainer = project.getTasks(); taskContainer.withType( BuildThemeTask.class, new Action<BuildThemeTask>() { @Override public void execute(BuildThemeTask buildThemeTask) { buildThemeTask.setClasspath(classpath); } }); }
private void configureGwtCompile() { project.getTasks().withType(AbstractGwtCompile.class, new Action<AbstractGwtCompile>() { @Override public void execute(final AbstractGwtCompile task) { task.configure(extension.getCompiler()); } }); }
private void _configureTasksExecuteNpmArgs( Project project, final NodeExtension nodeExtension) { TaskContainer taskContainer = project.getTasks(); taskContainer.withType( ExecuteNpmTask.class, new Action<ExecuteNpmTask>() { @Override public void execute(ExecuteNpmTask executeNpmTask) { _configureTaskExecuteNpmArgs(executeNpmTask, nodeExtension); } }); }
private void _configureTasksNpmInstall( Project project, final NodeExtension nodeExtension) { TaskContainer taskContainer = project.getTasks(); taskContainer.withType( NpmInstallTask.class, new Action<NpmInstallTask>() { @Override public void execute(NpmInstallTask npmInstallTask) { _configureTaskNpmInstall(npmInstallTask, nodeExtension); } }); }
private void applyDeployTask() { this.project.getTasks().create( "deploy", DeployTask.class ); this.project.getTasks().withType( DeployTask.class, task -> task.setHomeDir( ext.getHomeDirProvider() ) ); }
private void ensureBundleInstallRoot() { if (bundleInstallRoot == null) { // TODO Fix bundleInstallRoot = project.getTasks().withType(CreatePackageTask.class).iterator().next().getBundleInstallRoot(); } }
private void configureCompileJJTreeTask(Project project) { CompileJjtreeTask compileJjtreeTask = (CompileJjtreeTask) project.getTasks().findByName(CompileJjtreeTask.TASK_NAME_VALUE); if (compileJjtreeTask == null) { return; } if (!compileJjtreeTask.getSource().isEmpty()) { addJJTreeDependencyToJavaccCompileTask(project.getTasks().withType(JavaCompile.class), project.getTasks().withType(CompileJavaccTask.class), compileJjtreeTask); } }
private void configureTaskRule() { project.getTasks().withType(getCastedTaskType(), task -> { String prunedName = task.getName().replaceFirst(getTaskBaseName(), ""); if (prunedName.isEmpty()) { prunedName = task.getName(); } prunedName = ("" + prunedName.charAt(0)).toLowerCase() + prunedName.substring(1); configureTaskDefaults(task, prunedName); }); }
private void configureCompileDefaults() { _project.getTasks().withType(GosuCompile.class, gosuCompile -> { gosuCompile.getConventionMapping().map("gosuClasspath", () -> { FileCollection cp = gosuCompile.getClasspath(); return cp; }); }); }
private void injectGcloud(Class<? extends GcloudTask> gcloudTask) { project .getTasks() .withType(gcloudTask) .whenTaskAdded( task -> project.afterEvaluate(project -> task.setGcloud(cloudSdkOperations.getGcloud()))); } }
@Override public void apply( Project project ) { project.getPluginManager().apply( KotlinPluginWrapper.class ); project.getTasks().withType( KotlinCompile.class, task -> { task.getKotlinOptions().setJvmTarget( "1.8" ); task.getKotlinOptions().setFreeCompilerArgs( Arrays.asList( "-Xjsr305=strict", "-Xjvm-default=enable" ) ); } ); } }
@Override public void apply( Project project ) { project.getPluginManager().apply( KotlinPluginWrapper.class ); project.getTasks().withType( KotlinCompile.class, task -> { task.getKotlinOptions().setJvmTarget( "1.8" ); task.getKotlinOptions().setFreeCompilerArgs( Collections.singletonList( "-Xjsr305=strict" ) ); } ); DependencyHandler deps = project.getDependencies(); deps.add( DepConstants.IMPL, "org.jetbrains.kotlin:kotlin-stdlib-jdk8" ); deps.add( DepConstants.IMPL, "org.jetbrains.kotlin:kotlin-reflect" ); } }
private void includeSourcesToJar(Project project) { Jar jarTask = project.getTasks() .withType(Jar.class) .getByName("jar"); JavaPluginConvention javaConvention = project.getConvention() .getPlugin(JavaPluginConvention.class); SourceSet mainSourset = javaConvention.getSourceSets() .getByName("main"); jarTask.from(mainSourset.getAllSource()); }