Release by Condition, closes #112

gradle-plugin/build.gradle

@@ -13,7 +13,7 @@ repositories {
 
 dependencies {
     implementation project(":gver-dsl")
-    implementation "org.dmfs:semver:0.2.0"
+    implementation "org.dmfs:semver:0.2.2"
     implementation 'org.eclipse.jgit:org.eclipse.jgit:6.7.0.202309050840-r'
     implementation 'org.dmfs:srcless-annotations:0.3.0'
     implementation "org.dmfs:jems2:2.19.0"

gradle-plugin/src/main/java/org/dmfs/gradle/gver/GitVersionPlugin.java

@@ -1,12 +1,13 @@
 package org.dmfs.gradle.gver;
 
+import org.dmfs.gradle.gver.tasks.TagPreReleaseTask;
 import org.dmfs.gradle.gver.tasks.TagReleaseTask;
 import org.dmfs.gradle.gver.tasks.TagTask;
+import org.dmfs.gradle.gver.tasks.VersionTask;
 import org.dmfs.gradle.gver.utils.ProjectRepositoryFunction;
 import org.dmfs.gver.dsl.GitVersionConfig;
 import org.dmfs.gver.git.GitVersion;
 import org.dmfs.gver.git.changetypefacories.FirstOf;
-import org.dmfs.gradle.gver.tasks.VersionTask;
 import org.dmfs.jems2.Single;
 import org.dmfs.jems2.single.Frozen;
 import org.dmfs.semver.VersionSequence;
@@ -73,6 +74,7 @@ public String toString()
 
         project.getTasks().register("gitTag", TagTask.class);
         project.getTasks().register("gitTagRelease", TagReleaseTask.class);
+        project.getTasks().register("gitTagPreRelease", TagPreReleaseTask.class);
         project.getTasks().register("gitVersion", VersionTask.class);
 
         project.subprojects(subproject -> subproject.setVersion(project.getVersion()));

gradle-plugin/src/main/java/org/dmfs/gradle/gver/tasks/ApplicableReleaseTypes.java

@@ -0,0 +1,21 @@
+package org.dmfs.gradle.gver.tasks;
+
+import org.dmfs.gver.dsl.GitVersionConfig;
+import org.dmfs.gver.dsl.ReleaseType;
+import org.dmfs.jems2.iterable.DelegatingIterable;
+import org.dmfs.jems2.iterable.Mapped;
+import org.dmfs.jems2.iterable.Sieved;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+
+import java.util.Map;
+
+public final class ApplicableReleaseTypes extends DelegatingIterable<ReleaseType>
+{
+    public ApplicableReleaseTypes(GitVersionConfig config, Repository repository, RevCommit revCommit, String name)
+    {
+        super(new Mapped<>(Map.Entry::getValue,
+            new Sieved<>(entry -> entry.getKey().matches(repository, revCommit, name),
+                config.mTagConfig.mTagMappings.entrySet())));
+    }
+}

gradle-plugin/src/main/java/org/dmfs/gradle/gver/tasks/TagPreReleaseTask.java

@@ -0,0 +1,69 @@
+package org.dmfs.gradle.gver.tasks;
+
+import org.dmfs.gradle.gver.utils.ProjectRepositoryFunction;
+import org.dmfs.gver.dsl.GitVersionConfig;
+import org.dmfs.jems2.iterable.Mapped;
+import org.dmfs.jems2.optional.First;
+import org.dmfs.semver.StrictParser;
+import org.dmfs.semver.VersionSequence;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Repository;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.Task;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.IOException;
+
+import static org.dmfs.gver.dsl.ReleaseType.PRERELEASE;
+import static org.eclipse.jgit.lib.Constants.R_TAGS;
+
+
+/**
+ * A Gradle {@link Task} that tags the current HEAD with a new pre-release version.
+ * Note, that this task will throw an {@link IllegalStateException} when the current HEAD is not on a pre-release branch.
+ */
+public class TagPreReleaseTask extends DefaultTask
+{
+    public TagPreReleaseTask()
+    {
+        setGroup("gver");
+        setDescription("Tags the HEAD commit with a new pre-release version.");
+    }
+
+    @TaskAction
+    public void perform() throws IOException, GitAPIException
+    {
+        try (Repository r = ProjectRepositoryFunction.INSTANCE.value(getProject()))
+        {
+            Git git = new Git(r);
+            GitVersionConfig config = (GitVersionConfig) getProject().getExtensions().getByName("gver");
+            ObjectId head = r.resolve("HEAD");
+
+            if (!new First<>(PRERELEASE::equals, new ApplicableReleaseTypes(config, r, r.parseCommit(head), r.getBranch()))
+                .isPresent())
+            {
+                throw new IllegalStateException("Not adding a release tag on non-pre-release branch");
+            }
+
+            getLogger().lifecycle(getProject().getVersion().toString());
+            getLogger().lifecycle(""+new StrictParser().parse(getProject().getVersion().toString()).build().isPresent());
+            String version = new VersionSequence(new StrictParser().parse(getProject().getVersion().toString())).toString();
+
+            if (!new First<>(version::equals,
+                new Mapped<>(tag -> tag.getName().startsWith(R_TAGS) ? tag.getName().substring(R_TAGS.length()) : tag.getName(),
+                    git.tagList().call())).isPresent())
+            {
+                git.tag()
+                    .setObjectId(r.parseCommit(head))
+                    .setName(version)
+                    .call();
+            }
+            else
+            {
+                getLogger().lifecycle("Tag {} already exists. Not adding tag.", version);
+            }
+        }
+    }
+}

gradle-plugin/src/main/java/org/dmfs/gradle/gver/tasks/TagReleaseTask.java

@@ -17,6 +17,7 @@
 
 import java.io.IOException;
 
+import static org.dmfs.gver.dsl.ReleaseType.RELEASE;
 import static org.eclipse.jgit.lib.Constants.R_TAGS;
 
 
@@ -41,9 +42,8 @@ public void perform() throws IOException, GitAPIException
             GitVersionConfig config = (GitVersionConfig) getProject().getExtensions().getByName("gver");
             ObjectId head = r.resolve("HEAD");
 
-            if (!new First<>(branch -> config.mReleaseBranchPattern.matcher(branch).lookingAt(), git.nameRev()
-                .addPrefix("refs/heads")
-                .add(head).call().values()).isPresent())
+            if (!new First<>(RELEASE::equals, new ApplicableReleaseTypes(config, r, r.parseCommit(head), r.getBranch()))
+                .isPresent())
             {
                 throw new IllegalStateException("Not adding a release tag on non-release branch");
             }

gradle-plugin/src/test/java/org/dmfs/gradle/gver/utils/TestProject.java

@@ -2,6 +2,7 @@
 
 import org.dmfs.gver.dsl.GitVersionConfig;
 import org.dmfs.gver.dsl.Strategy;
+import org.dmfs.gver.dsl.TagConfig;
 import org.dmfs.gver.git.Suffixes;
 import org.gradle.api.Project;
 import org.gradle.testfixtures.ProjectBuilder;

gver-dsl/build.gradle

@@ -1,5 +1,6 @@
 plugins {
     id 'groovy'
+    id 'java-library'
     id 'maven-publish'
 }
 
@@ -26,11 +27,11 @@ dependencies {
     annotationProcessor 'org.dmfs:nullless-processors:0.3.0'
 
     compileOnly 'org.codehaus.groovy:groovy-all:2.5.19'
-    implementation "org.dmfs:semver:0.2.0"
+    api "org.dmfs:semver:0.2.2"
     implementation "org.dmfs:rfc5545-datetime:0.3"
     implementation 'org.eclipse.jgit:org.eclipse.jgit:6.7.0.202309050840-r'
     implementation 'org.dmfs:srcless-annotations:0.3.0'
-    implementation "org.dmfs:jems2:2.19.0"
+    api "org.dmfs:jems2:2.19.0"
 
     testAnnotationProcessor 'org.dmfs:srcless-processors:0.3.0'
 

gver-dsl/src/main/java/org/dmfs/gver/dsl/GitVersionConfig.java

@@ -6,6 +6,7 @@
 import org.dmfs.gver.dsl.issuetracker.GitHub;
 import org.dmfs.gver.dsl.issuetracker.Gitea;
 import org.dmfs.gver.git.Suffixes;
+import org.dmfs.gver.git.changetypefacories.condition.Branch;
 
 import java.util.Optional;
 import java.util.function.Predicate;
@@ -29,6 +30,13 @@ public class GitVersionConfig
     public Closure conventionalCommits = new ConventionalCommits(this);
     public Closure strictConventionalCommits = new StrictConventionalCommits(this);
 
+    public TagConfig mTagConfig = new TagConfig();
+
+    public GitVersionConfig(){
+        // provide legacy config as default
+        setReleaseBranchPattern(Pattern.compile("main|master"));
+    }
+
     public void setIssueTracker(IssueTracker issueTracker)
     {
         this.issueTracker = Optional.of(issueTracker);
@@ -57,7 +65,8 @@ public IssueTracker Gitea(Closure<?> closure)
 
     public void setReleaseBranchPattern(Pattern releaseBranchPattern)
     {
-        mReleaseBranchPattern = releaseBranchPattern;
+        mTagConfig.mTagMappings.put(new Branch(branch -> releaseBranchPattern.matcher(branch).matches()), ReleaseType.RELEASE);
+        mTagConfig.mTagMappings.put(new Branch(branch -> releaseBranchPattern.matcher(branch).matches()), ReleaseType.PRERELEASE);
     }
 
 
@@ -110,4 +119,12 @@ public void suffixes(Closure<?> closure)
         closure.call();
     }
 
+    public void tag(Closure<?> closure)
+    {
+        mTagConfig.mTagMappings.clear();
+        closure.setResolveStrategy(Closure.DELEGATE_FIRST);
+        closure.setDelegate(mTagConfig);
+        closure.call();
+    }
+
 }

gver-dsl/src/main/java/org/dmfs/gver/dsl/ReleaseType.java

@@ -0,0 +1,8 @@
+package org.dmfs.gver.dsl;
+
+public enum ReleaseType
+{
+    RELEASE,
+    PRERELEASE,
+    NOTHING
+}

gver-dsl/src/main/java/org/dmfs/gver/dsl/TagConfig.java

@@ -0,0 +1,41 @@
+package org.dmfs.gver.dsl;
+
+import groovy.lang.Closure;
+import org.dmfs.gver.git.changetypefacories.Condition;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public final class TagConfig
+{
+    public final Map<Condition, ReleaseType> mTagMappings = new LinkedHashMap<>();
+
+    public final ReleaseType release = ReleaseType.RELEASE;
+    public final ReleaseType preRelease = ReleaseType.PRERELEASE;
+    public final ReleaseType nothing = ReleaseType.NOTHING;
+
+    public ConditionConsumer with(ReleaseType type)
+    {
+        return new ConditionConsumer()
+        {
+            @Override
+            public void when(Closure<?> condition)
+            {
+                Conditions conditions = new Conditions();
+                condition.setResolveStrategy(Closure.DELEGATE_FIRST);
+                condition.setDelegate(conditions);
+                condition.call();
+
+                mTagMappings.put(conditions, type);
+            }
+
+            @Override
+            public Void getOtherwise()
+            {
+                mTagMappings.put((repository, commit, branch) -> true, type);
+                return null;
+            }
+
+        };
+    }
+}

gver-dsl/src/test/java/org/dmfs/gver/git/changetypefacories/condition/EnvVariableTest.java

@@ -17,7 +17,7 @@ class EnvVariableTest
     void testFooBar()
     {
         assertThat(new EnvVariable("GVER_TEST_VARIABLE_FOOBAR", "foobar"::equals),
-            new Matches(mock(Repository.class), mock(RevCommit.class), "branch"));
+            new Matches(mock(Repository.class), mock("commit", RevCommit.class), "branch"));
     }
 
     @Test