git-maintain 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9af927752168031d4518212f7ce2114730068296267e7b390db20dde01c3565
-  data.tar.gz: 3e72669ad23fb312fb6d6cadc96ec0b3d9ab1c57db9ee97032a756ac6bffae71
+  metadata.gz: 3f55eb06d04154df930e2e69d85b4d0d3b882361681f2d70a2acc503dc9abfad
+  data.tar.gz: 6d4597f517459cf6304ca419ef7b4897b894c032200f311a1efd549524fc13ba
 SHA512:
-  metadata.gz: 4185735836c059c50a9a76568d678a9a7900fd81a1855c6d3b45edb31245d62e0b877fb1f352e03df94743bef3027c3630be0c9bf57eafb61d82899ed5f58e49
-  data.tar.gz: 966702bfd742eee451afc86ed247e0bca851cbd955b4cbf2cad2a2f7e30dbe815600093d286aef7f78a8e5f311680fa57991b0f15965d97f5881d9b144e66dd8
+  metadata.gz: 9363ed5154f62cef4ac12ee4a1599c108f48bd192dcaea8154cbf4b0db3f80eda06baf8972f39986d8870b6cf5c812ad6877d0fd75c24eb594e4f9e96dc53731
+  data.tar.gz: 97d60ac6e78bec2d3c8c6233e99412f4941c1e9fed9f69f1ce9acc923e9f3060279c9a82d7dd6f50a66b6c50c6799c0d686e86aeaec984b8fe704e018497f3d9

data/CHANGELOG

@@ -1,3 +1,13 @@
+------------------
+0.12.0  (2025-09-11)
+------------------
+
+* Cleanup code for Addons releases
+* Replace all egrep calls with grep -E
+* Replace $? handling with Exceptions
+* Various minor fixes
+* Drop obsolete Travis CI code
+
 ------------------
 0.11.0  (2025-04-15)
 ------------------

data/git-maintain-completion.sh

@@ -1,13 +1,13 @@
 export _GIT_MAINTAIN_CMD_AWK=$(([ -f /bin/awk ] && echo "/bin/awk") || echo "/usr/bin/awk")
 export _GIT_MAINTAIN_CMD_SORT=$(([ -f /bin/sort ] && echo "/bin/sort") || echo "/usr/bin/sort")
