git-maintain 0.9.0 → 0.12.0

data/lib/common.rb

@@ -57,6 +57,7 @@ module GitMaintain
 
     def registerCustom(repo_name, classes)
         raise("Multiple class for repo #{repo_name}") if @@custom_classes[repo_name] != nil
+        classes[:name] = repo_name if classes[:name] == nil
         @@custom_classes[repo_name] = classes
     end
     module_function :registerCustom
@@ -73,6 +74,11 @@ module GitMaintain
     end
     module_function :getClass
 
+    def getCustomClasses()
+        return @@custom_classes
+    end
+    module_function :getCustomClasses
+
     def loadClass(default_class, repo_name, *more)
         @@load_class.push(default_class)
         obj = GitMaintain::getClass(default_class, repo_name).new(*more)
@@ -95,49 +101,64 @@ module GitMaintain
 
     def getActionAttr(attr)
         if Common.const_get(attr).class == Hash
-            return ACTION_CLASS.inject({}){|h, x| h.merge(x.const_get(attr))}
+            return ACTION_CLASS.inject({}){|h, x| h.merge(getClass(x).const_get(attr))}
         else
-            return ACTION_CLASS.map(){|x| x.const_get(attr)}.flatten()
+            return ACTION_CLASS.map(){|x| getClass(x).const_get(attr)}.flatten()
         end
     end
     module_function :getActionAttr
 
     def setOpts(action, optsParser, opts)
          ACTION_CLASS.each(){|x|
-            next if x::ACTION_LIST.index(action) == nil
-            if x.singleton_methods().index(:set_opts) != nil then
+            if x::ACTION_LIST.index(action) != nil &&
+               x.singleton_methods().index(:set_opts) != nil then
+                matched=true
                 x.set_opts(action, optsParser, opts)
             end
             # Try to add repo specific opts
             y = getClass(x)
-            if x != y && y.singleton_methods().index(:set_opts) != nil then
+            if x != y && y::ACTION_LIST.index(action) != nil &&
+               y.singleton_methods().index(:set_opts) != nil then
+                matched=true
+                x.set_opts(action, optsParser, opts) if x.singleton_methods().index(:set_opts) != nil
                 y.set_opts(action, optsParser, opts)
             end
-            break
+            break if matched == true
         }
     end
     module_function :setOpts
 
     def checkOpts(opts)
         ACTION_CLASS.each(){|x|
-            next if x::ACTION_LIST.index(opts[:action]) == nil
-            next if x.singleton_methods().index(:check_opts) == nil
-            x.check_opts(opts)
+            if x::ACTION_LIST.index(opts[:action]) != nil &&
+               x.singleton_methods().index(:check_opts) != nil then
+                matched=true
+                x.check_opts(opts)
+            end
 
             # Try to add repo specific opts
             y = getClass(x)
-            if x != y && y.singleton_methods().index(:check_opts) != nil then
+            if x != y && y::ACTION_LIST.index(opts[:action]) != nil &&
+               y.singleton_methods().index(:check_opts) != nil then
+                matched=true
+                x.check_opts(opts) if x.singleton_methods().index(:check_opts) != nil
                 y.check_opts(opts)
             end
-        }
+            break if matched == true
+       }
     end
     module_function :checkOpts
 
     def execAction(opts, action)
         ACTION_CLASS.each(){|x|
-            next if x::ACTION_LIST.index(action) == nil
-            x.execAction(opts, action)
-            break
+            if x::ACTION_LIST.index(action) != nil
+                return x.execAction(opts, action)
+            end
+           # Try to add repo specific opts
+            y = getClass(x)
+            if x != y && y::ACTION_LIST.index(opts[:action]) != nil then
+                return y.execAction(opts, action)
+            end
         }
     end
     module_function :execAction
@@ -202,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
@@ -217,3 +244,16 @@ Dir.entries(BACKPORT_LIB_DIR + "/addons/").each(){|entry|
     require entry.sub(/.rb$/, "")
 }
 $LOAD_PATH.pop()
+
+if ENV["GIT_MAINTAIN_ADDON_DIR"].to_s() != "" then
+    ADDON_DIR=ENV["GIT_MAINTAIN_ADDON_DIR"].to_s()
+    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$/ );
+            require entry.sub(/.rb$/, "")
+        }
+        $LOAD_PATH.pop()
+    end
+end
+

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()
-            runSystem("bash")
-            if $? == 0 then
-                log(:INFO, "Continuing...")
-            else
+        def runBash(env="")
+            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,56 +358,65 @@ module GitMaintain
             submitReleases(opts, new_tags)
         end
         def summary(opts)
-             log(:INFO, "Configuration summary:")
-             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)}
 
@@ -399,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,35 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: git-maintain
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Nicolas Morey-Chaisemartin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-18 00:00:00.000000000 Z
+date: 2025-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: octokit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '5.0'
 description: |-
   Be lazy and let git-maintain do all the heavy lifting for maintaining stable branches.
   Leaves you only with the essential: reviewing the selected patches and decide where they should go.
@@ -71,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Your ultimate script for maintaining stable branches and releasing your project.