diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5e4b8d4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +/.idea +/.gradle +/gradle +/build diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..25fae1a --- /dev/null +++ b/build.gradle @@ -0,0 +1,29 @@ +plugins { + id 'java' +} + +group 'devtools.liferay' +version '1.0.0' + +sourceCompatibility = 1.8 + +repositories { + mavenCentral() +} + +dependencies { + testCompile group: 'junit', name: 'junit', version: '4.12' +} + +apply plugin: 'java-gradle-plugin' + +gradlePlugin { + plugins { + liferayPortalProperties{ + id = 'devtools-liferay-portal-properties' + implementationClass = 'devtools.liferay.portal.properties.plugin.PortalPropertiesPlugin' + } + } +} + +apply plugin: 'maven' \ No newline at end of file diff --git a/gradlew b/gradlew new file mode 100644 index 0000000..cccdd3d --- /dev/null +++ b/gradlew @@ -0,0 +1,172 @@ +#!/usr/bin/env sh + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS="" + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin, switch paths to Windows format before running java +if $cygwin ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..f955316 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,84 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS= + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 0000000..85bd4d0 --- /dev/null +++ b/settings.gradle @@ -0,0 +1,2 @@ +rootProject.name = 'portal-properties' + diff --git a/src/main/java/devtools/liferay/portal/properties/plugin/PortalPropertiesPlugin.java b/src/main/java/devtools/liferay/portal/properties/plugin/PortalPropertiesPlugin.java new file mode 100644 index 0000000..faff1ee --- /dev/null +++ b/src/main/java/devtools/liferay/portal/properties/plugin/PortalPropertiesPlugin.java @@ -0,0 +1,19 @@ +package devtools.liferay.portal.properties.plugin; + +import devtools.liferay.portal.properties.plugin.task.BuildPropertiesExtension; +import devtools.liferay.portal.properties.plugin.task.BuildPropertiesTask; +import org.gradle.api.Plugin; +import org.gradle.api.Project; + +import static devtools.liferay.portal.properties.plugin.PortalPropertiesUtils.TASK_NAME; + +public class PortalPropertiesPlugin implements Plugin { + + + @Override + public void apply(Project target) { + target.getTasks().create(TASK_NAME, BuildPropertiesTask.class, (task) -> { + task.setDescFolderPath("loquesea"); + }); + } +} diff --git a/src/main/java/devtools/liferay/portal/properties/plugin/PortalPropertiesUtils.java b/src/main/java/devtools/liferay/portal/properties/plugin/PortalPropertiesUtils.java new file mode 100644 index 0000000..6f7a085 --- /dev/null +++ b/src/main/java/devtools/liferay/portal/properties/plugin/PortalPropertiesUtils.java @@ -0,0 +1,6 @@ +package devtools.liferay.portal.properties.plugin; + +public class PortalPropertiesUtils { + public static final String TASK_NAME = "buildproperties"; + +} diff --git a/src/main/java/devtools/liferay/portal/properties/plugin/task/BuildPropertiesExtension.java b/src/main/java/devtools/liferay/portal/properties/plugin/task/BuildPropertiesExtension.java new file mode 100644 index 0000000..d587581 --- /dev/null +++ b/src/main/java/devtools/liferay/portal/properties/plugin/task/BuildPropertiesExtension.java @@ -0,0 +1,23 @@ +package devtools.liferay.portal.properties.plugin.task; + +import org.gradle.api.Project; + +public class BuildPropertiesExtension { + private String descFolderPath = ""; + + public BuildPropertiesExtension(Project project){ + this.descFolderPath = project.getObjects().property(String.class).get(); + } + + public BuildPropertiesExtension(){ + + } + + public String getDescFolderPath() { + return descFolderPath; + } + + public void setDescFolderPath(String descFolderPath) { + this.descFolderPath = descFolderPath; + } +} diff --git a/src/main/java/devtools/liferay/portal/properties/plugin/task/BuildPropertiesTask.java b/src/main/java/devtools/liferay/portal/properties/plugin/task/BuildPropertiesTask.java new file mode 100644 index 0000000..b6b4c91 --- /dev/null +++ b/src/main/java/devtools/liferay/portal/properties/plugin/task/BuildPropertiesTask.java @@ -0,0 +1,171 @@ +package devtools.liferay.portal.properties.plugin.task; + +import org.gradle.api.DefaultTask; +import org.gradle.api.tasks.TaskAction; +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.StandardCopyOption; +import java.util.Enumeration; +import java.util.List; +import java.util.Properties; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +public class BuildPropertiesTask extends DefaultTask { + private String descFolderPath = ""; + private String originFolderPath = ""; + private String keysFolderPath = ""; + + + @TaskAction + public void buildPropertiesTask() throws Exception{ + log("Build properties task..." + descFolderPath); + printSettings(); + List originFiles = getFilesFromFolder(originFolderPath); + List keysFiles = getFilesFromFolder(keysFolderPath); + List destinationFolders = getFolderFromFolder(descFolderPath); + + keysFiles.stream().forEach(keysFile -> { + parseEnvironment(getFileName(keysFile.getFileName().toString()), keysFile, originFiles, destinationFolders); + }); + } + + private List getFilesFromFolder(String folderPath) throws IOException { + final List collect = Files.list(Paths.get(getProject().getProjectDir() + "/" + folderPath)).filter(Files::isRegularFile).collect(Collectors.toList()); + return collect; + } + + private List getFolderFromFolder(String folderPath) throws IOException { + final List collect = Files.list(Paths.get(getProject().getProjectDir() + "/" + folderPath)).filter(Files::isDirectory).collect(Collectors.toList()); + return collect; + } + + private void parseEnvironment(String environment, Path keysFilePath, List originFiles, List destinationFolders){ + log("Parsing " + environment + " environment..."); + originFiles.stream().forEach(originFile -> { + destinationFolders.stream().filter(destinationFolder -> { + return destinationFolder.toString().endsWith(environment); + }).forEach(destinationFolder -> { + Path destinationFilePath = copyFile(originFile, destinationFolder); + parseDestinationFile(keysFilePath, destinationFilePath); + }); + }); + } + + private void parseDestinationFile(Path keysFilePath, Path destinationFilePath) { + if(destinationFilePath != null){ + try { + Properties keySet = new Properties(); + FileInputStream keysFileInputStream = null; + keysFileInputStream = new FileInputStream(keysFilePath.toFile()); + if(keysFileInputStream != null){ + keySet.load(keysFileInputStream); + } + Enumeration keyNameEnum = (Enumeration)keySet.propertyNames(); + while(keyNameEnum.hasMoreElements()){ + String keyName = keyNameEnum.nextElement(); + String keyNameSearched = "\\$\\{" + keyName + "\\}"; + String keyValue = keySet.getProperty(keyName); + String content = new String(Files.readAllBytes(destinationFilePath), StandardCharsets.UTF_8); + content = content.replaceAll(keyNameSearched, keyValue); + Files.write(destinationFilePath, content.getBytes(StandardCharsets.UTF_8)); + } + + checkBrokenProperties(destinationFilePath, getFileName(keysFilePath.getFileName().toString())); + + + + }catch(IOException exception){ + error(null, exception); + } + } + } + + private void checkBrokenProperties(Path destinationFilePath, String environment) throws IOException { + String content = new String(Files.readAllBytes(destinationFilePath), StandardCharsets.UTF_8); + Pattern brokenPropertyPattern = Pattern.compile("\\$\\{.*\\}"); + Matcher brokenPropertyMatcher = brokenPropertyPattern.matcher(content); + while(brokenPropertyMatcher.find()){ + error("WARNING: Property not found in file " + destinationFilePath.getFileName().toString() + " on " + environment + " folder (" + brokenPropertyMatcher.group() + ")", null); + } + } + + + private Path copyFile(Path originFilePath, Path destinationFolderPath){ + log("Copying " + originFilePath.toString() + " to " + destinationFolderPath.toString()); + Path destinationFilePath = Paths.get(destinationFolderPath.toString() + "/" + originFilePath.getFileName().toString()); + try { + Files.copy(originFilePath, destinationFilePath, StandardCopyOption.REPLACE_EXISTING); + return destinationFilePath; + }catch(IOException exception){ + error(null, exception); + return null; + } + } + + private String getFileExtension(String file) { + if (file == null) { + return ""; + } + int i = file.lastIndexOf('.'); + String ext = i > 0 ? file.substring(i + 1) : ""; + return ext; + } + + private String getFileName(String file) { + if (file == null) { + return ""; + } + int i = file.lastIndexOf('.'); + String ext = i > 0 ? file.substring(0, i) : ""; + return ext; + } + + private void printSettings(){ + log("Settings: "); + log("destination folder path: " + descFolderPath); + log("origin folder path: " + originFolderPath); + log("keys folder path: " + keysFolderPath); + } + + public String getDescFolderPath() { + return descFolderPath; + } + + public void setDescFolderPath(String descFolderPath) { + this.descFolderPath = descFolderPath; + } + + public String getOriginFolderPath() { + return originFolderPath; + } + + public void setOriginFolderPath(String originFolderPath) { + this.originFolderPath = originFolderPath; + } + + public String getKeysFolderPath() { + return keysFolderPath; + } + + public void setKeysFolderPath(String keysFolderPath) { + this.keysFolderPath = keysFolderPath; + } + + private void log(String message){ + System.out.println(message); + } + + private void error(String message, Exception exception){ + if(message != null && !message.isEmpty()) { + System.err.println(message); + } + if(exception != null) { + exception.printStackTrace(); + } + } +}