feat: add git describe version placeholders

Author: qoomon

CHANGELOG.md

@@ -1,15 +1,17 @@
 # Changelog
 
-## 6.3.0 (unreleased)
+## 4.3.0 (unreleased)
 * **Features**
     * add git describe version placeholders
-      enable describe feature by set config `describeTagPattern` at root level or at branch/tag config level
         * new placeholders
             * `${describe}`
             * `${describe.tag}`
-                * `${describe.<TAG_PATTERN_GROUP_NAME or TAG_PATTERN_GROUP_INDEX>}`
+                * `${describe.<TAG_PATTERN_GROUP_NAME or TAG_PATTERN_GROUP_INDEX>}` e.g. pattern `v(?<version>.*)` will create placeholder `${describe.version}`
             * `${describe.distance}`
 
+* **BREAKING CHANGES**
+    * no longer provide project property `git.dirty` due to performance issues on larger projects,
+      version format placeholder `${dirty}` is still available
 
 ## 4.1.0
 * **Features**

README.md

@@ -160,7 +160,14 @@ gitVersioning.apply(closureOf<GitVersioningPluginConfig> {
 
 ℹ define placeholder overwrite value (placeholder is defined) like this `${name:+OVERWRITE_VALUE}`<br>
   e.g `${dirty:-SNAPSHOT}` resolves to `-SNAPSHOT` instead of `-DIRTY`
-  
+
+- `${version}`
+    - `version` set in `pom.xml`
+    - e.g. '1.0.0-SNAPSHOT'
+- `${version.release}`
+    - like `${version}` without `-SNAPSHOT` postfix
+    - e.g. '1.0.0'
+    
 - `${ref}`
     - current ref name (branch name, tag name or commit hash)
 - `${ref.slug}`
@@ -227,18 +234,20 @@ gitVersioning.apply(closureOf<GitVersioningPluginConfig> {
             versionFormat = '${1}'
             ```
           
-- `${version}`
-    - `version` set in `pom.xml`
-    - e.g. '1.0.0-SNAPSHOT'
-- `${version.release}`
-    - like `${version}` without `-SNAPSHOT` postfix
-    - e.g. '1.0.0'
+- `${describe}`
+    - will resolve to `git describe` output
+    - ⚠️ may lead to performance issue on very large projects
+- `${describe.tag}`
+    - the matching tag of `git describe`
+- `${describe.distance}`
+    - the distance count to last matching tag
 
 - `${dirty}`
-    - if repository has untracked files or uncommited changes this placeholder will resolve to `-DIRTY`, otherwise it will resolve to an empty string.  
+    - if repository has untracked files or uncommitted changes this placeholder will resolve to `-DIRTY`, otherwise it will resolve to an empty string.
+    - ⚠️ may lead to performance issue on very large projects
 - `${dirty.snapshot}`
-    - if repository has untracked files or uncommited changes this placeholder will resolve to `-SNAPSHOT`, otherwise it will resolve to an empty string.
-  
+    - like `${dirty}`, but will resolve to `-SNAPSHOT`
+
 - `${value}` - Only available within property format
     - value of matching property
 
@@ -286,8 +295,6 @@ gitVersioning.apply(closureOf<GitVersioningPluginConfig> {
     - `git.tag.slug` like `git.tag` with all `/` replaced by `-`
 - `git.commit.timestamp` e.g. '1560694278'
 - `git.commit.timestamp.datetime` e.g. '2019-11-16T14:37:10Z'
-- `git.dirty` repository's dirty state indicator `true` or `false`
-
 
 ## Gradle Tasks
 

src/main/java/me/qoomon/gitversioning/commons/GitSituation.java

@@ -9,44 +9,42 @@
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Supplier;
 import java.util.regex.Pattern;
 
 import static java.time.Instant.EPOCH;
 import static java.time.ZoneOffset.UTC;
 import static java.util.Collections.emptyList;
+import static java.util.Objects.requireNonNull;
 import static me.qoomon.gitversioning.commons.GitUtil.NO_COMMIT;
 import static org.eclipse.jgit.lib.Constants.HEAD;
 
-//TODO rename to GitSituation
+
 public class GitSituation {
 
     private final Repository repository;
     private final File rootDirectory;
 
     private final ObjectId head;
     private final String hash;
-    private final Lazy<ZonedDateTime> timestamp = Lazy.of(this::timestamp);
-    private Lazy<String> branch = Lazy.of(this::branch);
+    private final Supplier<ZonedDateTime> timestamp = Lazy.by(this::timestamp);
+    private Supplier<String> branch = Lazy.by(this::branch);
 
-    private final Lazy<Map<ObjectId, List<Ref>>> reverseTagRefMap = Lazy.of(this::reverseTagRefMap);
-    private Lazy<List<String>> tags = Lazy.of(this::tags);
+    private final Supplier<Map<ObjectId, List<Ref>>> reverseTagRefMap = Lazy.by(this::reverseTagRefMap);
+    private Supplier<List<String>> tags = Lazy.by(this::tags);
 
-    private final Lazy<Boolean> clean = Lazy.of(this::clean);
+    private final Supplier<Boolean> clean = Lazy.by(this::clean);
 
-    private final Pattern describeTagPattern;
-    private final Lazy<GitDescription> description = Lazy.of(this::describe);
+    private Pattern describeTagPattern = Pattern.compile(".*");
+    private Supplier<GitDescription> description = Lazy.by(this::describe);
 
-    public GitSituation(Repository repository, Pattern describeTagPattern) throws IOException {
+    public GitSituation(Repository repository) throws IOException {
         this.repository = repository;
         this.rootDirectory = repository.getWorkTree();
         this.head = repository.resolve(HEAD);
         this.hash = head != null ? head.getName() : NO_COMMIT;
-        this.describeTagPattern = describeTagPattern != null ? describeTagPattern : Pattern.compile(".*");
     }
 
-    public GitSituation(Repository repository) throws IOException {
-        this(repository, null);
-    }
 
     public File getRootDirectory() {
         return rootDirectory;
@@ -65,7 +63,7 @@ public String getBranch() {
     }
 
     public void setBranch(String branch) {
-        this.branch = Lazy.of(branch);
+        this.branch = () -> branch;
     }
 
     public boolean isDetached() {
@@ -77,13 +75,22 @@ public List<String> getTags() {
     }
 
     public void setTags(List<String> tags) {
-        this.tags = Lazy.of(tags);
+        this.tags = () -> requireNonNull(tags);
     }
 
     public boolean isClean() {
         return clean.get();
     }
 
+    public void setDescribeTagPattern(Pattern describeTagPattern) {
+        this.describeTagPattern = requireNonNull(describeTagPattern);
+        this.description = Lazy.by(this::describe);
+    }
+
+    public Pattern getDescribeTagPattern() {
+        return describeTagPattern;
+    }
+
     public GitDescription getDescription() {
         return description.get();
     }

src/main/java/me/qoomon/gitversioning/commons/GitUtil.java

@@ -66,6 +66,10 @@ public static GitDescription describe(Repository repository, ObjectId revObjectI
     public static GitDescription describe(Repository repository, ObjectId revObjectId, Pattern tagPattern,
                                           Map<ObjectId, List<Ref>> reverseTagRefMap) throws IOException {
 
+        if(revObjectId == null) {
+            return new GitDescription(NO_COMMIT, "root", 0);
+        }
+
         // Walk back commit ancestors looking for tagged one
         try (RevWalk walk = new RevWalk(repository)) {
             walk.setRetainBody(false);

src/main/java/me/qoomon/gitversioning/commons/Lazy.java

@@ -1,14 +1,17 @@
 package me.qoomon.gitversioning.commons;
 
 
+import java.util.concurrent.Callable;
+import java.util.function.Supplier;
+
 import static java.util.Objects.requireNonNull;
 
-public final class Lazy<T> {
+public final class Lazy<T> implements Supplier<T> {
 
-    private volatile Initializer<T> initializer;
-    private T object;
+    private volatile Callable<T> initializer;
+    private volatile T value;
 
-    public Lazy(Initializer<T> initializer) {
+    public Lazy(Callable<T> initializer) {
         this.initializer = requireNonNull(initializer);
     }
 
@@ -17,27 +20,29 @@ public T get() {
             synchronized (this) {
                 if (initializer != null) {
                     try {
-                        object = initializer.get();
-                        initializer = null;
+                        value = initializer.call();
                     } catch (Exception e) {
                         throw new RuntimeException(e);
                     }
+                    initializer = null;
                 }
             }
         }
-        return object;
+        return value;
     }
 
     public static <T> Lazy<T> of(T value) {
         return new Lazy<>(() -> value);
     }
 
-    public static <T> Lazy<T> of(Initializer<T> initializer) {
-        return new Lazy<>(initializer);
+    public static <T> Lazy<T> by(Callable<T> supplier) {
+        return new Lazy<>(supplier);
     }
 
-    @FunctionalInterface
-    public interface Initializer<T> {
-        T get() throws Exception;
+    public static <V> V get(Lazy<V> value) {
+        if (value != null) {
+            return value.get();
+        }
+        return null;
     }
 }

src/main/java/me/qoomon/gitversioning/commons/StringUtil.java

@@ -4,18 +4,20 @@
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Supplier;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 public final class StringUtil {
 
-    public static String substituteText(String text, Map<String, String> replacements) {
+    public static String substituteText(String text, Map<String, Supplier<String>> replacements) {
         StringBuffer result = new StringBuffer();
         Pattern placeholderPattern = Pattern.compile("\\$\\{(?<key>[^}:]+)(?::(?<modifier>[-+])(?<value>[^}]*))?}");
         Matcher placeholderMatcher = placeholderPattern.matcher(text);
         while (placeholderMatcher.find()) {
             String placeholderKey = placeholderMatcher.group("key");
-            String replacement = replacements.get(placeholderKey);
+            Supplier<String> replacementSupplier = replacements.get(placeholderKey);
+            String replacement = replacementSupplier != null ? replacementSupplier.get() : null;
             String placeholderModifier = placeholderMatcher.group("modifier");
             if(placeholderModifier != null){
                 if (placeholderModifier.equals("-") && replacement == null) {
@@ -40,15 +42,15 @@ public static String substituteText(String text, Map<String, String> replacement
      * @param regex regular expression
      * @return a map of group-index and group-name to matching value
      */
-    public static Map<String, String> valueGroupMap(String text, String regex) {
-        return valueGroupMap(text, Pattern.compile(regex));
+    public static Map<String, String> patternGroupValues(String text, String regex) {
+        return patternGroupValues(Pattern.compile(regex), text);
     }
     /**
-     * @param text  to parse
      * @param pattern pattern
+     * @param text  to parse
      * @return a map of group-index and group-name to matching value
      */
-    public static Map<String, String> valueGroupMap(String text, Pattern pattern) {
+    public static Map<String, String> patternGroupValues(Pattern pattern, String text) {
         Map<String, String> result = new HashMap<>();
         Matcher groupMatcher = pattern.matcher(text);
         if (groupMatcher.find()) {
@@ -57,14 +59,14 @@ public static Map<String, String> valueGroupMap(String text, Pattern pattern) {
                 result.put(String.valueOf(i), groupMatcher.group(i));
             }
 
-            for (String groupName : patternGroupNames(pattern)) {
+            for (String groupName : patternGroups(pattern)) {
                 result.put(groupName, groupMatcher.group(groupName));
             }
         }
         return result;
     }
 
-    private static Set<String> patternGroupNames(Pattern groupPattern) {
+    public static Set<String> patternGroups(Pattern groupPattern) {
         Set<String> groupNames = new HashSet<>();
         Pattern groupNamePattern = Pattern.compile("\\(\\?<(?<name>[a-zA-Z][a-zA-Z0-9]*)>");
         Matcher groupNameMatcher = groupNamePattern.matcher(groupPattern.toString());