-export _GIT_MAINTAIN_CMD_EGREP=$(([ -f /bin/egrep ] && echo "/bin/egrep") || echo "/usr/bin/egrep")
+export _GIT_MAINTAIN_CMD_GREP=$(([ -f /bin/grep ] && echo "/bin/grep") || echo "/usr/bin/grep")
 export _GIT_MAINTAIN_CMD_SED=$(([ -f /bin/sed ] && echo "/bin/sed") || echo "/usr/bin/sed")
 
 _git_maintain_genoptlist(){
 	local COMMAND=$*
 	${COMMAND}  --help 2>&1 | \
 		${_GIT_MAINTAIN_CMD_AWK} 'BEGIN { found = 0 } { if(found == 1) print $$0; if($$1 == "Options:") {found = 1}}' | \
-		${_GIT_MAINTAIN_CMD_EGREP} -e "^[[:space:]]*--" -e "^[[:space:]]*-[a-zA-Z0-9]" | \
+		${_GIT_MAINTAIN_CMD_GREP} -E -e "^[[:space:]]*--" -e "^[[:space:]]*-[a-zA-Z0-9]" | \
 		${_GIT_MAINTAIN_CMD_SED} -e 's/^[[:space:]]*//' -e 's/^-[^-], //' | \
 		${_GIT_MAINTAIN_CMD_AWK} '{ print $1}' | \
 		${_GIT_MAINTAIN_CMD_SED} -e 's/^\(.*\)\[no-\]\(.*$\)/\1\2\n\1no-\2/' | \

data/lib/addons/RDMACore.rb

@@ -32,7 +32,7 @@ module GitMaintain
             end
         end
         def release(opts)
-            prev_ver=@repo.runGit("show HEAD:CMakeLists.txt  | egrep \"[sS][eE][tT]\\\\(PACKAGE_VERSION\"").
+            prev_ver=@repo.runGit("show HEAD:CMakeLists.txt  | grep -E \"[sS][eE][tT]\\\\(PACKAGE_VERSION\"").
                          chomp().gsub(/[sS][eE][tT]\(PACKAGE_VERSION\s*"([0-9.]*)".*$/, '\1')
             ver_nums = prev_ver.split(".")
             new_ver =  (ver_nums[0 .. -2] + [ver_nums[-1].to_i() + 1 ]).join(".")
@@ -49,8 +49,9 @@ module GitMaintain
 
             git_prev_ver = "v" + prev_ver
             # Older tags might do have the terminal minor version (.0) for major releases
-            @repo.runGit("rev-parse --verify --quiet #{git_prev_ver}")
-            if $? != 0 then
+            begin
+                @repo.ref_exist?(git_prev_ver)
+            rescue NoRefError
                 # Try without the minor version number
                 git_prev_ver = "v" + ver_nums[0 .. -2].join(".")
             end
@@ -80,10 +81,7 @@ module GitMaintain
 
             if opts[:rel_type] == :major
                 # For major, tag the current version first
-                @repo.runGitInteractive("tag -a -s v#{rel_ver} #{edit_flag} -F #{tag_path}")
-                if $? != 0 then
-                    raise("Failed to tag branch #{local_branch}")
-                end
+                release_do_tag(opts, "v" + rel_ver, tag_path)
             end
 
             # Update version number in relevant files
@@ -107,23 +105,21 @@ mv debian/changelog.new debian/changelog")
             end
 
             # Add and commit
-            @repo.runGit("add  */*.spec CMakeLists.txt debian/changelog")
-            @repo.runGitInteractive("commit -m '#{commit_msg} #{new_ver}' --verbose #{edit_flag} --signoff")
-            if $? != 0 then
-                raise("Failed to commit on branch #{local_branch}")
-            end
+            release_do_add_commit(opts, [ "*/*.spec", "CMakeLists.txt", "debian/changelog" ],
+                                  new_ver, nil, "#{commit_msg} #{new_ver}")
 
             if opts[:rel_type] == :stable
-                @repo.runGitInteractive("tag -a -s v#{rel_ver} #{edit_flag} -F #{tag_path}")
-                if $? != 0 then
-                    raise("Failed to tag branch #{local_branch}")
-                end
+                release_do_tag(opts, rel_ver, tag_path)
             end
             `rm -f #{tag_path}`
+            return 0
         end
         def validate(opts)
-            @repo.runSystem("rm -Rf build/ && mkdir build/ && cd build/ && cmake .. && make -j")
-            raise("Validation failure") if $? != 0
+            begin
+                @repo.runSystem("rm -Rf build/ && mkdir build/ && cd build/ && cmake .. && make -j")
+            rescue RuntimeError
+                raise("Validation failure")
+            end
         end
     end
     class RDMACoreRepo < Repo
@@ -181,8 +177,11 @@ mv debian/changelog.new debian/changelog")
             cmdList << "./buildlib/cbuild pkg azp"
 
             toDo=cmdList.join("&&")
-            runSystem(toDo)
-            raise("Fail to run stable creation code") if $? != 0
+            begin
+                runSystem(toDo)
+            rescue RuntimeError
+                raise("Fail to run stable creation code")
+            end
         end
     end
 

data/lib/addons/git-maintain.rb

@@ -69,17 +69,9 @@ $(cat CHANGELOG)
 EOF
 mv CHANGELOG.new CHANGELOG")
 
-            # Add and commit
-            @repo.runGit("add  CHANGELOG")
-            @repo.runGitInteractive("commit -F #{tag_path} --verbose --edit --signoff")
-            if $? != 0 then
-                raise("Failed to commit on branch #{local_branch}")
-            end
-            @repo.runGitInteractive("tag -a -s v#{new_ver} --edit -F #{tag_path}")
-            if $? != 0 then
-                raise("Failed to tag branch #{local_branch}")
-            end
+            release_do_add_commit_tag(opts, ["CHANGELOG"], "v" + new_ver, tag_path)
             `rm -f #{tag_path}`
+            return 0
         end
     end
     class GitMaintainRepo < Repo

data/lib/branch.rb

@@ -83,8 +83,8 @@ module GitMaintain
                 optsParser.on("--remote", "Delete the remote staging branch instead of the local ones.") {
                     |val| opts[:delete_remote] = true}
             when :list
-                 optsParser.on("--stable", "List unreleased commits in the upstream stable branch.") {
-                     opts[:stable] = true }
+                optsParser.on("--stable", "List unreleased commits in the upstream stable branch.") {
+                    opts[:stable] = true }
             when :merge
                 optsParser.banner += "-m <suffix>"
                 optsParser.on("-m", "--merge [SUFFIX]", "Merge branch with suffix.") {
@@ -93,17 +93,17 @@ module GitMaintain
                 optsParser.on("-w", "--watch <PERIOD>", Integer,
                               "Watch and refresh CI status every <PERIOD>.") {
                     |val| opts[:watch] = val}
-                 optsParser.on("--stable", "Check CI status on stable repo.") {
-                     opts[:stable] = true }
+                optsParser.on("--stable", "Check CI status on stable repo.") {
+                    opts[:stable] = true }
             when :pull
-                 optsParser.on("--stable", "List unreleased commits in the upstream stable branch.") {
-                     opts[:stable] = true }
+                optsParser.on("--stable", "List unreleased commits in the upstream stable branch.") {
+                    opts[:stable] = true }
             when :push
                 optsParser.banner += "[-f]"
                 optsParser.on("-f", "--force", "Add --force to git push (for 'push' action).") {
                     opts[:push_force] = true}
                 optsParser.on("--stable", "Push to stable repo.") {
-                     opts[:stable] = true }
+                    opts[:stable] = true }
                 optsParser.banner += "[-T]"
                 optsParser.on("-T", "--no-ci", "Ignore CI build status and push anyway.") {
                     opts[:no_ci] = true}
@@ -115,16 +115,16 @@ module GitMaintain
             when :steal
                 optsParser.banner += "[-a][-b <HEAD>]"
                 optsParser.on("-a", "--all", "Check all commits from master. "+
-                                               "By default only new commits (since last successful run) are considered.") {
+                                             "By default only new commits (since last successful run) are considered.") {
                     |val| opts[:steal_base] = :all}
                 optsParser.on("-b", "--base <HEAD>", "Check all commits from this commit. "+
-                                               "By default only new commits (since last successful run) are considered.") {
+                                                     "By default only new commits (since last successful run) are considered.") {
                     |val| opts[:steal_base] = val}
             end
         end
 
         def self.check_opts(opts)
-               if opts[:action] == :release then
+            if opts[:action] == :release then
                 if opts[:br_suff] != "master" then
                     raise "Action #{opts[:action]} can only be done on 'master' suffixed branches"
                 end
@@ -203,6 +203,8 @@ module GitMaintain
                 sleep(opts[:watch])
                 ci.emptyCache()
             end
+            GitMaintain::log(:INFO, "Done working on selected branches")
+
         end
 
         def initialize(repo, version, ci, branch_suff)
@@ -224,10 +226,15 @@ module GitMaintain
                 @verbose_name = version
             end
 
-            @head          = @repo.runGit("rev-parse --verify --quiet #{@local_branch}")
+            @head          = @repo.ref_exist?(@local_branch)
             @valid_ref     = "#{@repo.valid_repo}/#{@local_branch}"
             @remote_ref    = "#{@repo.stable_repo}/#{@remote_branch}"
-            @stable_head   = @repo.runGit("rev-parse --verify --quiet #{@remote_ref}")
+            @stable_head   = 
+                begin
+                    @repo.ref_exist?(@remote_ref)
+                rescue
+                    nil
+                end
             case @branch_type
             when :std
                 @stable_base   = @repo.findStableBase(@local_branch)
@@ -255,9 +262,10 @@ module GitMaintain
 
         # Checkout the repo to the given branch
         def checkout()
-            print @repo.runGit("checkout -q #{@local_branch}")
-            if $? != 0 then
-                raise "Error: Failed to checkout the branch"
+            begin
+                print @repo.runGit("checkout -q #{@local_branch}")
+            rescue RuntimeError => e
+                crit("Failed to checkout the branch #{@local_branch}")
             end
         end
 
@@ -266,15 +274,16 @@ module GitMaintain
             opts[:commits].each(){|commit|
                 prev_head=@repo.runGit("rev-parse HEAD")
                 log(:INFO, "Applying #{@repo.getCommitHeadline(commit)}")
-                @repo.runGitInteractive("cherry-pick #{commit}")
-                if $? != 0 then
+                begin
+                    @repo.runGitInteractive("cherry-pick #{commit}")
+                rescue RuntimeError
                     log(:WARNING, "Cherry pick failure. Starting bash for manual fixes. Exit shell to continue")
-			        @repo.runBash("PS1_WARNING='CP FIX'")
-		        end
+		    @repo.runBash("PS1_WARNING='CP FIX'")
+		end
                 new_head=@repo.runGit("rev-parse HEAD")
                 # Do not make commit pretty if it was not applied
                 if new_head != prev_head
-		            make_pretty(commit)
+		    make_pretty(commit)
                 end
             }
         end
@@ -286,22 +295,26 @@ module GitMaintain
             # If we are not force checking everything,
             # try to start from the last tag we steal upto
             case opts[:steal_base]
-                when nil
+            when nil
+                begin
                     sha = @repo.runGit("rev-parse 'git-maintain/steal/last/#{@stable_base}' 2>&1")
-                    if $? == 0 then
-                        base_ref=sha
-                        log(:VERBOSE, "Starting from last successfull run:")
-                        log(:VERBOSE, @repo.getCommitHeadline(base_ref))
-                    end
-                when :all
-                    base_ref=@stable_base
-                else
+                    base_ref=sha
+                    log(:VERBOSE, "Starting from last successfull run:")
+                    log(:VERBOSE, @repo.getCommitHeadline(base_ref))
+                rescue RuntimeError
+                    # No matching tag found. Not an issue
+                end
+            when :all
+                base_ref=@stable_base
+            else
+                begin
                     sha = @repo.runGit("rev-parse #{opts[:steal_base]} 2>&1")
-                    if $? == 0 then
-                        base_ref=sha
-                        log(:VERBOSE, "Starting from base:")
-                        log(:VERBOSE, @repo.getCommitHeadline(base_ref))
-                    end
+                    base_ref=sha
+                    log(:VERBOSE, "Starting from base:")
+                    log(:VERBOSE, @repo.getCommitHeadline(base_ref))
+                rescue RuntimeError
+                    crit("Could not find specified base '#{opts[:steal_base]}'")
+                end
             end
 
             master_sha=@repo.runGit("rev-parse origin/master")
@@ -333,8 +346,9 @@ module GitMaintain
             merge_branch = @repo.versionToLocalBranch(@version, opts[:do_merge])
 
             # Make sure branch exists
-            hash_to_merge = @repo.runGit("rev-parse --verify --quiet #{merge_branch}")
-            if $? != 0 then
+            begin
+                hash_to_merge = @repo.ref_exist?(merge_branch)
+            rescue NoRefError
                 log(:INFO, "Branch #{merge_branch} does not exists. Skipping...")
                 return
             end
@@ -348,11 +362,12 @@ module GitMaintain
 
             rep = GitMaintain::checkLog(opts, merge_branch, @local_branch, "merge")
             if rep == "y" then
-                @repo.runGitInteractive("merge #{merge_branch}")
-                if $? != 0 then
+                begin
+                    @repo.runGitInteractive("merge #{merge_branch}")
+                rescue RuntimeError
                     log(:WARNING, "Merge failure. Starting bash for manual fixes. Exit shell to continue")
-			        @repo.runBash("PS1_WARNING='MERGING'")
-		        end
+		    @repo.runBash("PS1_WARNING='MERGING'")
+		end
             else
                 log(:INFO, "Skipping merge")
                 return
@@ -363,8 +378,9 @@ module GitMaintain
             remoteRef = opts[:stable] == true ? @remote_ref : @valid_ref
 
             # Make sure branch exists
-            @repo.runGit("rev-parse --verify --quiet #{remoteRef}")
-            if $? != 0 then
+            begin
+                @repo.ref_exist?(remoteRef)
+            rescue NoRefError
                 log(:INFO, "Branch #{remoteRef} does not exists. Skipping...")
                 return
             end
@@ -485,8 +501,9 @@ module GitMaintain
 
         def delete(opts)
             if opts[:delete_remote] == true then
-                @repo.runGit("rev-parse --verify --quiet #{@repo.valid_repo}/#{@local_branch}")
-                if $? != 0 then
+                begin
+                    @repo.ref_exist?("#{@repo.valid_repo}/#{@local_branch}")
+                rescue NoRefError
                     log(:DEBUG, "Skipping non existing remote branch #{@local_branch}.")
                     return
                 end
@@ -522,13 +539,16 @@ module GitMaintain
 
         private
         def add_blacklist(commit)
-  	        @repo.runGit("notes append -m \"#{@local_branch}\" #{commit}")
+  	    @repo.runGit("notes append -m \"#{@local_branch}\" #{commit}")
         end
 
         def is_blacklisted?(commit)
-            @repo.runGit("notes show #{commit} 2> /dev/null").split("\n").each(){|br|
-                return true if br == @local_branch
-            }
+            begin
+                @repo.runGit("notes show #{commit} 2> /dev/null").split("\n").each(){|br|
+                    return true if br == @local_branch
+                }
+            rescue
+            end
             return false
         end
 
@@ -538,113 +558,115 @@ module GitMaintain
 
             msg_path=`mktemp`.chomp()
             msg_file = File.open(msg_path, "w+")
-	        msg_file.puts @repo.runGit("log -1 --format=\"%s%n%n[ Upstream commit #{msg_commit} ]%n%n%b\" #{orig_commit}")
+	    msg_file.puts @repo.runGit("log -1 --format=\"%s%n%n[ Upstream commit #{msg_commit} ]%n%n%b\" #{orig_commit}")
             msg_file.close()
-	        @repo.runGit("commit -s --amend -F #{msg_path}")
+	    @repo.runGit("commit -s --amend -F #{msg_path}")
             `rm -f #{msg_path}`
         end
 
         def is_in_tree?(commit, src_commit=commit)
-	        fullhash=@repo.runGit("rev-parse --verify --quiet #{commit}")
+            fullhash=nil
+            begin
+	        fullhash=@repo.ref_exist?(commit)
+            rescue NoRefError
 	        # This might happen if someone pointed to a commit that doesn't exist in our
 	        # tree.
-	        if $? != 0 then
                 log(:WARNING, "Commit #{src_commit} points to a SHA #{commit} not in tree")
-		        return false
-	        end
-
-	        # Hope for the best, same commit is/isn't in the current branch
-	        if @repo.runGit("merge-base #{fullhash} HEAD") == fullhash then
-		        return true
-	        end
-
-	        # Grab the subject, since commit sha1 is different between branches we
-	        # have to look it up based on subject.
-	        subj=@repo.getCommitSubj(commit)
-	        if $? != 0 then
-		        return false
-	        end
-
-	        # Try and find if there's a commit with given subject the hard way
-	        @repo.runGit("log --pretty=\"%H\" -F --grep \"#{subj.gsub("\"", '\\"')}\" "+
+		return false
+	    end
+
+	    # Hope for the best, same commit is/isn't in the current branch
+	    if @repo.runGit("merge-base #{fullhash} HEAD") == fullhash then
+		return true
+	    end
+
+	    # Grab the subject, since commit sha1 is different between branches we
+	    # have to look it up based on subject.
+	    subj=@repo.getCommitSubj(commit)
+
+	    # Try and find if there's a commit with given subject the hard way
+	    @repo.runGit("log --pretty=\"%H\" -F --grep \"#{subj.gsub("\"", '\\"')}\" "+
                          "#{@stable_base}..HEAD").split("\n").each(){|cmt|
                 cursubj=@repo.runGit("log -1 --format=\"%s\" #{cmt}")
                 if cursubj = subj then
-	                return true
-		        end
-	        }
-	        return false
+	            return true
+		end
+	    }
+	    return false
         end
 
         def is_relevant?(commit)
