Merge pull request #110 from philippart-s/bug-non-annotated-tag

bug: Support non annotated tag

Author: Stéphane Philippart

.gitignore

@@ -2,3 +2,6 @@
 *.iml
 target
 work
+.classpath
+.settings
+.project

README.md

@@ -9,6 +9,7 @@
 ## Introduction
 
 This plugin can be used to determine the next release version based on previous tags and the commit messages used.  
+:warning: By default only [annotated tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging) are supported, to support non annotated tag you must use an option to activate this feature (see below).:warning: 
 It calculates the version number based on the format of the commit message.  
 The commit message format used is [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/).
 

src/main/java/io/jenkins/plugins/conventionalcommits/NextVersionStep.java

@@ -16,6 +16,7 @@
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import javax.annotation.Nonnull;
 import org.apache.commons.lang.StringUtils;
@@ -40,6 +41,8 @@ public class NextVersionStep extends Step {
   private boolean incrementPreRelease;
   private String buildMetadata;
   private boolean writeVersion;
+  // True if non annotated tag are supported
+  private boolean nonAnnotatedTag;
 
   @DataBoundConstructor
   public NextVersionStep() {
@@ -123,6 +126,11 @@ public void setIncrementPreRelease(boolean incrementPreRelease) {
     this.incrementPreRelease = incrementPreRelease;
   }
 
+  @DataBoundSetter
+  public void setNonAnnotatedTag(boolean nonAnnotatedTag) {
+    this.nonAnnotatedTag = nonAnnotatedTag;
+  }
+
   @Override
   public StepExecution start(StepContext stepContext) throws Exception {
     return new Execution(
@@ -133,6 +141,7 @@ public StepExecution start(StepContext stepContext) throws Exception {
         preRelease,
         preservePreRelease,
         incrementPreRelease,
+        nonAnnotatedTag,
         stepContext);
   }
 
@@ -179,6 +188,13 @@ public static class Execution extends SynchronousStepExecution<String> {
     // True to increment prerelease information instead of the version itself
     private final transient boolean incrementPreRelease;
 
+    // True if annotated tags are supported
+    @SuppressFBWarnings(
+        value = "SE_TRANSIENT_FIELD_NOT_RESTORED",
+        justification = "Only used when starting.")
+    private final transient boolean nonAnnotatedTag;
+
+
     /**
      * Constructor with fields initialisation.
      *
@@ -189,6 +205,7 @@ public static class Execution extends SynchronousStepExecution<String> {
      * @param preRelease Pre release information to add
      * @param preservePreRelease Keep existing prerelease information or not
      * @param incrementPreRelease Increment prerelease information or not
+     * @param nonAnnotatedTag Should use or non annotated tags
      * @param context Jenkins context
      */
     protected Execution(
@@ -199,6 +216,7 @@ protected Execution(
         String preRelease,
         boolean preservePreRelease,
         boolean incrementPreRelease,
+        boolean nonAnnotatedTag,
         @Nonnull StepContext context) {
       super(context);
       this.outputFormat = outputFormat;
@@ -208,6 +226,36 @@ protected Execution(
       this.preRelease = preRelease;
       this.preservePreRelease = preservePreRelease;
       this.incrementPreRelease = incrementPreRelease;
+      this.nonAnnotatedTag = nonAnnotatedTag;
+    }
+
+    /**
+     * Return the last tag.
+     *
+     * @param dir The project's directory.
+     * @param includeNonAnnotatedTags If true include the non annotated tag.
+     *
+     * @return The last tag of the project.
+     */
+    private String getLatestTag(File dir, boolean includeNonAnnotatedTags)
+        throws InterruptedException, IOException {
+      Objects.requireNonNull(dir, "Directory is mandatory");
+      String latestTag = "";
+      try {
+        if (includeNonAnnotatedTags) {
+          latestTag = execute(dir, "git", "tag", "-l").trim();
+          latestTag = latestTag.substring(latestTag.lastIndexOf("\n") + 1);
+        } else {
+          latestTag = execute(dir, "git", "describe", "--abbrev=0", "--tags").trim();
+        }
+      } catch (IOException exp) {
+        if (exp.getMessage().contains("No names found, cannot describe anything.")) {
+          getContext().get(TaskListener.class).getLogger().println("No tags found");
+        }
+      }
+
+      getContext().get(TaskListener.class).getLogger().println("Current Tag is: " + latestTag);
+      return latestTag;
     }
 
     @Override
@@ -222,16 +270,7 @@ protected String run() throws Exception {
         throw new IOException("workspace.isRemote(), not entirely sure what to do here...");
       } else {
         File dir = new File(workspace.getRemote());
-        // git describe --abbrev=0 --tags
-        String latestTag = "";
-        try {
-          latestTag = execute(dir, "git", "describe", "--abbrev=0", "--tags").trim();
-          getContext().get(TaskListener.class).getLogger().println("Current Tag is: " + latestTag);
-        } catch (IOException exp) {
-          if (exp.getMessage().contains("No names found, cannot describe anything.")) {
-            getContext().get(TaskListener.class).getLogger().println("No tags found");
-          }
-        }
+        String latestTag = getLatestTag(dir, nonAnnotatedTag);
 
         Version currentVersion =
             new CurrentVersion()

src/test/java/io/jenkins/plugins/conventionalcommits/JenkinsTest.java

@@ -423,4 +423,30 @@ public void shouldFailWriteVersion() throws Exception {
             containsString("Could not write the next version to the configuration file."));
     assertThat(JenkinsRule.getLog(b), containsString("Finished: SUCCESS"));
   }
+
+  @Test
+  public void shouldUseNonAnnotatedTag() throws Exception {
+    // Given : a project with last tag (1.1.0) is non annotated
+    WorkflowJob p = rule.jenkins.createProject(WorkflowJob.class, "p");
+    URL zipFile = getClass().getResource("simple-project-with-non-annotated-tags.zip");
+    assertThat(zipFile, is(notNullValue()));
+
+    // When: ask to have nextVersion with nonAnnotatedTag option to true
+    p.setDefinition(
+        new CpsFlowDefinition(
+            "node {\n"
+                + "  unzip '"
+                + zipFile.getPath()
+                + "'\n"
+                + "  nextVersion(nonAnnotatedTag: true)\n"
+                + "}\n",
+            true));
+
+    // Then : the given nextVersion is based on the last tag (even if it's a non annotated tag)
+    WorkflowRun b = rule.assertBuildStatus(Result.SUCCESS, p.scheduleBuild2(0).get());
+    assertThat(JenkinsRule.getLog(b), containsString("Started"));
+    assertThat(JenkinsRule.getLog(b), containsString("nextVersion"));
+    assertThat(JenkinsRule.getLog(b), containsString("1.1.1"));
+    assertThat(JenkinsRule.getLog(b), containsString("Finished: SUCCESS"));
+  }
 }

src/test/java/io/jenkins/plugins/conventionalcommits/utils/GradleProjectTypeTest.java

@@ -95,18 +95,14 @@ public void shouldWriteNextVersionToFile() throws Exception {
     File gradleDir = rootFolder.newFolder("SampleGradleProject");
     createBuildGradleFiles(gradleDir, buildGradleWithVersionContent);
 
-    // When : write next version tp the file
+    // When : write next version to the file
     GradleProjectType gradleProjectType = new GradleProjectType();
     gradleProjectType.writeVersion(gradleDir, Version.valueOf("1.1.0"), null);
 
     // Then : the file is updated
-    String buildGradleExpected =
-        "foo = foo value\n" +
-            "version = 1.1.0\n" +
-            "bar = bar value";
     assertThat(new String(
             Files.readAllBytes(Paths.get(gradleDir.getPath() + File.separator + "gradle.properties"))),
-        containsString(buildGradleExpected));
+        containsString("version = 1.1.0"));
   }
 
   @Test(expected = IOException.class)