Add VersionDetails#isCleanTag (#58)

Author: iamdanfox

readme.md

@@ -36,6 +36,7 @@ details.lastTag
 details.commitDistance
 details.gitHash
 details.branchName // is null if the repository in detached HEAD mode
+details.isCleanTag
 ```
 
 Tasks

src/main/groovy/com/palantir/gradle/gitversion/GitCli.groovy

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2015 Palantir Technologies
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * <http://www.apache.org/licenses/LICENSE-2.0>
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.palantir.gradle.gitversion
+
+class GitCli {
+    private GitCli() {}
+
+    static void verifyGitCommandExists() {
+        Process gitVersionProcess = new ProcessBuilder("git", "version").start()
+        if (gitVersionProcess.waitFor() != 0) {
+            throw new IllegalStateException("error invoking git command")
+        }
+    }
+
+    static String runGitCommand(File dir, String... commands) {
+        List<String> cmdInput = new ArrayList<>()
+        cmdInput.add("git")
+        cmdInput.addAll(commands)
+        ProcessBuilder pb = new ProcessBuilder(cmdInput)
+        pb.directory(dir)
+        pb.redirectErrorStream(true)
+
+        Process process = pb.start()
+        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))
+
+        StringBuilder builder = new StringBuilder()
+        String line = null
+        while ((line = reader.readLine()) != null) {
+            builder.append(line)
+            builder.append(System.getProperty("line.separator"))
+        }
+
+        int exitCode = process.waitFor()
+        if (exitCode != 0) {
+            return ""
+        }
+
+        return builder.toString().trim()
+    }
+
+    static File getRootGitDir(File currentRoot) {
+        File gitDir = scanForRootGitDir(currentRoot)
+        if (!gitDir.exists()) {
+            throw new IllegalArgumentException('Cannot find \'.git\' directory')
+        }
+        return gitDir
+    }
+
+    private static File scanForRootGitDir(File currentRoot) {
+        File gitDir = new File(currentRoot, '.git')
+
+        if (gitDir.exists()) {
+            return gitDir
+        }
+
+        // stop at the root directory, return non-existing File object
+        if (currentRoot.parentFile == null) {
+            return gitDir
+        }
+
+        // look in parent directory
+        return scanForRootGitDir(currentRoot.parentFile)
+    }
+}

src/main/groovy/com/palantir/gradle/gitversion/GitVersionPlugin.groovy

@@ -20,153 +20,89 @@ import org.eclipse.jgit.api.DescribeCommand
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.internal.storage.file.FileRepository
 import org.eclipse.jgit.lib.Constants
+import org.eclipse.jgit.lib.ObjectId
+import org.eclipse.jgit.lib.Ref
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 
-import java.util.regex.Matcher
-
 class GitVersionPlugin implements Plugin<Project> {
 
-    // Gradle returns 'unspecified' when no version is set
-    private static final String UNSPECIFIED_VERSION = 'unspecified'
     private static final int VERSION_ABBR_LENGTH = 10
 
+    void apply(Project project) {
+        project.ext.gitVersion = {
+            return versionDetails(project).version
+        }
+
+        project.ext.versionDetails = {
+            return versionDetails(project)
+        }
+
+        project.tasks.create('printVersion') {
+            group = 'Versioning'
+            description = 'Prints the project\'s configured version to standard out'
+            doLast {
+                println project.version
+            }
+        }
+    }
+
     @Memoized
-    private File gitDir(Project project) {
-        return getRootGitDir(project.rootDir)
+    private VersionDetails versionDetails(Project project) {
+        String description = gitDescribe(project)
+        String hash = gitHash(project)
+        String branchName = gitBranchName(project)
+        boolean isClean = isClean(project)
+
+        return new VersionDetails(description, hash, branchName, isClean)
     }
 
     @Memoized
     private Git gitRepo(Project project) {
-        return Git.wrap(new FileRepository(gitDir(project)))
+        File gitDir = GitCli.getRootGitDir(project.rootDir);
+        return Git.wrap(new FileRepository(gitDir))
     }
 
     @Memoized
-    private String gitDesc(Project project) {
+    private String gitDescribe(Project project) {
         // verify that "git" command exists (throws exception if it does not)
-        verifyGitCommandExists()
+        GitCli.verifyGitCommandExists()
 
         Git git = gitRepo(project)
         try {
             // back-compat: the JGit "describe" command throws an exception in repositories with no commits, so call it
             // first to preserve this behavior in cases where this call would fail but native "git" call does not.
             new DescribeCommand(git.getRepository()).call()
 
-            String version = runGitCommand(project.rootDir, "describe", "--tags", "--always", "--first-parent") ?: UNSPECIFIED_VERSION
-            boolean isClean = git.status().call().isClean()
-            return version + (isClean ? '' : '.dirty')
+            return GitCli.runGitCommand(project.rootDir, "describe", "--tags", "--always", "--first-parent")
         } catch (Throwable t) {
-            return UNSPECIFIED_VERSION
+            return null
         }
     }
 
     @Memoized
     private String gitHash(Project project) {
         Git git = gitRepo(project)
-        return git.getRepository().getRef("HEAD").getObjectId().abbreviate(VERSION_ABBR_LENGTH).name()
+        ObjectId objectId = git.getRepository().getRef("HEAD").getObjectId();
+        if (objectId == null) {
+            return null
+        }
+        return objectId.abbreviate(VERSION_ABBR_LENGTH).name()
     }
 
     @Memoized
     private String gitBranchName(Project project) {
         Git git = gitRepo(project)
-        def ref = git.repository.getRef(git.repository.branch)
+        Ref ref = git.getRepository().getRef(git.repository.branch)
         if (ref == null) {
             return null
-        } else {
-            return ref.getName().substring(Constants.R_HEADS.length())
         }
+        return ref.getName().substring(Constants.R_HEADS.length())
     }
 
-    void apply(Project project) {
-        project.ext.gitVersion = {
-            return gitDesc(project)
-        }
-
-        project.ext.versionDetails = {
-            String description = gitDesc(project)
-            if (description.equals(UNSPECIFIED_VERSION)) {
-                return null
-            }
-
-            String hash = gitHash(project)
-            String branchName = gitBranchName(project)
-
-            if (!(description =~ /.*g.?[0-9a-fA-F]{3,}/)) {
-                // Description has no git hash so it is just the tag name
-                return new VersionDetails(description, 0, hash, branchName)
-            }
-
-            Matcher match = (description =~ /(.*)-([0-9]+)-g.?[0-9a-fA-F]{3,}/)
-            String tagName = match[0][1]
-            int commitCount = Integer.valueOf(match[0][2])
-
-            return new VersionDetails(tagName, commitCount, hash, branchName)
-        }
-
-        project.tasks.create('printVersion') {
-            group = 'Versioning'
-            description = 'Prints the project\'s configured version to standard out'
-            doLast {
-                println project.version
-            }
-        }
-    }
-
-    private static File getRootGitDir(currentRoot) {
-        File gitDir = scanForRootGitDir(currentRoot)
-        if (!gitDir.exists()) {
-            throw new IllegalArgumentException('Cannot find \'.git\' directory')
-        }
-        return gitDir
-    }
-
-    private static File scanForRootGitDir(File currentRoot) {
-        File gitDir = new File(currentRoot, '.git')
-
-        if (gitDir.exists()) {
-            return gitDir
-        }
-
-        // stop at the root directory, return non-existing File object
-        if (currentRoot.parentFile == null) {
-            return gitDir
-        }
-
-        // look in parent directory
-        return scanForRootGitDir(currentRoot.parentFile)
-    }
-
-    private static void verifyGitCommandExists() {
-        Process gitVersionProcess = new ProcessBuilder("git", "version").start()
-        if (gitVersionProcess.waitFor() != 0) {
-            throw new IllegalStateException("error invoking git command")
-        }
-    }
-
-    private static String runGitCommand(File dir, String ...commands) {
-        List<String> cmdInput = new ArrayList<>()
-        cmdInput.add("git")
-        cmdInput.addAll(commands)
-        ProcessBuilder pb = new ProcessBuilder(cmdInput)
-        pb.directory(dir)
-        pb.redirectErrorStream(true)
-
-        Process process = pb.start()
-        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))
-
-        StringBuilder builder = new StringBuilder()
-        String line = null
-        while ((line = reader.readLine()) != null) {
-            builder.append(line)
-            builder.append(System.getProperty("line.separator"))
-        }
-
-        int exitCode = process.waitFor()
-        if (exitCode != 0) {
-            return ""
-        }
-
-        return builder.toString().trim()
+    @Memoized
+    private boolean isClean(Project project) {
+        Git git = gitRepo(project)
+        return git.status().call().isClean();
     }
-
 }

src/main/groovy/com/palantir/gradle/gitversion/VersionDetails.groovy

@@ -17,25 +17,61 @@ package com.palantir.gradle.gitversion;
 
 import groovy.transform.*
 
-/**
- * POGO containing the tag name and commit count that make
- * up the version string.
- */
+import java.util.regex.Matcher
+
 @ToString
 @EqualsAndHashCode
 class VersionDetails implements Serializable {
+
+    // Gradle returns 'unspecified' when no version is set
+    private static final String UNSPECIFIED_VERSION = 'unspecified'
     private static final long serialVersionUID = -7340444937169877612L;
 
-    final String lastTag;
-    final int commitDistance;
+    final String description;
     final String gitHash;
     final String branchName;
+    final boolean isClean;
 
-    public VersionDetails(String lastTag, int commitDistance, String gitHash, String branchName) {
-        this.lastTag = lastTag;
-        this.commitDistance = commitDistance;
+    public VersionDetails(String description, String gitHash, String branchName, boolean isClean) {
+        this.description = description;
         this.gitHash = gitHash;
-        this.branchName = branchName
+        this.branchName = branchName;
+        this.isClean = isClean;
+    }
+
+    public String getVersion() {
+        if (description == null) {
+            return UNSPECIFIED_VERSION
+        }
+
+        return description + (isClean ? '' : '.dirty')
+    }
+
+    public boolean getIsCleanTag() {
+        return isClean && descriptionIsPlainTag();
     }
 
+    public int getCommitDistance() {
+        if (descriptionIsPlainTag()) {
+            return 0;
+        }
+
+        Matcher match = (description =~ /(.*)-([0-9]+)-g.?[0-9a-fA-F]{3,}/)
+        int commitCount = Integer.valueOf(match[0][2])
+        return commitCount;
+    }
+
+    public String getLastTag() {
+        if (descriptionIsPlainTag()) {
+            return description;
+        }
+
+        Matcher match = (description =~ /(.*)-([0-9]+)-g.?[0-9a-fA-F]{3,}/)
+        String tagName = match[0][1]
+        return tagName;
+    }
+
+    private boolean descriptionIsPlainTag() {
+        return !(description =~ /.*g.?[0-9a-fA-F]{3,}/);
+    }
 }