CDRIVER-4422 calc_release_version.py: remove --merged, plus improvements (#1060)

Detail of changes:
 * remove --merged option for compatibility with older versions of 'git'
 * fix bug that considered pre-release tags as higher than their
   succeeding releases (e.g., 1.22.0-beta0 was treated as a higher
   version tag than 1.22.0)
 * refactor to reduce code duplication, increase readability, and
   improve maintainability

Co-authored-by: Kevin Albertson <[email protected]>

Author: rcsanchez97

build/calc_release_version.py

@@ -72,28 +72,29 @@ def check_head_tag():
     """
     Checks the current HEAD to see if it has been tagged with a tag that matches
     the pattern for a release tag.  Returns release version calculated from the
-    tag, or None if there is no matching tag associated with HEAD.  If there are
-    multiple release tags associated with HEAD, the one with the highest version
-    is returned.
+    tag, or None if there is no matching tag associated with HEAD.
     """
 
     found_tag = False
     version_loose = LooseVersion('0.0.0')
 
-    tags = check_output(['git', 'tag', '-l']).split()
-    head_commit = check_output(['git', 'rev-parse', '--revs-only',
-                                           'HEAD^{commit}']).strip()
-    for tag in tags:
-        release_tag_match = RELEASE_TAG_RE.match(tag)
-        tag_commit = check_output(['git', 'rev-parse', '--revs-only',
-                                              tag + '^{commit}']).strip()
-        if tag_commit == head_commit and release_tag_match:
-            new_version_loose = LooseVersion(release_tag_match.group('ver'))
-            if new_version_loose > version_loose:
-                if DEBUG:
-                    print('HEAD release tag: ' + release_tag_match.group('ver'))
-                version_loose = new_version_loose
-                found_tag = True
+    # have git tell us if any tags that look like release tags point at HEAD;
+    # based on our policy, a commit should never have more than one release tag
+    tags = check_output(['git', 'tag', '--points-at', 'HEAD', '--list', '1.*']).split()
+    tag = ''
+    if len(tags) == 1:
+        tag = tags[0]
+    elif len(tags) > 1:
+        raise Exception ('Expected 1 or 0 tags on HEAD, got: {}'.format(tags))
+
+    release_tag_match = RELEASE_TAG_RE.match(tag)
+    if release_tag_match:
+        new_version_loose = LooseVersion(release_tag_match.group('ver'))
+        if new_version_loose > version_loose:
+            if DEBUG:
+                print('HEAD release tag: ' + release_tag_match.group('ver'))
+            version_loose = new_version_loose
+            found_tag = True
 
     if found_tag:
         if DEBUG:
@@ -102,13 +103,15 @@ def check_head_tag():
 
     return None
 
-def get_next_minor (prerelease_marker):
+def get_next_minor(prerelease_marker):
     """
     get_next_minor does the following:
-    Inspect the branches that fit the convention for a release branch.
-    Choose the latest increment the minor version. Append .0 to form the new version (e.g., r1.21 becomes 1.22.0)
-    Append a pre-release marker. (e.g. 1.22.0 becomes 1.22.0-20220201+gitf6e6a7025d)
+        - Inspect the branches that fit the convention for a release branch.
+        - Choose the latest and increment the minor version.
+        - Append .0 to form the new version (e.g., r1.21 becomes 1.22.0)
+        - Append a pre-release marker. (e.g. 1.22.0 becomes 1.22.0-20220201+gitf6e6a7025d)
     """
+
     version_loose = LooseVersion('0.0.0')
 
     version_new = {}
@@ -123,9 +126,9 @@ def get_next_minor (prerelease_marker):
             version_new['patch'] = 0
             version_new['prerelease'] = prerelease_marker
             new_version_loose = LooseVersion(str(version_new['major']) + '.' +
-                                                str(version_new['minor']) + '.' +
-                                                str(version_new['patch']) + '-' +
-                                                version_new['prerelease'])
+                                             str(version_new['minor']) + '.' +
+                                             str(version_new['patch']) + '-' +
+                                             version_new['prerelease'])
             if new_version_loose > version_loose:
                 version_loose = new_version_loose
                 if DEBUG:
@@ -134,6 +137,69 @@ def get_next_minor (prerelease_marker):
                             + release_branch_match.group('brname') + '"')
     return str(version_loose)
 
