Merge pull request #327 from TheSnoozer/master

Improve properties replacement and allow to change the case of letters (#317) and fix the runningOnBuildServer check for detecting the branch name on Jenkins / Hudson to also check 'HUDSON_HOME' and 'JENKINS_HOME' (#326)

Author: TheSnoozer

README.md

@@ -361,16 +361,30 @@ It's really simple to setup this plugin; below is a sample pom that you may base
                         Furthermore each replacementProperty need to be configured with a token and a value.
                         The token can be seen as the needle and the value as the text to be written over any found tokens. If using regular expressions the value can reference grouped regex matches by using $1, $2, etc.
 
+                        Since 2.2.4 the plugin allows to define a even more sophisticated ruleset and allows to set an `propertyOutputSuffix` within each replacement property. If this option is empty the original property will be overwritten (default behaviour in 2.2.3). however when this configuration is set to `something` and a user wants to modify the `git.branch` property the plugin will keep `git.branch` as the original one (w/o modifications) but also will be creating a new `git.branch.something` property with the requested replacement.
+                        Furthermore with 2.2.4 the plugin allows to perform certain types of string manipulation either before or after the evaluation of the replacement. With this feature a user can currently easily manipulate the case (e.g. lower case VS upper case) of the input/output property. This behaviour can be achieved by defining a list of `transformationRules` for the property where those rules should take effect. Each `transformationRule` consist of two required fields `apply` and `action`. The `apply`-tag controls when the rule should be applied and can be set to `BEFORE` to have the rule being applied before or it can be set to `AFTER` to have the rule being applied after the replacement. The `action`-tag determines the string conversion rule that should be applied. Currenlty supported is `LOWER_CASE` and `UPPER_CASE`. Potential candidates in the feature are `CAPITALIZATION` and `INVERT_CASE``(open a ticket if you need them...).
+
                         Please note that the replacement will *only be applied to properties that are being generated by the plugin*.
                         If you want to replace properties that are being generated by other plugins you may want to use the maven-replacer-plugin or any other alternative.
                     -->
                     <replacementProperties>
                       <!-- example: apply replacement only to the specific property git.branch and replace '/' with '-'
                       <replacementProperty>
                         <property>git.branch</property>
+                        <propertyOutputSuffix>something<propertyOutputSuffix>
                         <token>^([^\/]*)\/([^\/]*)$</token>
                         <value>$1-$2</value>
                         <regex>true</regex>
+                        <transformationRules>
+                          <transformationRule>
+                            <apply>BEFORE</apply>
+                            <action>UPPER_CASE</action>
+                          </transformationRule>
+                          <transformationRule>
+                            <apply>AFTER</apply>
+                            <action>LOWER_CASE</action>
+                          </transformationRule>
+                        </transformationRules>
                       </replacementProperty>
                       -->
                     </replacementProperties>
@@ -882,7 +896,7 @@ Worth pointing out is, that git-commit-id tries to be 1-to-1 compatible with git
 * **skip** - `(default: false)` when you don't use `git-describe` information in your build, you can opt to be calculate it.
 
 
-* **validationProperties** Since version **2.2.2** the maven-git-commit-id-plugin comes equipped with an additional validation utility which can be used to verify if your project properties are set as you would like to have them set. This feature ships with an additional mojo execution and for instance allows to check if the version is not a snapshot build. If you are interested in the config checkout the[validation utility documentation](https://github.com/ktoso/maven-git-commit-id-plugin#validate-if-properties-are-set-as-expected).
+**validationProperties** Since version **2.2.2** the maven-git-commit-id-plugin comes equipped with an additional validation utility which can be used to verify if your project properties are set as you would like to have them set. This feature ships with an additional mojo execution and for instance allows to check if the version is not a snapshot build. If you are interested in the config checkout the[validation utility documentation](https://github.com/ktoso/maven-git-commit-id-plugin#validate-if-properties-are-set-as-expected).
 
 All options are documented in the code, so just use `ctrl + q` (intellij @ linux) or `f1` (intellij @ osx) when writing the options in pom.xml - you'll get examples and detailed information about each option (even more than here).
 

src/main/java/pl/project13/maven/git/GitDataProvider.java

@@ -180,7 +180,8 @@ protected String determineBranchName(Map<String, String> env) throws GitCommitId
    * @param env environment settings
    */
   private boolean runningOnBuildServer(Map<String, String> env) {
-    return env.containsKey("HUDSON_URL") || env.containsKey("JENKINS_URL");
+    return env.containsKey("HUDSON_URL") || env.containsKey("JENKINS_URL") ||
+           env.containsKey("HUDSON_HOME") || env.containsKey("JENKINS_HOME");
   }
 
   /**
@@ -261,4 +262,4 @@ protected static String stripCredentialsFromOriginUrl(String gitRemoteString) th
       throw new GitCommitIdExecutionException(e);
     }
   }
-}
+}

src/main/java/pl/project13/maven/git/PropertiesReplacer.java

@@ -19,6 +19,7 @@
 
 import pl.project13.maven.git.log.LoggerBridge;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
@@ -38,30 +39,56 @@ public void performReplacement(Properties properties, List<ReplacementProperty>
 			for(ReplacementProperty replacementProperty: replacementProperties) {
 				String propertyKey = replacementProperty.getProperty();
 				if(propertyKey == null) {
+					Map<Object, Object> propertiesToBeAdded = new HashMap<>();
 					for (Map.Entry<Object, Object> entry : properties.entrySet()) {
 						String key = (String)entry.getKey();
 						String content = (String)entry.getValue();
 						String result = performReplacement(replacementProperty, content);
-						entry.setValue(result);
-						log.info("apply replace on property " + key + ": original value '" + content + "' with '" + result + "'");
+						if((replacementProperty.getPropertyOutputSuffix() != null) && (!replacementProperty.getPropertyOutputSuffix().isEmpty())) {
+							String newPropertyKey = key + "." + replacementProperty.getPropertyOutputSuffix();
+							propertiesToBeAdded.put(newPropertyKey, result);
+							log.info("apply replace on property " + key + " and save to " + newPropertyKey + ": original value '" + content + "' with '" + result + "'");
+						} else {
+							entry.setValue(result);
+							log.info("apply replace on property " + key + ": original value '" + content + "' with '" + result + "'");
+						}
 					}
+					properties.putAll(propertiesToBeAdded);
 				} else {
 					String content = properties.getProperty(propertyKey);
 					String result = performReplacement(replacementProperty, content);
-					properties.setProperty(propertyKey, result);
-					log.info("apply replace on property " + propertyKey + ": original value '" + content + "' with '" + result + "'");
+					if((replacementProperty.getPropertyOutputSuffix() != null) && (!replacementProperty.getPropertyOutputSuffix().isEmpty())) {
+						String newPropertyKey = propertyKey + "." + replacementProperty.getPropertyOutputSuffix();
+						properties.setProperty(newPropertyKey, result);
+						log.info("apply replace on property " + propertyKey + " and save to " + newPropertyKey + ": original value '" + content + "' with '" + result + "'");
+					} else {
+						properties.setProperty(propertyKey, result);
+						log.info("apply replace on property " + propertyKey + ": original value '" + content + "' with '" + result + "'");
+					}
 				}
 			}
 		}
 	}
 
 	private String performReplacement(ReplacementProperty replacementProperty, String content) {
-		String result = content;
+		String result = performTransformationRules(replacementProperty, content, TransformationRule.ApplyEnum.BEFORE);
 		if(replacementProperty != null) {
 			if(replacementProperty.isRegex()) {
-				result = replaceRegex(content, replacementProperty.getToken(), replacementProperty.getValue());
+				result = replaceRegex(result, replacementProperty.getToken(), replacementProperty.getValue());
 			} else {
-				result = replaceNonRegex(content, replacementProperty.getToken(), replacementProperty.getValue());
+				result = replaceNonRegex(result, replacementProperty.getToken(), replacementProperty.getValue());
+			}
+		}
+		return performTransformationRules(replacementProperty, result, TransformationRule.ApplyEnum.AFTER);
+	}
+
+	private String performTransformationRules(ReplacementProperty replacementProperty, String content, TransformationRule.ApplyEnum forRule) {
+		String result = content;
+		if((replacementProperty.getTransformationRules() != null) && (!replacementProperty.getTransformationRules().isEmpty())) {
+			for(TransformationRule transformationRule: replacementProperty.getTransformationRules()) {
+				if(transformationRule.getApplyRule().equals(forRule)) {
+					result = transformationRule.getActionRule().perform(result);
+				}
 			}
 		}
 		return result;

src/main/java/pl/project13/maven/git/ReplacementProperty.java

@@ -17,8 +17,14 @@
 
 package pl.project13.maven.git;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.apache.maven.plugins.annotations.Parameter;
 
+/**
+ * @since 2.2.3
+ */
 public class ReplacementProperty {
   /**
    * Defines if a replacement should only be applied to a single property.
@@ -27,6 +33,20 @@ public class ReplacementProperty {
   @Parameter
   private String property;
 
+  /**
+   * @since 2.2.4
+   * Defines an additional output property suffix.
+   * Note: 
+   * this will only be *appended* to the current property key
+   * (e.g. when the property is set to 'sample' the property
+   * 'git.branch' will be transformed to 'git.branch.sample')
+   * 
+   * Be advised that you might want to adjust your include
+   * or exclude filters which be applied after the regex validation.
+   */
+  @Parameter
+  private String propertyOutputSuffix;
+
   /**
    * Token to replace.
    * This may or may not be a regular expression.
@@ -48,13 +68,22 @@ public class ReplacementProperty {
   @Parameter(defaultValue = "true")
   private boolean regex = true;
 
+  /**
+   * @since 2.2.4
+   * Provides the ability to perform certain string transformations before regex evaluation or after.
+   */
+  @Parameter
+  private List<TransformationRule> transformationRules = new ArrayList<>();
+
   public ReplacementProperty(){}
 
-  public ReplacementProperty(String property, String token, String value, boolean regex) {
+  public ReplacementProperty(String property, String propertyOutputSuffix, String token, String value, boolean regex, List<TransformationRule> transformationRules) {
     this.property = property;
+    this.propertyOutputSuffix = propertyOutputSuffix;
     this.token = token;
     this.value = value;
     this.regex = regex;
+    this.transformationRules = transformationRules;
   }
 
   public String getProperty() {
@@ -65,6 +94,14 @@ public void setProperty(String property) {
     this.property = property;
   }
 
+  public String getPropertyOutputSuffix() {
+    return propertyOutputSuffix;
+  }
+
+  public void setPropertyOutputSuffix(String propertyOutputSuffix) {
+    this.propertyOutputSuffix = propertyOutputSuffix;
+  }
+
   public String getToken() {
     return token;
   }
@@ -89,4 +126,11 @@ public void setRegex(boolean regex) {
     this.regex = regex;
   }
 
+  public List<TransformationRule> getTransformationRules() {
+    return transformationRules;
+  }
+
+  public void setTransformationRules(List<TransformationRule> transformationRules) {
+    this.transformationRules = transformationRules;
+  }
 }

src/main/java/pl/project13/maven/git/TransformationRule.java

@@ -0,0 +1,110 @@
+/*
+ * This file is part of git-commit-id-plugin by Konrad 'ktoso' Malawski <konrad.malawski@java.pl>
+ *
+ * git-commit-id-plugin is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * git-commit-id-plugin is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with git-commit-id-plugin.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package pl.project13.maven.git;
+
+import org.apache.maven.plugins.annotations.Parameter;
+
+public class TransformationRule {
+  /**
+   * Determines when the transformation should be taken place.
+   * Currently supported is
+   *   - BEFORE_REGEX
+   *   - AFTER_REGEX
+   */
+  @Parameter(required = true)
+  private String apply;
+
+  private ApplyEnum applyRule;
+
+  protected enum ApplyEnum {
+    BEFORE,
+    AFTER,
+    ;
+  };
+
+  /**
+   * Determines the action that should be performed as transformation.
+   * Currently supported is
+   *   - LOWER_CASE
+   *   - UPPER_CASE
+   */
+  @Parameter(required = true)
+  private String action;
+
+  private ActionEnum actionRule;
+
+  protected enum ActionEnum {
+    LOWER_CASE {
+        @Override
+        protected String perform(String input) {
+          if(input != null) {
+            return input.toLowerCase();
+          }
+          return input;
+        }
+      },
+    UPPER_CASE {
+      @Override
+      protected String perform(String input) {
+        if(input != null) {
+          return input.toUpperCase();
+        }
+        return null;
+      }
+    },
+    ;
+    protected abstract String perform(String input);
+  }
+
+  public TransformationRule(){}
+
+  public TransformationRule(String apply, String action) {
+    this(ApplyEnum.valueOf(apply), ActionEnum.valueOf(action));
+    this.apply = apply;
+    this.action = action;
+  }
+
+  protected TransformationRule(ApplyEnum applyRule, ActionEnum actionRule) {
+    this.applyRule = applyRule;
+    this.actionRule = actionRule;
+  }
+
+  public String getApply() {
+    return apply;
+  }
+
+  public void setApply(String apply) {
+    this.apply = apply;
+  }
+
+  public ApplyEnum getApplyRule() {
+    return applyRule;
+  }
+
+  public String getAction() {
+    return action;
+  }
+
+  public void setAction(String action) {
+    this.action = action;
+  }
+
+  public ActionEnum getActionRule() {
+    return actionRule;
+  }
+}