@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); }
public void apply(Project project) { project.getPlugins().apply( "java" ); final HibernateExtension hibernateExtension = new HibernateExtension( project ); project.getLogger().debug( "Adding Hibernate extensions to the build [{}]", project.getName() ); project.getExtensions().add( "hibernate", hibernateExtension ); project.afterEvaluate( new Action<Project>() { @Override public void execute(Project project) { if ( hibernateExtension.enhance != null ) { applyEnhancement( project, hibernateExtension ); } } } ); }
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); }
public static OkBuckExtension getOkBuckExtension(Project project) { return (OkBuckExtension) project.getRootProject().getExtensions().getByName(OkBuckGradlePlugin.OKBUCK); }
public static OkBuckGradlePlugin getPlugin(Project project) { return project.getRootProject().getPlugins().getPlugin(OkBuckGradlePlugin.class); }
@Override public void apply(Project project) { logger.debug("plugin apply"); project.afterEvaluate(this::afterEvaluate); TaskContainer taskContainer = project.getTasks(); autoVersionConfig = project.getExtensions().create("autoversion", AutoVersionConfig.class); taskContainer.create("nextMajor", this::configureNextMajor); taskContainer.create("nextMinor", this::configureNextMinor); taskContainer.create("nextPatch", this::configureNextPatch); }
rootProject.getExtensions().create(OKBUCK, OkBuckExtension.class, rootProject); rootProject.getConfigurations().maybeCreate(TransformManager.CONFIGURATION_TRANSFORM); rootProject.getConfigurations().maybeCreate(FORCED_OKBUCK); rootProject.afterEvaluate( rootBuckProject -> { Task setupOkbuck = rootBuckProject.getTasks().create("setupOkbuck"); setupOkbuck.setGroup(GROUP); setupOkbuck.setDescription("Setup okbuck cache and dependencies"); .getTasks() .create(OKBUCK, OkBuckTask.class, okbuckExt, kotlin, scala, buckFileManager); rootOkBuckTask.dependsOn(setupOkbuck); .getTasks() .create( BUCK_WRAPPER, cacheName -> rootBuckProject .getConfigurations() .maybeCreate(cacheName + "ExtraDepCache"))); .getTasks() .create(OKBUCK_CLEAN, OkBuckCleanTask.class, okbuckExt.buckProjects); rootOkBuckTask.dependsOn(okBuckClean);
@Override public void apply(@NotNull final Project project) { // This plugin builds on the CAGatewayExportBase plugin to define conventions project.getPlugins().apply(CAGatewayImportBase.class); // Add the base plugin to add standard lifecycle tasks: https://docs.gradle.org/current/userguide/standard_plugins.html#sec:base_plugins project.getPlugins().apply("base"); final GatewayImportConnectionProperties gatewayConnectionProperties = project.getExtensions().create("GatewayImportConnection", GatewayImportConnectionProperties.class, project); // Set Defaults project.afterEvaluate(p -> setDefaults(gatewayConnectionProperties)); project.getTasks().create("import-bundle", ImportBundleTask.class, t -> t.setGatewayConnectionProperties(gatewayConnectionProperties)); }
private void createExtension(Project project) { project.getExtensions().create("springBoot", SpringBootExtension.class, project); }
private void configureNebulaResolutionRules(Project project) { Configuration resolutionRulesConfiguration = project.getRootProject().getConfigurations().getAt("resolutionRules"); resolutionRulesConfiguration.getDependencies().add(project.getDependencies().create("com.netflix.nebula:gradle-resolution-rules:0.52.0")); NebulaResolutionRulesExtension resolutionRulesExtension = (NebulaResolutionRulesExtension) project.getExtensions().getByName("nebulaResolutionRules"); resolutionRulesExtension.getOptional().add("slf4j-bridge"); project.afterEvaluate((o) -> { project.getLogger().lifecycle("Optional resolution rules: {}", resolutionRulesExtension.getOptional()); resolutionRulesConfiguration.getDependencies().forEach(dependency -> project.getLogger().lifecycle("Resolution rules dependency: {}", dependency)); }); } }
private static BuildFullBundleTask createBuildFullBundleTask(@NotNull Project project, GatewayDeveloperPluginConfig pluginConfig, BuildDeploymentBundleTask buildDeploymentBundleTask) { // Create build-full-bundle task final BuildFullBundleTask buildFullBundleTask = project.getTasks().create(BUILD_FULL_BUNDLE, BuildFullBundleTask.class, t -> { t.getEnvironmentConfig().set(pluginConfig.getEnvironmentConfig()); t.getDependencyBundles().setFrom(project.getConfigurations().getByName(BUNDLE_CONFIGURATION)); }); project.afterEvaluate(p -> buildFullBundleTask.getOutputBundle().set(new File(pluginConfig.getBuiltEnvironmentBundleDir().getAsFile().get(), p.getName() + '-' + p.getVersion() + "-full.bundle"))); buildFullBundleTask.dependsOn(buildDeploymentBundleTask); return buildFullBundleTask; }
public HensonManager(Project project) { this.project = project; this.logger = project.getLogger(); this.taskManager = new TaskManager(project, logger); this.dependencyManager = new DependencyManager(project, logger); this.hensonExtension = (HensonPluginExtension) project.getExtensions().getByName("henson"); }
public JvmTarget( Project project, String name, String aptConfigurationName, String testAptConfigurationName) { super(project, name); this.aptConfigurationName = aptConfigurationName; this.testAptConfigurationName = testAptConfigurationName; sourceSets = getProject().getConvention().getPlugin(JavaPluginConvention.class).getSourceSets(); isKotlin = project.getPlugins().stream().anyMatch(plugin -> plugin instanceof KotlinBasePluginWrapper); Optional<Task> compileTask = project.getTasks().stream().filter(it -> it instanceof AbstractCompile).findFirst(); if (compileTask.isPresent()) { fakeCompile = (AbstractCompile) compileTask.get(); } else { fakeCompile = null; } }
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); }
@Override public void apply(Project project) { // make sure there's a `clean` task project.getPlugins().apply(BasePlugin.class); // setup the extension spotlessExtension = project.getExtensions().create(EXTENSION, SpotlessExtension.class, project); // after the project has been evaluated, configure the check and format tasks per source set project.afterEvaluate(this::createTasks); }
@Override public File call(Object... obj) { Launch4jPluginExtension ext = ((Launch4jPluginExtension) task.getProject().getExtensions().getByName(Launch4jPlugin.LAUNCH4J_CONFIGURATION_NAME)); return task.getProject().file(task.getProject().getBuildDir() + "/" + ext.getOutputDir() + "/lib"); } });
generateR2 = project.getPlugins().hasPlugin("com.jakewharton.butterknife"); isKotlinAndroid = project.getPlugins().hasPlugin(KotlinAndroidPluginWrapper.class); isKapt = project.getPlugins().hasPlugin(KOTLIN_KAPT_PLUGIN); hasKotlinAndroidExtensions = project.getPlugins().hasPlugin(KOTLIN_ANDROID_EXTENSIONS_MODULE); try { AndroidExtensionsExtension androidExtensions = project.getExtensions().getByType(AndroidExtensionsExtension.class); hasKotlinExtension = hasKotlinAndroidExtensions && androidExtensions.isExperimental(); } catch (Exception ignored) { throw new IllegalStateException( "module `" + project.getName() + "` must specify minSdkVersion and targetSdkVersion in build.gradle"); } else {
@Override public void apply(Project project) { WMRouterExtension extension = project.getExtensions() .create(Const.NAME, WMRouterExtension.class); WMRouterLogger.info("register transform"); project.getExtensions().findByType(BaseExtension.class) .registerTransform(new WMRouterTransform()); project.afterEvaluate(p -> WMRouterLogger.setConfig(extension)); } }
private void configureAppPlugin() { final ApplicationPluginConvention convention = this.project.getConvention().findPlugin( ApplicationPluginConvention.class ); convention.setMainClassName( "io.purplejs.boot.MainApp" ); final JavaExec runTask = (JavaExec) this.project.getTasks().getByName( ApplicationPlugin.TASK_RUN_NAME ); runTask.systemProperty( "io.purplejs.runMode", "dev" ); final String devDirs = new File( this.project.getProjectDir(), "src/main/resources" ).getAbsolutePath(); runTask.systemProperty( "io.purplejs.devSourceDirs", devDirs ); } }
File dir = getProject().getProjectDir(); List<String> excludes = new ArrayList<>(); if (getProject() == getProject().getRootProject()) { excludes.add(".gradle"); relativizeIfSubdir(excludes, dir, getProject().getBuildDir()); for (Project subproject : getProject().getSubprojects()) { relativizeIfSubdir(excludes, dir, subproject.getBuildDir()); return (FileCollection) getProject().fileTree(dir).include((String) target).exclude(excludes); } else { return (FileCollection) getProject().fileTree(dir).include((List<String>) target).exclude(excludes); return getProject().files(target);