+def get_branch_tags(active_branch_name):
+    """
+    Returns the tag or tags (as a single string with newlines between tags)
+    corresponding to the current branch, which must not be master.  If the
+    specified branch is a release branch then return all tags based on the
+    major/minor X.Y release version.  If the specified branch is neither master
+    nor a release branch, then walk backwards in history until the first tag
+    matching the glob '1.*' and return that tag.
+    """
+
+    if active_branch_name == 'master':
+        raise Exception('this method is not meant to be called while on "master"')
+    tags = ''
+    release_branch_match = RELEASE_BRANCH_RE.match(active_branch_name)
+    if release_branch_match:
+        # This is a release branch, so look for tags only on this branch
+        tag_glob = release_branch_match.group('vermaj') + '.' \
+                + release_branch_match.group('vermin') + '.*'
+        tags = check_output(['git', 'tag', '--list', tag_glob])
+    else:
+        # Not a release branch, so look for the most recent tag in history
+        commits = check_output(['git', 'log', '--pretty=format:%H',
+                                '--no-merges'])
+        if len(commits) > 0:
+            for commit in commits.splitlines():
+                tags = check_output(['git', 'tag', '--points-at',
+                                     commit, '--list', '1.*'])
+                if len(tags) > 0:
+                    # found a tag, we should be done
+                    break
+
+    return tags
+
+def process_and_sort_tags(tags):
+    """
+    Given a string (as returned from get_branch_tags), return a sorted list of
+    zero or more tags (sorted based on the LooseVersion comparison) which meet
+    the following criteria:
+        - a final release tag (i.e., 1.x.y without any pre-release suffix)
+        - a pre-release tag which is not superseded by a release tag (i.e.,
+          1.x.y-preX iff 1.x.y does not already exist)
+    """
+
+    processed_and_sorted_tags = []
+    if not tags or len(tags) == 0:
+        return processed_and_sorted_tags
+
+    raw_tags = tags.splitlines()
+    # find all the final release tags
+    for tag in raw_tags:
+        release_tag_match = RELEASE_TAG_RE.match(tag)
+        if release_tag_match and not release_tag_match.group('verpre'):
+            processed_and_sorted_tags.append(tag)
+    # collect together final release tags and pre-release tags for
+    # versions that have not yet had a final release
+    for tag in raw_tags:
+        tag_parts = tag.split('-')
+        if len(tag_parts) >= 2 and tag_parts[0] not in processed_and_sorted_tags:
+            processed_and_sorted_tags.append(tag)
+    processed_and_sorted_tags.sort(key=LooseVersion)
+
+    return processed_and_sorted_tags
+
 def main():
     """
     The algorithm is roughly:
@@ -151,53 +217,50 @@ def main():
            patch version, and append a new pre-release marker
     """
 
-
     version_loose = LooseVersion('0.0.0')
-    head_commit_short = check_output(['git', 'rev-parse',
-                                                 '--revs-only', '--short=10',
-                                                 'HEAD^{commit}']).strip()
+    head_commit_short = check_output(['git', 'rev-parse', '--revs-only',
+                                      '--short=10', 'HEAD^{commit}']).strip()
     prerelease_marker = datetime.date.today().strftime('%Y%m%d') \
             + '+git' + head_commit_short
 
     if NEXT_MINOR:
         if DEBUG:
             print('Calculating next minor release')
-        return get_next_minor (prerelease_marker)
+        return get_next_minor(prerelease_marker)
 
     head_tag_ver = check_head_tag()
     if head_tag_ver:
         return head_tag_ver
 
     active_branch_name = check_output(['git', 'rev-parse',
-                                                  '--abbrev-ref', 'HEAD']).strip()
+                                       '--abbrev-ref', 'HEAD']).strip()
     if DEBUG:
         print('Calculating release version for branch: ' + active_branch_name)
     if active_branch_name == 'master':
-        return get_next_minor (prerelease_marker)
+        return get_next_minor(prerelease_marker)
 
-    else:
-        tags = check_output(['git', 'tag',
-                                        '--merged', 'HEAD',
-                                        '--list', '1.*'])
-        if len(tags) > 0:
-            sorted_tags = tags.splitlines()
-            sorted_tags.sort(key=LooseVersion)
-            release_tag_match = RELEASE_TAG_RE.match(sorted_tags[-1])
-            if release_tag_match:
-                version_new = {}
-                version_new['major'] = int(release_tag_match.group('vermaj'))
-                version_new['minor'] = int(release_tag_match.group('vermin'))
-                version_new['patch'] = int(release_tag_match.group('verpatch')) + 1
-                version_new['prerelease'] = prerelease_marker
-                new_version_loose = LooseVersion(str(version_new['major']) + '.' +
-                                                 str(version_new['minor']) + '.' +
-                                                 str(version_new['patch']) + '-' +
-                                                 version_new['prerelease'])
-                if new_version_loose > version_loose:
-                    version_loose = new_version_loose
-                    if DEBUG:
-                        print('Found new best version "' + str(version_loose) \
-                                + '" from tag "' + release_tag_match.group('ver') + '"')
+    branch_tags = get_branch_tags(active_branch_name)
+    tags = process_and_sort_tags(branch_tags)
+
+    tag = tags[-1] if len(tags) > 0 else ''
+    # at this point the RE match is redundant, but convenient for accessing
+    # the components of the version string
+    release_tag_match = RELEASE_TAG_RE.match(tag)
+    if release_tag_match:
+        version_new = {}
+        version_new['major'] = int(release_tag_match.group('vermaj'))
+        version_new['minor'] = int(release_tag_match.group('vermin'))
+        version_new['patch'] = int(release_tag_match.group('verpatch')) + 1
+        version_new['prerelease'] = prerelease_marker
+        new_version_loose = LooseVersion(str(version_new['major']) + '.' +
+                                         str(version_new['minor']) + '.' +
+                                         str(version_new['patch']) + '-' +
+                                         version_new['prerelease'])
+        if new_version_loose > version_loose:
+            version_loose = new_version_loose
+            if DEBUG:
+                print('Found new best version "' + str(version_loose) \
+                        + '" from tag "' + release_tag_match.group('ver') + '"')
 
     return str(version_loose)
 
@@ -210,9 +273,9 @@ def previous(rel_ver):
         print('Calculating previous release version (option -p was specified).')
     version_loose = LooseVersion('0.0.0')
     rel_ver_loose = LooseVersion(rel_ver)
-    tags = check_output(['git', 'tag',
-                                    '--list', '1.*'])
-    for tag in tags.splitlines():
+    tags = check_output(['git', 'tag', '--list', '1.*'])
+    processed_and_sorted_tags = process_and_sort_tags(tags)
+    for tag in processed_and_sorted_tags:
         previous_tag_match = PREVIOUS_TAG_RE.match(tag)
         if previous_tag_match:
             version_new = {}