private void _configureTaskTranspileJSForJavaPlugin(TranspileJSTask transpileJSTask) {

    transpileJSTask.mustRunAfter(JavaPlugin.PROCESS_RESOURCES_TASK_NAME);

    Project project = transpileJSTask.getProject();

    final SourceSet sourceSet = GradleUtil.getSourceSet(project, SourceSet.MAIN_SOURCE_SET_NAME);

    transpileJSTask.setSourceDir(
        new Callable<File>() {

          @Override
          public File call() throws Exception {
            File resourcesDir = _getSrcDir(sourceSet.getResources());

            return new File(resourcesDir, "META-INF/resources");
          }
        });

    transpileJSTask.setWorkingDir(
        new Callable<File>() {

          @Override
          public File call() throws Exception {
            SourceSetOutput sourceSetOutput = sourceSet.getOutput();

            return new File(sourceSetOutput.getResourcesDir(), "META-INF/resources");
          }
        });

    Task classesTask = GradleUtil.getTask(project, JavaPlugin.CLASSES_TASK_NAME);

    classesTask.dependsOn(transpileJSTask);
  }
  @Override
  public void apply(Project project) {
    GradleUtil.applyPlugin(project, NodePlugin.class);

    final NpmInstallTask npmInstallTask =
        (NpmInstallTask) GradleUtil.getTask(project, NodePlugin.NPM_INSTALL_TASK_NAME);

    final DownloadNodeModuleTask downloadMetalCliTask = _addTaskDownloadMetalCli(project);

    final Configuration jsCompileConfiguration = _addConfigurationJSCompile(project);
    final Configuration soyCompileConfiguration = _addConfigurationSoyCompile(project);

    final TranspileJSTask transpileJSTask = _addTaskTranspileJS(project);

    project.afterEvaluate(
        new Action<Project>() {

          @Override
          public void execute(Project project) {
            _addTasksExpandJSCompileDependencies(
                transpileJSTask, npmInstallTask, jsCompileConfiguration);
            _addTasksExpandSoyCompileDependencies(transpileJSTask, soyCompileConfiguration);

            _configureTasksTranspileJS(project, downloadMetalCliTask, npmInstallTask);
          }
        });
  }
  protected void configurePluginsSDK(
      Project project,
      final WorkspaceExtension workspaceExtension,
      Copy initBundleTask,
      AbstractArchiveTask[] distBundleTasks) {

    final Project pluginsSDKProject =
        GradleUtil.getProject(project, workspaceExtension.getPluginsSDKDir());

    if (pluginsSDKProject == null) {
      return;
    }

    AntBuilder antBuilder = pluginsSDKProject.getAnt();

    antBuilder.importBuild("build.xml");

    final Task warTask = GradleUtil.getTask(pluginsSDKProject, WarPlugin.WAR_TASK_NAME);

    File homeDir = workspaceExtension.getHomeDir();

    if (!homeDir.exists()) {
      warTask.dependsOn(initBundleTask);
    }

    Task updateSDKPropertiesTask =
        addTaskUpdateSDKProperties(pluginsSDKProject, workspaceExtension);

    Task buildTask = pluginsSDKProject.task(LifecycleBasePlugin.BUILD_TASK_NAME);

    buildTask.dependsOn(updateSDKPropertiesTask, warTask);

    for (AbstractArchiveTask abstractArchiveTask : distBundleTasks) {
      abstractArchiveTask.into(
          "deploy",
          new Closure<Void>(null) {

            @SuppressWarnings("unused")
            public void doCall(CopySpec copySpec) {
              ConfigurableFileTree configurableFileTree = pluginsSDKProject.fileTree("dist");

              configurableFileTree.builtBy(warTask);
              configurableFileTree.include("*.war");

              copySpec.from(configurableFileTree);
            }
          });
    }
  }
  private void _configureTaskReplaceSoyTranslationForJavaPlugin(
      final ReplaceSoyTranslationTask replaceSoyTranslationTask) {

    replaceSoyTranslationTask.dependsOn(JavaPlugin.PROCESS_RESOURCES_TASK_NAME);

    replaceSoyTranslationTask.setSource(
        new Callable<File>() {

          @Override
          public File call() throws Exception {
            SourceSet sourceSet =
                GradleUtil.getSourceSet(
                    replaceSoyTranslationTask.getProject(), SourceSet.MAIN_SOURCE_SET_NAME);

            SourceSetOutput sourceSetOutput = sourceSet.getOutput();

            return sourceSetOutput.getResourcesDir();
          }
        });

    Task classesTask =
        GradleUtil.getTask(replaceSoyTranslationTask.getProject(), JavaPlugin.CLASSES_TASK_NAME);

    classesTask.dependsOn(replaceSoyTranslationTask);
  }
  protected Configuration addConfigurationBundle(
      Project project, WorkspaceExtension workspaceExtension) {

    Configuration configuration = GradleUtil.addConfiguration(project, BUNDLE_CONFIGURATION_NAME);

    configuration.setDescription("Configures the Liferay bundle to use for your project.");

    GradleUtil.addDependency(
        project,
        BUNDLE_CONFIGURATION_NAME,
        workspaceExtension.getBundleArtifactGroup(),
        workspaceExtension.getBundleArtifactName(),
        workspaceExtension.getBundleArtifactVersion());

    return configuration;
  }
  protected Copy addTaskInitBundle(
      final Project project,
      final WorkspaceExtension workspaceExtension,
      final Configuration bundleConfiguration) {

    Copy copy = GradleUtil.addTask(project, INIT_BUNDLE_TASK_NAME, Copy.class);

    copy.doFirst(
        new Action<Task>() {

          @Override
          public void execute(Task task) {
            Copy copy = (Copy) task;

            project.delete(copy.getDestinationDir());
          }
        });

    configureTaskCopyBundle(copy, bundleConfiguration);

    Project rootProject = project.getRootProject();

    copy.from(
        rootProject.file("configs/common"),
        rootProject.file("configs/" + workspaceExtension.getEnvironment()));

    copy.into(workspaceExtension.getHomeDir());

    copy.setDescription(
        "Downloads and unzips the bundle into " + workspaceExtension.getHomeDir() + ".");
    copy.setIncludeEmptyDirs(false);

    return copy;
  }
  @Override
  public void apply(Project project) {
    WorkspaceExtension workspaceExtension =
        GradleUtil.addExtension(project, PLUGIN_NAME, WorkspaceExtension.class);

    Configuration bundleConfiguration = addConfigurationBundle(project, workspaceExtension);

    addRepositoryBundle(project, workspaceExtension);

    Tar distBundleTarTask =
        addTaskDistBundle(
            project, DIST_BUNDLE_TAR_TASK_NAME, Tar.class, bundleConfiguration, workspaceExtension);

    distBundleTarTask.setCompression(Compression.GZIP);
    distBundleTarTask.setExtension("tar.gz");

    Zip distBundleZipTask =
        addTaskDistBundle(
            project, DIST_BUNDLE_ZIP_TASK_NAME, Zip.class, bundleConfiguration, workspaceExtension);

    AbstractArchiveTask[] distBundleTasks = {distBundleTarTask, distBundleZipTask};

    Copy initBundleTask = addTaskInitBundle(project, workspaceExtension, bundleConfiguration);

    configureModules(project, workspaceExtension, distBundleTasks);
    configurePluginsSDK(project, workspaceExtension, initBundleTask, distBundleTasks);
    configureThemes(project, workspaceExtension, distBundleTasks);
  }
  public Map<String, String> getBundleDefaultInstructions() {
    Map<String, String> map = new HashMap<>();

    map.put(Constants.BUNDLE_SYMBOLICNAME, project.getName());
    map.put(Constants.BUNDLE_VENDOR, "Liferay, Inc.");
    map.put(Constants.DONOTCOPY, "(.touch)");
    map.put(Constants.DSANNOTATIONS, "*");
    map.put(Constants.METATYPE, "*");
    map.put(Constants.PLUGIN, StringUtil.merge(_BND_PLUGIN_CLASS_NAMES, ","));
    map.put(Constants.SOURCES, "false");

    map.put("Git-Descriptor", "${system-allow-fail;git describe --dirty --always}");
    map.put("Git-SHA", "${system-allow-fail;git rev-list -1 HEAD}");

    JavaCompile javaCompile =
        (JavaCompile) GradleUtil.getTask(project, JavaPlugin.COMPILE_JAVA_TASK_NAME);

    CompileOptions compileOptions = javaCompile.getOptions();

    map.put("Javac-Debug", _getOnOffValue(compileOptions.isDebug()));
    map.put("Javac-Deprecation", _getOnOffValue(compileOptions.isDeprecation()));

    String encoding = compileOptions.getEncoding();

    if (Validator.isNull(encoding)) {
      encoding = System.getProperty("file.encoding");
    }

    map.put("Javac-Encoding", encoding);

    map.put("-jsp", "*.jsp,*.jspf");
    map.put("-sass", "*");

    return map;
  }
  private DownloadNodeModuleTask _addTaskDownloadMetalCli(Project project) {
    DownloadNodeModuleTask downloadNodeModuleTask =
        GradleUtil.addTask(project, DOWNLOAD_METAL_CLI_TASK_NAME, DownloadNodeModuleTask.class);

    downloadNodeModuleTask.setModuleName("metal-cli");
    downloadNodeModuleTask.setModuleVersion(_METAL_CLI_VERSION);

    return downloadNodeModuleTask;
  }
  private Configuration _addConfigurationSoyCompile(Project project) {
    Configuration configuration =
        GradleUtil.addConfiguration(project, SOY_COMPILE_CONFIGURATION_NAME);

    configuration.setDescription("Configures additional Soy dependencies.");
    configuration.setVisible(false);

    return configuration;
  }
  private Copy _addTaskExpandCompileDependency(
      Project project,
      File file,
      File destinationDir,
      String taskNamePrefix,
      RenameDependencyClosure renameDependencyClosure) {

    String taskName = GradleUtil.getTaskName(taskNamePrefix, file);

    Copy copy = GradleUtil.addTask(project, taskName, Copy.class);

    copy.doFirst(
        new Action<Task>() {

          @Override
          public void execute(Task task) {
            Copy copy = (Copy) task;

            Project project = copy.getProject();

            project.delete(copy.getDestinationDir());
          }
        });

    copy.from(project.zipTree(file));

    String name = renameDependencyClosure.call(file.getName());

    name = name.substring(0, name.length() - 4);

    destinationDir = new File(destinationDir, name);

    copy.setDescription(
        "Expands " + file.getName() + " into " + project.relativePath(destinationDir) + ".");
    copy.setDestinationDir(destinationDir);

    return copy;
  }
  protected void configureModules(
      Project project,
      final WorkspaceExtension workspaceExtension,
      final AbstractArchiveTask[] distBundleTasks) {

    Project modulesProject = GradleUtil.getProject(project, workspaceExtension.getModulesDir());

    if (modulesProject == null) {
      return;
    }

    Action<Project> action =
        new Action<Project>() {

          @Override
          public void execute(Project project) {
            Set<Project> subprojects = project.getSubprojects();

            if (!subprojects.isEmpty()) {
              return;
            }

            GradleUtil.applyPlugin(project, LiferayPlugin.class);

            LiferayExtension liferayExtension =
                GradleUtil.getExtension(project, LiferayExtension.class);

            liferayExtension.setAppServerParentDir(workspaceExtension.getHomeDir());

            for (AbstractArchiveTask abstractArchiveTask : distBundleTasks) {

              abstractArchiveTask.into(
                  "deploy",
                  new Closure<Void>(null) {

                    @SuppressWarnings("unused")
                    public void doCall(CopySourceSpec copySourceSpec) {
                      copySourceSpec.from(JavaPlugin.JAR_TASK_NAME);
                    }
                  });
            }

            if (workspaceExtension.isModulesDefaultRepositoryEnabled()) {
              addRepositoryModules(project);
            }
          }
        };

    modulesProject.subprojects(action);
  }
