Valid tags give a default offset of 0

Previously, tags that were created for a subproject needed to include a
commit that modified a file within the path. This is no longer required
and as long as the tag is created for the project's tag prefix, it will
be counted as part of the project.

For example, for project hash-utils with tag prefix 'hash', we have
three commits:
1. An empty commit tagged 'hash-0.3'
2. A commit that modifies a file in the 'hash-utils' directory
3. A commit that does not modify any files in 'hash-utils'

Commits 1 and 2 would be counted, but 3 would not. The resulting
version number will be 0.3.1.

This is currently using an implementation detail regarding how JGit's
LogCommand returns its result. See eclipse-jgit/jgit#149

Author: Jonathing

build.gradle

@@ -39,6 +39,7 @@ dependencies {
     shadowOnly libs.slf4j
     shadowOnly libs.jopt
     compileOnly libs.jopt
+    //runtimeOnly libs.jopt
 
     // Static Analysis
     compileOnly libs.nulls

src/main/java/net/minecraftforge/gitver/internal/GitChangelog.java

@@ -44,11 +44,11 @@ static String generateChangelogFromTo(Git git, String repositoryUrl, boolean pla
 
         var changeLogName = Util.replace(git.getRepository().getFullBranch(), s -> s.replace("refs/heads/", "")); //Generate a changelog name from the current branch.
 
-        var log = GitUtils.getCommitLogFromTo(git, start, end, filter); //Get all commits between the start and the end.
+        var tagMap = GitUtils.getCommitToTagMap(git, tagPrefix); //Grab a map between commits and tag names.
+        var log = GitUtils.getCommitLogFromTo(git, tagMap, start, end, tagPrefix, filter); //Get all commits between the start and the end.
         var logList = new ArrayList<RevCommit>(); //And generate a list from it.
         log.forEach(logList::add);
 
-        var tagMap = GitUtils.getCommitToTagMap(git, tagPrefix); //Grab a map between commits and tag names.
         var versionMap = GitUtils.buildVersionMap(logList, tagMap); //And generate a version map from this. Mapping each commit to a unique version.
         var primaryVersionMap = GitUtils.getPrimaryVersionMap(logList, tagMap); //Then determine which commits belong to which identifiable-version mappings.
 

src/main/java/net/minecraftforge/gitver/internal/GitUtils.java

@@ -8,11 +8,14 @@
 import org.eclipse.jgit.api.ListBranchCommand;
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.errors.MissingObjectException;
+import org.eclipse.jgit.errors.StopWalkException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.revwalk.TreeRevFilter;
+import org.eclipse.jgit.revwalk.filter.OrRevFilter;
 import org.eclipse.jgit.revwalk.filter.RevFilter;
 import org.eclipse.jgit.transport.RemoteConfig;
 import org.eclipse.jgit.util.StringUtils;
@@ -62,7 +65,7 @@ static String getRelativePath(File root, File file) {
      * Counts commits, for the given Git repository, from the given tag to {@linkplain Constants#HEAD HEAD}. If the
      * given tag cannot be found, this method will return {@code -1}.
      * <p>
-     * See {@link #countCommits(Git, ObjectId, Iterable, Iterable)} for more information.
+     * See {@link #countCommits(Git, Map, ObjectId, String, Iterable, Iterable)} for more information.
      *
      * @param git          The git repository to count commits in
      * @param tag          The tag name to start counting from
@@ -72,14 +75,14 @@ static String getRelativePath(File root, File file) {
      * @throws GitAPIException If an error occurs when running the log command (see
      *                         {@link org.eclipse.jgit.api.LogCommand#call() LogCommand.call()}
      * @throws IOException     If an I/O error occurs when reading the Git repository
-     * @see #countCommits(Git, ObjectId, Iterable, Iterable)
+     * @see #countCommits(Git, Map, ObjectId, String, Iterable, Iterable)
      */
-    static int countCommits(Git git, String tag, Iterable<String> includePaths, Iterable<String> excludePaths) throws GitAPIException, IOException {
+    static int countCommits(Git git, String tag, String tagPrefix, Iterable<String> includePaths, Iterable<String> excludePaths) throws GitAPIException, IOException {
         var tags = GitUtils.getTagToCommitMap(git);
         var commitHash = tags.get(tag);
         if (commitHash == null) return -1;
 
-        return countCommits(git, ObjectId.fromString(commitHash), includePaths, excludePaths);
+        return countCommits(git, GitUtils.getCommitToTagMap(git), ObjectId.fromString(commitHash), tagPrefix, includePaths, excludePaths);
     }
 
     /**
@@ -102,8 +105,8 @@ static int countCommits(Git git, String tag, Iterable<String> includePaths, Iter
      * @see org.eclipse.jgit.api.LogCommand LogCommand
      * @see <a href="https://git-scm.com/docs/git-log"><code>git-log</code></a>
      */
-    static int countCommits(Git git, ObjectId from, Iterable<String> includePaths, Iterable<String> excludePaths) throws GitAPIException, IOException {
-        return Util.count(getCommitLogFromTo(git, from, getHead(git), includePaths, excludePaths));
+    static int countCommits(Git git, Map<String, String> commitsToTags, ObjectId from, String tagPrefix, Iterable<String> includePaths, Iterable<String> excludePaths) throws GitAPIException, IOException {
+        return Util.count(getCommitLogFromTo(git, commitsToTags, from, getHead(git), tagPrefix, includePaths, excludePaths));
     }
 
     /**
@@ -157,8 +160,8 @@ static RevCommit getCommitFromId(Git git, ObjectId other) throws IOException {
      *                         {@link org.eclipse.jgit.api.LogCommand#call() LogCommand.call()}
      * @throws IOException     If an I/O error occurs when reading the Git repository
      */
-    static Iterable<RevCommit> getCommitLogFromTo(Git git, ObjectId from, ObjectId to, Iterable<String> includePaths) throws GitAPIException, IOException {
-        return getCommitLogFromTo(git, from, to, includePaths, Collections::emptyIterator);
+    static Iterable<RevCommit> getCommitLogFromTo(Git git, Map<String, String> tags, ObjectId from, ObjectId to, String tagPrefix, Iterable<String> includePaths) throws GitAPIException, IOException {
+        return getCommitLogFromTo(git, tags, from, to, tagPrefix, includePaths, Collections::emptyIterator);
     }
 
     /**
@@ -174,7 +177,7 @@ static Iterable<RevCommit> getCommitLogFromTo(Git git, ObjectId from, ObjectId t
      *                         {@link org.eclipse.jgit.api.LogCommand#call() LogCommand.call()}
      * @throws IOException     If an I/O error occurs when reading the Git repository
      */
-    static Iterable<RevCommit> getCommitLogFromTo(Git git, ObjectId from, ObjectId to, Iterable<String> includePaths, Iterable<String> excludePaths) throws GitAPIException, IOException {
+    static Iterable<RevCommit> getCommitLogFromTo(Git git, Map<String, String> commitsToTags, ObjectId from, ObjectId to, String tagPrefix, Iterable<String> includePaths, Iterable<String> excludePaths) throws GitAPIException, IOException {
         var start = getCommitFromId(git, from);
         var end = getCommitFromId(git, to);
 
@@ -185,13 +188,25 @@ static Iterable<RevCommit> getCommitLogFromTo(Git git, ObjectId from, ObjectId t
             log.not(parent);
         // We do not exclude the starting commit itself, so the commit is present in the returned iterable
 
-        for (var path : includePaths)
-            log.addPath(path);
+        boolean hasFilters = Util.forEach(includePaths, log::addPath) || Util.forEach(excludePaths, log::excludePath);
 
-        for (var path : excludePaths)
-            log.excludePath(path);
+        // TODO [GitVersion][JGit] PR in a solution for creating an OR rev filter
+        return Util.make((RevWalk) log.call(), walk -> {
+            if (!hasFilters || StringUtils.isEmptyOrNull(tagPrefix) || commitsToTags == null || commitsToTags.isEmpty()) return;
 
-        return log.call();
+            walk.setRevFilter(OrRevFilter.create(new TreeRevFilter(walk, walk.getTreeFilter()), new RevFilter() {
+                @Override
+                public boolean include(RevWalk walker, RevCommit cmit) throws StopWalkException {
+                    return commitsToTags.getOrDefault(ObjectId.toString(cmit), "").startsWith(tagPrefix);
+                }
+
+                @Override
+                public RevFilter clone() {
+                    throw new UnsupportedOperationException();
+                }
+            }));
+            walk.setTreeFilter(null);
+        });
     }
 
     /**

src/main/java/net/minecraftforge/gitver/internal/GitVersionImpl.java

@@ -300,12 +300,10 @@ private int getSubprojectCommitCount(Git git, String tag) {
 
         var includePaths = !this.localPath.isEmpty() ? Collections.singleton(this.localPath) : Collections.<String>emptySet();
         try {
-            int count = GitUtils.countCommits(git, tag, includePaths, excludePaths);
-            if (count >= 0) return count;
-
-            throw new GitVersionExceptionInternal("Couldn't find any commits with the following parameters: Tag %s, Include Paths [%s], Exclude Paths [%s]".formatted(tag, String.join(", ", includePaths), String.join(", ", excludePaths)));
+            int count = GitUtils.countCommits(git, tag, this.tagPrefix, includePaths, excludePaths);
+            return Math.max(count, 0);
         } catch (GitAPIException | IOException e) {
-            throw new GitVersionExceptionInternal("Failed to count commits", e);
+            throw new GitVersionExceptionInternal("Failed to count commits with the following parameters: Tag %s, Include Paths [%s], Exclude Paths [%s]".formatted(tag, String.join(", ", includePaths), String.join(", ", excludePaths)));
         }
     }
 

src/main/java/net/minecraftforge/gitver/internal/Util.java

@@ -101,6 +101,14 @@ static int count(Iterable<?> iterable) {
         return null;
     }
 
+    static <T> boolean forEach(Iterable<T> iterable, Consumer<T> action) {
+        var it = iterable.iterator();
+        if (!it.hasNext()) return false;
+
+        it.forEachRemaining(action);
+        return true;
+    }
+
     static <T> T make(Supplier<T> t) {
         return t.get();
     }