-	        # Let's grab the commit that this commit fixes (if exists (based on the "Fixes:" tag)).
-	        fixescmt=@repo.runGit("log -1 #{commit} | grep -i \"fixes:\" | head -n 1 | "+
+	    # Let's grab the commit that this commit fixes (if exists (based on the "Fixes:" tag)).
+	    fixescmt=@repo.runGit("log -1 #{commit} | grep -i \"fixes:\" | head -n 1 | "+
                                   "sed -e 's/^[ \\t]*//' | cut -f 2 -d ':' | "+
                                   "sed -e 's/^[ \\t]*//' -e 's/\\([0-9a-f]\\+\\)(/\\1 (/' | cut -f 1 -d ' '")
 
-	        # If this commit fixes anything, but the broken commit isn't in our branch we don't
-	        # need this commit either.
-	        if fixescmt != "" then
-		          if is_in_tree?(fixescmt, commit) then
-                      return true
-                  else
-                      return false
-                  end
+	    # If this commit fixes anything, but the broken commit isn't in our branch we don't
+	    # need this commit either.
+	    if fixescmt != "" then
+		if is_in_tree?(fixescmt, commit) then
+                    return true
+                else
+                    return false
+                end
             end
 
-	        if @repo.runGit("show #{commit} | grep -i 'stable@' | wc -l") == "0" then
-		        return false
-	        end
+	    if @repo.runGit("show #{commit} | grep -i 'stable@' | wc -l") == "0" then
+		return false
+	    end
 
-	        # Let's see if there's a version tag in this commit
-	        full=@repo.runGit("show #{commit} | grep -i 'stable@'").gsub(/.* #?/, "")
+	    # Let's see if there's a version tag in this commit
+	    full=@repo.runGit("show #{commit} | grep -i 'stable@'").gsub(/.* #?/, "")
 
-	        # Sanity check our extraction
+	    # Sanity check our extraction
             if full =~ /stable/ then
                 return false
             end
 
             full = @repo.runGit("rev-parse #{full}^{commit}")
 
-	        # Make sure our branch contains this version
-	        if @repo.runGit("merge-base #{@head} #{full}") == full then
-		        return true
-	        end
+	    # Make sure our branch contains this version
+	    if @repo.runGit("merge-base #{@head} #{full}") == full then
+		return true
+	    end
 
-	        # Tag is not in history, ignore
-	        return false
+	    # Tag is not in history, ignore
+	    return false
         end
 
         def pick_one(commit)
-            @repo.runGitInteractive("cherry-pick --strategy=recursive -Xpatience -x #{commit} &> /dev/null")
-	        return if  $? == 0
+            cpCmd="cherry-pick --strategy=recursive -Xpatience -x"
+            @repo.runGitInteractive("#{cpCmd} #{commit} &> /dev/null", :check_err => false)
+	    return if $? == 0
+
             if @repo.runGit("status -uno --porcelain | wc -l") == "0" then
-			    @repo.runGit("reset --hard")
+		@repo.runGit("reset --hard")
                 raise CherryPickErrorException.new("Failed to cherry pick commit #{commit}", commit)
-		    end
-		    @repo.runGit("reset --hard")
-		    # That didn't work? Let's try that with every variation of the commit
-		    # in other stable trees.
+	    end
+	    @repo.runGit("reset --hard")
+
+	    # That didn't work? Let's try that with every variation of the commit
+	    # in other stable trees.
             @repo.find_alts(commit).each(){|alt_commit|
-			    @repo.runGitInteractive("cherry-pick --strategy=recursive -Xpatience -x #{alt_commit} &> /dev/null")
-			    if $? == 0 then
-				    return
-			    end
-			    @repo.runGit("reset --hard")
+		@repo.runGitInteractive("#{cpCmd} #{alt_commit} &> /dev/null", :check_err => false)
+		if $? == 0 then
+		    return
+		end
+		@repo.runGit("reset --hard")
             }
-		    # Still no? Let's go back to the original commit and hand it off to
-		    # the user.
-		    @repo.runGitInteractive("cherry-pick --strategy=recursive -Xpatience -x #{commit} &> /dev/null")
+
+	    # Still no? Let's go back to the original commit and hand it off to
+	    # the user.
+	    @repo.runGitInteractive("#{cpCmd} #{commit} &> /dev/null", :check_err => false)
             raise CherryPickErrorException.new("Failed to cherry pick commit #{commit}", commit)
-	        return false
         end
 
         def confirm_one(opts, commit)
- 		    rep=""
-		    do_cp=false
-		    puts @repo.getCommitHeadline(commit)
-		    while rep != "y" do
-			    puts "Do you want to steal this commit ? (y/n/b/?)"
+ 	    rep=""
+	    do_cp=false
+	    puts @repo.getCommitHeadline(commit)
+	    while rep != "y" do
+		puts "Do you want to steal this commit ? (y/n/b/?)"
                 case opts[:yn_default]
                 when :no
                     log(:INFO, "Auto-replying no due to --no option")
@@ -657,38 +679,38 @@ module GitMaintain
                     rep = STDIN.gets.chomp()
                 end
 
-			    case rep
-				when "n"
-			        log(:INFO, "Skip this commit")
-					break
-				when "b"
-					log(:INFO, "Blacklisting this commit for the current branch")
-					add_blacklist(commit)
-					break
-				when "y"
-					rep="y"
-					do_cp=true
-					break
-				when "?"
-					puts @repo.runGit("show #{commit}")
+		case rep
+		when "n"
+		    log(:INFO, "Skip this commit")
+		    break
+		when "b"
+		    log(:INFO, "Blacklisting this commit for the current branch")
+		    add_blacklist(commit)
+		    break
+		when "y"
+		    rep="y"
+		    do_cp=true
+		    break
+		when "?"
+		    puts @repo.runGit("show #{commit}")
                 else
-					log(:ERROR, "Invalid answer $rep")
-		            puts @repo.runGit("show --format=oneline --no-patch --no-decorate #{commit}")
+		    log(:ERROR, "Invalid answer $rep")
+		    puts @repo.runGit("show --format=oneline --no-patch --no-decorate #{commit}")
                 end
-		    end
+	    end
             return do_cp
         end
 
         def steal_one(opts, commit, mainline=false)
-		    msg=''
+	    msg=''
             orig_cmt=commit
 
             if mainline == false then
-		        subj=@repo.getCommitSubj(commit)
+		subj=@repo.getCommitSubj(commit)
                 subj.gsub!(/"/, '\"')
-		        # Let's grab the mainline commit id, this is useful if the version tag
-		        # doesn't exist in the commit we're looking at but exists upstream.
-		        orig_cmt=@repo.runGit("log --no-merges --format=\"%H\" -F --grep \"#{subj}\" " +
+		# Let's grab the mainline commit id, this is useful if the version tag
+		# doesn't exist in the commit we're looking at but exists upstream.
+		orig_cmt=@repo.runGit("log --no-merges --format=\"%H\" -F --grep \"#{subj}\" " +
                                       "#{@stable_base}..origin/master | tail -n1")
 
                 if orig_cmt == "" then
@@ -696,24 +718,24 @@ module GitMaintain
                 end
             end
             # If the commit doesn't apply for us, skip it
-		    if is_relevant?(orig_cmt) != true
+	    if is_relevant?(orig_cmt) != true
                 return true
-		    end
+	    end
 
             log(:VERBOSE, "Found relevant commit #{@repo.getCommitHeadline(commit)}")
-		    if is_in_tree?(orig_cmt) == true
-		        # Commit is already in the stable branch, skip
+	    if is_in_tree?(orig_cmt) == true
+		# Commit is already in the stable branch, skip
                 log(:VERBOSE, "Commit is already in tree")
                 return true
-		    end
+	    end
 
-		    # Check if it's not blacklisted by a git-notes
-		    if is_blacklisted?(orig_cmt) == true then
-		        # Commit is blacklisted
-			    log(:INFO, "Skipping 'blacklisted' commit " +
-                     @repo.getCommitHeadline(orig_cmt))
+	    # Check if it's not blacklisted by a git-notes
+	    if is_blacklisted?(orig_cmt) == true then
+		# Commit is blacklisted
+		log(:INFO, "Skipping 'blacklisted' commit " +
+                           @repo.getCommitHeadline(orig_cmt))
                 return true
-		    end
+	    end
 
             do_cp = confirm_one(opts, orig_cmt)
             return false if do_cp != true
@@ -721,39 +743,83 @@ module GitMaintain
             prev_head=@repo.runGit("rev-parse HEAD")
 
             begin
-		        pick_one(commit)
+		pick_one(commit)
             rescue CherryPickErrorException => e
-			    log(:WARNING, "Cherry pick failed. Fix, commit (or reset) and exit.")
-			    @repo.runBash("PS1_WARNING='CP FIX'")
+		log(:WARNING, "Cherry pick failed. Fix, commit (or reset) and exit.")
+		@repo.runBash("PS1_WARNING='CP FIX'")
             end
             new_head=@repo.runGit("rev-parse HEAD")
 
-		    # If we didn't find the commit upstream then this must be a custom commit
-		    # in the given tree - make sure the user checks this commit.
-		    if orig_cmt == "" then
-			    msg="Custom"
-			    orig_cmt=@repo.runGit("rev-parse HEAD")
-			    log(:WARNING, "Custom commit, please double-check!")
-			    @repo.runBash("PS1_WARNING='CHECK'")
-		    end
+	    # If we didn't find the commit upstream then this must be a custom commit
+	    # in the given tree - make sure the user checks this commit.
+	    if orig_cmt == "" then
+		msg="Custom"
+		orig_cmt=@repo.runGit("rev-parse HEAD")
+		log(:WARNING, "Custom commit, please double-check!")
+		@repo.runBash("PS1_WARNING='CHECK'")
+	    end
             if new_head != prev_head
-		        make_pretty(orig_cmt, msg)
+		make_pretty(orig_cmt, msg)
             end
         end
 
         def steal_all(opts, range, mainline = false)
             res = true
- 	        @repo.runGit("log --no-merges --format=\"%H\" #{range} | tac").split("\n").each(){|commit|
+ 	    @repo.runGit("log --no-merges --format=\"%H\" #{range} | tac").split("\n").each(){|commit|
                 res &= steal_one(opts, commit, mainline)
             }
             return res
-       end
+        end
 
         def same_sha?(ref1, ref2)
-            c1=@repo.runGit("rev-parse --verify --quiet #{ref1}")
-            c2=@repo.runGit("rev-parse --verify --quiet #{ref2}")
-            return c1 == c2
+            begin
+                c1=@repo.ref_exist?(ref1)
+                c2=@repo.ref_exist?(ref2)
+                return c1 == c2
+            rescue
+                return false
+            end
+        end
+
+
+        def release_do_add_commit(opts, filelist, commit_path, commit_msg=nil)
+            edit_flag = ""
+            edit_flag = "--edit" if opts[:no_edit] == false
 
+            raise("No commit message provided") if commit_path == nil && commit_msg == nil
+            commit_flag=""
+            if commit_msg != nil
+                commit_flag = "-m '#{commit_msg}'"
+            else
+                commit_flag = "-F '#{commit_path}'"
+            end
+
+            # Add and commit
+            begin
+                @repo.runGit("add  " + filelist.join(" "))
+                @repo.runGitInteractive("commit #{commit_flag} --verbose #{edit_flag} --signoff")
+            rescue RuntimeError
+                raise("Failed to commit on branch #{@local_branch}")
+            end
+            return 0
+        end
+
+        def release_do_tag(opts, version, tag_path)
+            edit_flag = ""
+            edit_flag = "--edit" if opts[:no_edit] == false
+            begin
+                @repo.runGitInteractive("tag -a -s #{version} #{edit_flag} -F #{tag_path}")
+            rescue RuntimeError
+                raise("Failed to tag branch #{@local_branch}")
+            end
+            return 0
         end
+
+        def release_do_add_commit_tag(opts, filelist, version, message_path)
+            release_do_add_commit(opts, filelist, message_path)
+            release_do_tag(opts, version, message_path)
+           return 0
+        end
+
     end
 end

data/lib/common.rb

@@ -223,6 +223,12 @@ module GitMaintain
     end
     module_function :log
 
+    def crit(msg)
+        log(:ERROR, msg)
+        raise msg
+    end
+    module_function :crit
+
     def setVerbose(val)
         @@verbose_log = val
     end
@@ -241,7 +247,7 @@ $LOAD_PATH.pop()
 
 if ENV["GIT_MAINTAIN_ADDON_DIR"].to_s() != "" then
     ADDON_DIR=ENV["GIT_MAINTAIN_ADDON_DIR"].to_s()
-    if Dir.exists?(ADDON_DIR) then
+    if Dir.exist?(ADDON_DIR) then
         $LOAD_PATH.push(ADDON_DIR)
         Dir.entries(ADDON_DIR).each(){|entry|
             next if (!File.file?(ADDON_DIR + "/" + entry) || entry !~ /\.rb$/ );

data/lib/repo.rb

@@ -2,6 +2,11 @@ require 'octokit'
 require 'io/console'
 
 module GitMaintain
+    class NoRefError < RuntimeError
+        def initialize(ref)
+            super("Reference '#{ref}' was not found")
+        end
+    end
     class Repo
         @@VALID_REPO = "github"
         @@STABLE_REPO = "stable"
@@ -19,7 +24,7 @@ module GitMaintain
         }
 
         def self.load(path=".")
-            dir = Dir.pwd()
+            dir = File.realdirpath(path)
             repo_name = File.basename(dir)
             return GitMaintain::loadClass(Repo, repo_name, dir)
         end
@@ -60,9 +65,9 @@ module GitMaintain
             @stable_repo = getGitConfig("maintain.stable-repo")
             @stable_repo = @@STABLE_REPO if @stable_repo == ""
 
-            @remote_valid=runGit("remote -v | egrep '^#{@valid_repo}' | grep fetch |
+            @remote_valid=runGit("remote -v | grep -E '^#{@valid_repo}' | grep fetch |
                                 awk '{ print $2}' | sed -e 's/.*://' -e 's/\\.git//'")
-            @remote_stable=runGit("remote -v | egrep '^#{@stable_repo}' | grep fetch |
+            @remote_stable=runGit("remote -v | grep -E '^#{@stable_repo}' | grep fetch |
                                       awk '{ print $2}' | sed -e 's/.*://' -e 's/\\.git//'")
 
             @auto_fetch = getGitConfig("maintain.autofetch")
@@ -83,7 +88,7 @@ module GitMaintain
             @stable_base_format = getGitConfig("maintain.stable-base-format")
 
             @stable_base_patterns=
-                runGit("config --get-regexp   stable-base | egrep '^stable-base\.' | "+
+                runGit("config --get-regexp   stable-base | grep -E '^stable-base\.' | "+
                        "sed -e 's/stable-base\.//' -e 's/---/\\//g'").split("\n").inject({}){ |m, x|
                 y=x.split(" ");
                 m[y[0]] = y[1]
@@ -110,22 +115,41 @@ module GitMaintain
             GitMaintain::log(lvl, str)
         end
 
-        def run(cmd)
-            return `cd #{@path} && #{cmd}`
+        def _run_check_ret(ret, opts)
+            raise(RuntimeError.new(ret)) if $?.exitstatus != 0 && opts.fetch(:check_err, true) == true
         end
-        def runSystem(cmd)
-            return system("cd #{@path} && #{cmd}")
+        def run(cmd, opts = {})
+            ret = `cd #{@path} && #{cmd}`
+            _run_check_ret(ret, opts)
+            return ret
         end
+        def runSystem(cmd, opts = {})
+            ret = system("cd #{@path} && #{cmd}")
+            _run_check_ret(nil, opts)
+            return ret
 
-        def runGit(cmd)
+        end
+        def runGit(cmd, opts = {})
             log(:DEBUG, "Called from #{caller[1]}")
             log(:DEBUG, "Running git command '#{cmd}'")
-            return `git --work-tree=#{@path} #{cmd}`.chomp()
+            ret = `git --work-tree=#{@path} #{cmd}`.chomp()
+            _run_check_ret(ret, opts)
+            return ret
         end
-        def runGitInteractive(cmd)
+        def runGitInteractive(cmd, opts = {})
             log(:DEBUG, "Called from #{caller[1]}")
             log(:DEBUG, "Running interactive git command '#{cmd}'")
-            return system("git --work-tree=#{@path} #{cmd}")
+            ret = system("git --work-tree=#{@path} #{cmd}")
+            _run_check_ret(nil, opts)
+            return ret
+
+        end
+        def ref_exist?(ref)
+            begin
+                return runGit("rev-parse --verify --quiet '#{ref}'")
+            rescue RuntimeError
+                raise(NoRefError.new(ref))
+            end
         end
 
         def runGitImap(cmd)
@@ -138,17 +162,18 @@ module GitMaintain
                   fi; git --work-tree=#{@path} imap-send #{cmd}`
         end
         def getGitConfig(entry)
-            return @config_cache[entry] ||= runGit("config #{entry} 2> /dev/null").chomp()
+            return @config_cache[entry] ||= runGit("config #{entry} 2> /dev/null", :check_err => false).chomp()
         end
 
         def runBash(env="")
-            runSystem(env + " bash")
-            if $? == 0 then
-                log(:INFO, "Continuing...")
-            else
+            begin
+                runSystem(env + " bash")
+            rescue RuntimeError
                 log(:ERROR, "Shell exited with code #{$?}. Exiting")
                 raise("Cancelled by user")
             end
+            log(:INFO, "Continuing...")
+
         end
 
         def getCommitHeadline(sha)
@@ -200,10 +225,10 @@ module GitMaintain
 
         def getUnreleasedTags(opts)
             remote_tags=runGit("ls-remote --tags #{@stable_repo} |
-                                 egrep 'refs/tags/v[0-9.]*$'").split("\n").map(){
+                                 grep -E 'refs/tags/v[0-9.]*$'").split("\n").map(){
                 |x| x.gsub(/.*refs\/tags\//, '')
             }
-            local_tags =runGit("tag -l | egrep '^v[0-9.]*$'").split("\n")
+            local_tags =runGit("tag -l | grep -E '^v[0-9.]*$'").split("\n")
 
             new_tags = local_tags - remote_tags
             return new_tags
@@ -264,22 +289,22 @@ module GitMaintain
 
         def createRelease(opts, tag, github_rel=true)
             log(:INFO, "Creating a release for #{tag}")
-		    runGit("push #{@stable_repo} refs/tags/#{tag}")
+	    runGit("push #{@stable_repo} refs/tags/#{tag}")
 
             if github_rel == true then
- 		        msg = runGit("tag -l -n1000 '#{tag}'") + "\n"
+ 		msg = runGit("tag -l -n1000 '#{tag}'") + "\n"
 
-		        # Ye ghods is is a horrific format to parse
-		        name, body = msg.split("\n", 2)
-		        name = name.gsub(/^#{tag}/, '').strip
-		        body = body.split("\n").map { |l| l.sub(/^    /, '') }.join("\n")
-		        api.create_release(@remote_stable, tag, :name => name, :body => body)
+		# Ye ghods is is a horrific format to parse
+		name, body = msg.split("\n", 2)
+		name = name.gsub(/^#{tag}/, '').strip
+		body = body.split("\n").map { |l| l.sub(/^    /, '') }.join("\n")
+		api.create_release(@remote_stable, tag, :name => name, :body => body)
             end
-       end
+        end
 
         def versionToLocalBranch(version, suff)
             return @branch_format_raw.gsub(/\\\//, '/').
-                gsub(/\(.*\)/, version) + "/#{suff}"
+                       gsub(/\(.*\)/, version) + "/#{suff}"
         end
 
         def versionToStableBranch(version)
@@ -333,59 +358,65 @@ module GitMaintain
             submitReleases(opts, new_tags)
         end
         def summary(opts)
-             log(:INFO, "Configuration summary:")
-             if self.class != GitMaintain::Repo then
-                 log(:INFO, "Using custom repo class: #{self.class.to_s()}")
-             end
-             log(:INFO, "Stable remote: #{@stable_repo}")
-             log(:INFO, "Validation remote: #{@valid_repo}")
-             log(:INFO, "")
-             log(:INFO, "Branch config:")
-             log(:INFO, "Local branch format: /#{@branch_format_raw}/")
-             log(:INFO, "Remote stable branch format: #{@stable_branch_format}")
-             log(:INFO, "Remote stable base format: #{@stable_base_format}")
-
-             if @stable_base_patterns.length > 0 then
-                 log(:INFO, "")
-                 log(:INFO, "Stable base rules:")
-                 @stable_base_patterns.each(){|name, base|
-                     log(:INFO, "\t#{name} -> #{base}")
-                 }
-             end
-             brList = getBranchList(opts[:br_suff])
-             brStList = getStableBranchList()
-
-             if brList.length > 0 then
-                 log(:INFO, "")
-                 log(:INFO, "Local branches:")
-                 brList.each(){|br|
-                     branch = Branch.load(self, br, nil, opts[:branch_suff])
-                     localBr = branch.local_branch
-                     stableBr = @@STABLE_REPO + "/" + branch.remote_branch
-                     stableBase = branch.stable_base
-                     runGit("rev-parse --verify --quiet #{stableBr}")
-                     stableBr = "<MISSING>" if $? != 0 
-                     log(:INFO, "\t#{localBr} -> #{stableBr} (#{stableBase})")
-                     brStList.delete(br)
-                 }
-             end
-
-             if brStList.length > 0 then
-                 log(:INFO, "")
-                 log(:INFO, "Upstream branches:")
-                 brStList.each(){|br|
-                     branch = Branch.load(self, br, nil, opts[:branch_suff])
-                     stableBr = @@STABLE_REPO + "/" + branch.remote_branch
-                     stableBase = branch.stable_base
-                     log(:INFO, "\t<MISSING> -> #{stableBr} (#{stableBase})")
-                 }
-             end
-       end
+            log(:INFO, "Configuration summary:")
+            if self.class != GitMaintain::Repo then
+                log(:INFO, "Using custom repo class: #{self.class.to_s()}")
+            end
+            log(:INFO, "Stable remote: #{@stable_repo}")
+            log(:INFO, "Validation remote: #{@valid_repo}")
+            log(:INFO, "")
+            log(:INFO, "Branch config:")
+            log(:INFO, "Local branch format: /#{@branch_format_raw}/")
+            log(:INFO, "Remote stable branch format: #{@stable_branch_format}")
+            log(:INFO, "Remote stable base format: #{@stable_base_format}")
+
+            if @stable_base_patterns.length > 0 then
+                log(:INFO, "")
+                log(:INFO, "Stable base rules:")
+                @stable_base_patterns.each(){|name, base|
+                    log(:INFO, "\t#{name} -> #{base}")
+                }
+            end
+            brList = getBranchList(opts[:br_suff])
+            brStList = getStableBranchList()
+
+            if brList.length > 0 then
+                log(:INFO, "")
+                log(:INFO, "Local branches:")
+                brList.each(){|br|
+                    branch = Branch.load(self, br, nil, opts[:br_suff])
+                    localBr = branch.local_branch
+                    stableBr = @@STABLE_REPO + "/" + branch.remote_branch
+                    stableBase = branch.stable_base
+                    begin
+                        ref_exist?(stableBr)
+                    rescue NoRefError
+                        stableBr = "<MISSING>"
+                    end
+                    log(:INFO, "\t#{localBr} -> #{stableBr} (#{stableBase})")
+                    brStList.delete(br)
+                }
+            end
+
+            if brStList.length > 0 then
+                log(:INFO, "")
+                log(:INFO, "Upstream branches:")
+                brStList.each(){|br|
+                    branch = Branch.load(self, br, nil, opts[:branch_suff])
+                    stableBr = @@STABLE_REPO + "/" + branch.remote_branch
+                    stableBase = branch.stable_base
+                    log(:INFO, "\t<MISSING> -> #{stableBr} (#{stableBase})")
+                }
+            end
+        end
         def find_alts(commit)
             alts=[]
 
-            subj=runGit("log -1 --pretty='%s' #{commit}")
-            return alts if $? != 0
+            begin
+                subj=runGit("log -1 --pretty='%s' #{commit}")
+            rescue RuntimeError
+                return []
+            end
 
             branches = getStableBranchList().map(){|v| @@STABLE_REPO + "/" + versionToStableBranch(v)}
 
@@ -402,46 +433,46 @@ module GitMaintain
         #
         # Github API stuff
         #
-	    def api
-		    @api ||= Octokit::Client.new(:access_token => token, :auto_paginate => true)
-	    end
-
-	    def token
-		    @token ||= begin
-			               # We cannot use the 'defaults' functionality of git_config here,
-			               # because get_new_token would be evaluated before git_config ran
-			               tok = getGitConfig("maintain.api-token")
+	def api
+	    @api ||= Octokit::Client.new(:access_token => token, :auto_paginate => true)
+	end
+
+	def token
+	    @token ||= begin
+			   # We cannot use the 'defaults' functionality of git_config here,
+			   # because get_new_token would be evaluated before git_config ran
+			   tok = getGitConfig("maintain.api-token")
                            tok.to_s() == "" ? get_new_token : tok
-		               end
-	    end
- 	    def get_new_token
-		    puts "Requesting a new OAuth token from Github..."
-		    print "Github username: "
-		    user = $stdin.gets.chomp
-		    print "Github password: "
-		    pass = $stdin.noecho(&:gets).chomp
-		    puts
-
-		    api = Octokit::Client.new(:login => user, :password => pass)
-
-		    begin
-			    res = api.create_authorization(:scopes => [:repo], :note => "git-maintain")
-		    rescue Octokit::Unauthorized
-			    puts "Username or password incorrect.  Please try again."
-			    return get_new_token
+		       end
+	end
+ 	def get_new_token
+	    puts "Requesting a new OAuth token from Github..."
+	    print "Github username: "
+	    user = $stdin.gets.chomp
+	    print "Github password: "
+	    pass = $stdin.noecho(&:gets).chomp
+	    puts
+
+	    api = Octokit::Client.new(:login => user, :password => pass)
+
+	    begin
+		res = api.create_authorization(:scopes => [:repo], :note => "git-maintain")
+	    rescue Octokit::Unauthorized
+		puts "Username or password incorrect.  Please try again."
+		return get_new_token
             rescue Octokit::OneTimePasswordRequired
-		        print "Github OTP: "
-		        otp = $stdin.noecho(&:gets).chomp
-			    res = api.create_authorization(:scopes => [:repo], :note => "git-maintain",
+		print "Github OTP: "
+		otp = $stdin.noecho(&:gets).chomp
+		res = api.create_authorization(:scopes => [:repo], :note => "git-maintain",
                                                :headers => {"X-GitHub-OTP" => otp})
-		    end
+	    end
 
-		    token = res[:token]
-		    runGit("config --global maintain.api-token '#{token}'")
+	    token = res[:token]
+	    runGit("config --global maintain.api-token '#{token}'")
 
             # Now reopen with the token so OTP does not bother us
             @api=nil
             token
-	    end
-   end
+	end
+    end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: git-maintain
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Nicolas Morey-Chaisemartin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-04-15 00:00:00.000000000 Z
+date: 2025-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: octokit