Beispiel #13
0
  private Configuration _addConfigurationSoy(final Project project) {
    Configuration configuration = GradleUtil.addConfiguration(project, CONFIGURATION_NAME);

    configuration.defaultDependencies(
        new Action<DependencySet>() {

          @Override
          public void execute(DependencySet dependencySet) {
            _addDependenciesSoy(project);
          }
        });

    configuration.setDescription("Configures Closure Templates for this project.");
    configuration.setVisible(false);

    return configuration;
  }
  @SuppressWarnings("rawtypes")
  private ReplaceSoyTranslationTask _addTaskReplaceSoyTranslation(Project project) {

    final ReplaceSoyTranslationTask replaceSoyTranslationTask =
        GradleUtil.addTask(
            project, REPLACE_SOY_TRANSLATION_TASK_NAME, ReplaceSoyTranslationTask.class);

    replaceSoyTranslationTask.setDescription("Replaces 'goog.getMsg' definitions.");
    replaceSoyTranslationTask.setGroup(BasePlugin.BUILD_GROUP);
    replaceSoyTranslationTask.setIncludes(Collections.singleton("**/*.soy.js"));

    PluginContainer pluginContainer = project.getPlugins();

    pluginContainer.withId(
        _JS_MODULE_CONFIG_GENERATOR_PLUGIN_ID,
        new Action<Plugin>() {

          @Override
          public void execute(Plugin plugin) {
            replaceSoyTranslationTask.dependsOn(_CONFIG_JS_MODULES_TASK_NAME);
          }
        });

    pluginContainer.withId(
        _JS_TRANSPILER_PLUGIN_ID,
        new Action<Plugin>() {

          @Override
          public void execute(Plugin plugin) {
            replaceSoyTranslationTask.dependsOn(_TRANSPILE_JS_TASK_NAME);
          }
        });

    pluginContainer.withType(
        JavaPlugin.class,
        new Action<JavaPlugin>() {

          @Override
          public void execute(JavaPlugin javaPlugin) {
            _configureTaskReplaceSoyTranslationForJavaPlugin(replaceSoyTranslationTask);
          }
        });

    return replaceSoyTranslationTask;
  }
  protected UpdatePropertiesTask addTaskUpdateSDKProperties(
      Project project, WorkspaceExtension workspaceExtension) {

    UpdatePropertiesTask updatePropertiesTask =
        GradleUtil.addTask(project, UPDATE_SDK_PROPERTIES_TASK_NAME, UpdatePropertiesTask.class);

    updatePropertiesTask.property(
        "app.server.parent.dir", FileUtil.getAbsolutePath(workspaceExtension.getHomeDir()));

    String userName = System.getProperty("user.name");

    File sdkPropertiesFile =
        new File(workspaceExtension.getPluginsSDKDir(), "build." + userName + ".properties");

    updatePropertiesTask.setPropertiesFile(sdkPropertiesFile);

    return updatePropertiesTask;
  }
  private TranspileJSTask _addTaskTranspileJS(Project project) {
    final TranspileJSTask transpileJSTask =
        GradleUtil.addTask(project, TRANSPILE_JS_TASK_NAME, TranspileJSTask.class);

    transpileJSTask.setDescription("Transpiles JS files.");
    transpileJSTask.setGroup(BasePlugin.BUILD_GROUP);

    PluginContainer pluginContainer = project.getPlugins();

    pluginContainer.withType(
        JavaPlugin.class,
        new Action<JavaPlugin>() {

          @Override
          public void execute(JavaPlugin javaPlugin) {
            _configureTaskTranspileJSForJavaPlugin(transpileJSTask);
          }
        });

    return transpileJSTask;
  }
  protected <T extends AbstractArchiveTask> T addTaskDistBundle(
      final Project project,
      String taskName,
      Class<T> clazz,
      final Configuration bundleConfiguration,
      WorkspaceExtension workspaceExtension) {

    T task = GradleUtil.addTask(project, taskName, clazz);

    configureTaskCopyBundle(task, bundleConfiguration);

    task.from(
        project.file("configs/common"),
        project.file("configs/" + workspaceExtension.getEnvironment()));

    task.setBaseName(project.getName());
    task.setDescription("Assembles the bundle and zips it up.");
    task.setDestinationDir(project.getBuildDir());
    task.setIncludeEmptyDirs(false);

    return task;
  }
Beispiel #18
0
  private BuildSoyTask _addTaskBuildSoy(Project project) {
    final BuildSoyTask buildSoyTask =
        GradleUtil.addTask(project, BUILD_SOY_TASK_NAME, BuildSoyTask.class);

    buildSoyTask.setDescription("Compiles Closure Templates into JavaScript functions.");
    buildSoyTask.setGroup(BasePlugin.BUILD_GROUP);
    buildSoyTask.setIncludes(Collections.singleton("**/*.soy"));

    PluginContainer pluginContainer = project.getPlugins();

    pluginContainer.withType(
        JavaPlugin.class,
        new Action<JavaPlugin>() {

          @Override
          public void execute(JavaPlugin javaPlugin) {
            _configureTaskBuildSoyForJavaPlugin(buildSoyTask);
          }
        });

    return buildSoyTask;
  }
 @Input
 public String getBundleFileName() {
   return GradleUtil.toString(_bundleFileName);
 }
 public List<String> getSrcIncludes() {
   return GradleUtil.toStringList(_srcIncludes);
 }
 public File getSourceDir() {
   return GradleUtil.toFile(getProject(), _sourceDir);
 }
 @Input
 public String getOutputDirName() {
   return GradleUtil.toString(_outputDirName);
 }
  protected void configureThemes(
      Project project,
      final WorkspaceExtension workspaceExtension,
      final AbstractArchiveTask[] distBundleTasks) {

    Project themesProject = GradleUtil.getProject(project, workspaceExtension.getThemesDir());

    if (themesProject == null) {
      return;
    }

    Action<Project> action =
        new Action<Project>() {

          @Override
          public void execute(final Project project) {
            Set<Project> subproject = project.getSubprojects();

            if (!subproject.isEmpty()) {
              return;
            }

            project.setBuildDir("build_gradle");

            GradleUtil.applyPlugin(project, BasePlugin.class);
            GradleUtil.applyPlugin(project, GulpPlugin.class);

            Task assembleTask = GradleUtil.getTask(project, BasePlugin.ASSEMBLE_TASK_NAME);

            assembleTask.dependsOn(_GULP_BUILD_TASK_NAME);

            final Task createLiferayThemeJsonTask =
                addTaskCreateLiferayThemeJson(project, workspaceExtension);

            Delete cleanTask = (Delete) GradleUtil.getTask(project, BasePlugin.CLEAN_TASK_NAME);

            cleanTask.delete("build", "dist");
            cleanTask.dependsOn(
                BasePlugin.CLEAN_TASK_NAME
                    + StringUtil.capitalize(NodePlugin.NPM_INSTALL_TASK_NAME));

            Task deployTask = project.task(LiferayJavaPlugin.DEPLOY_TASK_NAME);

            deployTask.dependsOn(_GULP_DEPLOY_TASK_NAME);

            for (AbstractArchiveTask abstractArchiveTask : distBundleTasks) {

              abstractArchiveTask.into(
                  "deploy",
                  new Closure<Void>(null) {

                    @SuppressWarnings("unused")
                    public void doCall(CopySpec copySpec) {
                      ConfigurableFileTree fileTree = project.fileTree("dist");

                      fileTree.builtBy(_GULP_DEPLOY_TASK_NAME);
                      fileTree.include("*.war");

                      copySpec.from(fileTree);
                    }
                  });
            }

            TaskContainer taskContainer = project.getTasks();

            taskContainer.withType(
                ExecuteGulpTask.class,
                new Action<ExecuteGulpTask>() {

                  @Override
                  public void execute(ExecuteGulpTask executeGulpTask) {
                    executeGulpTask.dependsOn(
                        createLiferayThemeJsonTask, NodePlugin.NPM_INSTALL_TASK_NAME);
                  }
                });
          }
        };

    themesProject.subprojects(action);
  }
 @InputDirectory
 @Optional
 public File getPortalCommonDir() {
   return GradleUtil.toFile(getProject(), _portalCommonDir);
 }
 @Input
 public int getPrecision() {
   return GradleUtil.toInteger(_precision);
 }
 @Input
 public List<String> getRtlExcludedPathRegexps() {
   return GradleUtil.toStringList(_rtlExcludedPathRegexps);
 }
 @Input
 @Optional
 public String getSassCompilerClassName() {
   return GradleUtil.toString(_sassCompilerClassName);
 }
 @Input
 public String getGlobalName() {
   return GradleUtil.toString(_globalName);
 }
 @Input
 public String getModules() {
   return GradleUtil.toString(_modules);
 }
 @InputFile
 @Optional
 public File getPortalCommonFile() {
   return GradleUtil.toFile(getProject(), _portalCommonFile);
 }