git-maintain 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 356c77a387c232c07fd214617a107f32853d3425e1468f25c4f8594d8e5dedc8
-  data.tar.gz: a791a193557d15988872bef9ef3937591477491cfeb663b2fe4580c8cae8204e
+  metadata.gz: 4ccbf8e5307eaae5365b48a6ce99f026f020fa18acd0f34542cf8f4d8ecfbb51
+  data.tar.gz: de7a34ab07001688472118280ed5db9bed9016148a50f5009af2e9da5f16722e
 SHA512:
-  metadata.gz: '0194ca3ad74a99f24e1910df00dc320d1a277ba9a9bfab48142f176d4a23428fb275e37a2ac932d456ce26690ededa924b5bc15459b5bd348840d4ea7c13174d'
-  data.tar.gz: d604791372bfa3988518cb5b4216815236885e37e8c7716bc1cc9672306582b4d3a43b7c3c880bc88809e91d1d0441bf3d8312ddc59692daf2ae731f15be737e
+  metadata.gz: 8ed529842a7c85ca7e13e969fe561edc671ddc5ef20a559484523a7b0643e01236205b7b9681eff7d123024771ea6037ceaa79cba388032dc2971dbf2938aa58
+  data.tar.gz: 2bb5406a3a5d028a7dbde47a2ccdf6ae4b69e4b1ab379e428069af14088dce6a5289e0fe74eccf32e45f9927a94bde7143f86efb172d05c464092852f7edec12

data/CHANGELOG

@@ -1,7 +1,23 @@
 ------------------
-0.5.0  (2019-02-05)
+0.6.0  (2019-03-21)
 ------------------
 
+* Speed up push_stable
+* Add --check option for push_stable
+* Add --no-fetch option
+* Cleanup release email
+* Add build timestamp for running build in monitor
+* Add --watch for monitor and monitor_stable
+* Fix bad output ot git maintain steal
+* Rewrite log system and handle colors
+* Add list_stable command
+* Rework branching constraints to support more flexible names
+* Add create command to create missing local branches
+* Add delete command to remove temporary working branches
+
+------------------
+0.5.0  (2019-02-05)
+------------------
 
 * Handle bad Fixes tag
 * Speed up steal feature by remembering last point checked

data/README.md

@@ -9,8 +9,11 @@ The idea is to script most of the maintenance tasks so the maintainer can focus
 # Command summary
 
 - **cp**: Backport commits and eventually push them to github
+- **create**: Create missing local branches from all the stable branches
+- **delete**: Delete all local branches using the suffix
 - **steal**: Steal commit from upstream that fixes commit in the branch or were tagged as stable
 - **list**: List commit present in the branch but not in the stable branch
+- **list_stable**: List commit present in the stable branch but not in the latest associated relase
 - **merge**: Merge branch with suffix specified in -m <suff> into the main branch
 - **push**: Push branches to github for validation
 - **monitor**: Check the travis state of all branches
@@ -90,6 +93,36 @@ stable-base.dev---stable-v15 v15
 ```
 This will allow 'git maintain steal' to figure out what should be backported in the stable branches.
 
+
+You know can use a regexp for dealing with branch names that extends with version
+ without any changes to your .gitconfig
+
+Configure your local branch name space that also extracts the version:
+```
+$ git config --get maintain.branch-format
+dev\/stable-v([0-9]*)
+```
+
+Configure the upstream stable branches. Use ruby regexp value extraction (\\1) so git-maintain
+cal automatically insert the right version number
+```
+$ git config --get maintain.stable-branch-format
+stable-v\1
+
+```
+Finally configure the upstream fork points for stable branches so the `steal` commands know where to start from
+```
+$ git config --get maintain.stable-base-format
+v\1
+
+```
+
+Note that this value can be overriden by the stable-base.XXX value if needed
+
+Also, once you set these parameters, you can have git-maintain create all branches for you by running
+``
+$ git maintain create
+```
 ## Day-to-day workflow
 
 Watch the mailing-lists (and/or github and/or the upstream branches) for patches that are tagged for maintainance.

data/bin/git-maintain

@@ -45,6 +45,8 @@ optsParser.on("-b", "--branch-suffix [SUFFIX]", "Branch suffix. Default is 'mast
     |val| opts[:br_suff] = val}
 optsParser.on("-n", "--no", "Assume no to all questions.") {
     |val| opts[:no] = true}
+optsParser.on("--verbose", "Displays more informations.") {
+    |val| GitMaintain::setVerbose(true)}
 GitMaintain::setOpts(action, optsParser, opts)
 
 rest = optsParser.order!(ARGV);

data/lib/branch.rb

@@ -10,21 +10,27 @@ module GitMaintain
 
     class Branch
         ACTION_LIST = [
-            :cp, :steal, :list, :merge,
-            :push, :monitor,
+            :cp, :steal, :list, :list_stable,
+            :merge, :push, :monitor,
             :push_stable, :monitor_stable,
-            :release, :reset
+            :release, :reset, :create, :delete
         ]
         NO_FETCH_ACTIONS = [
-            :cp, :merge, :monitor, :release
+            :cp, :merge, :monitor, :release, :delete
         ]
         NO_CHECKOUT_ACTIONS = [
-            :list, :push, :monitor, :monitor_stable
+            :create, :delete, :list, :list_stable, :push, :monitor, :monitor_stable
+        ]
+        ALL_BRANCHES_ACTIONS = [
+            :create
         ]
         ACTION_HELP = [
             "* cp: Backport commits and eventually push them to github",
+            "* create: Create missing local branches from all the stable branches",
+            "* delete: Delete all local branches using the suffix",
             "* steal: Steal commit from upstream that fixes commit in the branch or were tagged as stable",
             "* list: List commit present in the branch but not in the stable branch",
+            "* list_stable: List commit present in the stable branch but not in the latest associated relase",
             "* merge: Merge branch with suffix specified in -m <suff> into the main branch",
             "* push: Push branches to github for validation",
             "* monitor: Check the travis state of all branches",
@@ -46,16 +52,28 @@ module GitMaintain
             opts[:do_merge] = false
             opts[:push_force] = false
             opts[:no_travis] = false
+            opts[:all] = false
+            opts[:check_only] = false
+            opts[:no_fetch] = false
+            opts[:watch] = false
 
             optsParser.on("-v", "--base-version [MIN_VER]", Integer, "Older release to consider.") {
                 |val| opts[:base_ver] = val}
             optsParser.on("-V", "--version [regexp]", Regexp, "Regexp to filter versions.") {
                 |val| opts[:version] = val}
 
-            if action != :merge
+            if  ALL_BRANCHES_ACTIONS.index(action) == nil &&
+                action != :merge &&
+                action != :delete then
                 optsParser.on("-B", "--manual-branch <branch name>", "Work on a specific (non-stable) branch.") {
                     |val| opts[:manual_branch] = val}
             end
+
+            if NO_FETCH_ACTIONS.index(action) == nil
+                optsParser.on("--no-fetch", "Skip fetch of stable repo.") {
+                    |val| opts[:no_fetch] = true}
+            end
+
             case action
             when :cp
                 optsParser.banner += "-c <sha1> [-c <sha1> ...]"
@@ -65,6 +83,10 @@ module GitMaintain
                 optsParser.banner += "-m <suffix>"
                 optsParser.on("-m", "--merge [SUFFIX]", "Merge branch with suffix.") {
                     |val| opts[:do_merge] = val}
+            when :monitor, :monitor_stable
+                optsParser.on("-w", "--watch <PERIOD>", Integer,
+                              "Watch and refresh travis status every <PERIOD>.") {
+                    |val| opts[:watch] = val}
             when :push
                 optsParser.banner += "[-f]"
                 optsParser.on("-f", "--force", "Add --force to git push (for 'push' action).") {
@@ -73,6 +95,8 @@ module GitMaintain
                 optsParser.banner += "[-T]"
                 optsParser.on("-T", "--no-travis", "Ignore Travis build status and push anyway.") {
                     |val| opts[:no_travis] = true}
+                optsParser.on("-c", "--check", "Check if there is something to be pushed.") {
+                    |val| opts[:check_only] = true}
             when :steal
                 optsParser.banner += "[-a]"
                 optsParser.on("-a", "--all", "Check all commits from master. "+
@@ -88,26 +112,38 @@ module GitMaintain
                     raise "Action #{opts[:action]} can only be done on 'master' suffixed branches"
                 end
             end
+            if opts[:action] == :delete then
+                if opts[:br_suff] == "master" then
+                    raise "Action #{opts[:action]} can NOT be done on 'master' suffixed branches"
+                end
+            end
         end
 
         def self.execAction(opts, action)
             repo   = Repo::load()
             travis = TravisChecker::load(repo)
 
-            if NO_FETCH_ACTIONS.index(action) == nil  then
+            if NO_FETCH_ACTIONS.index(action) == nil && opts[:no_fetch] == false then
                 repo.stableUpdate()
             end
 
             branchList=[]
             if opts[:manual_branch] == nil then
-                branchList = repo.getStableList(opts[:br_suff]).map(){|br|
+                unfilteredList = nil
+                if ALL_BRANCHES_ACTIONS.index(action) != nil then
+                    unfilteredList = repo.getStableBranchList()
+                else
+                    unfilteredList = repo.getBranchList(opts[:br_suff])
+                end
+                branchList = unfilteredList.map(){|br|
                     branch = Branch::load(repo, br, travis, opts[:br_suff])
                     case branch.is_targetted?(opts)
                     when :too_old
-                        puts "# Skipping older v#{branch.version}"
+                        GitMaintain::log(:VERBOSE, "Skipping older v#{branch.version}")
                         next
                     when :no_match
-                        puts "# Skipping v#{branch.version} not matching #{opts[:version].to_s()}"
+                        GitMaintain::log(:VERBOSE, "Skipping v#{branch.version} not matching" +
+                                                   opts[:version].to_s())
                         next
                     end
                     branch
@@ -115,16 +151,20 @@ module GitMaintain
             else
                 branchList = [ Branch::load(repo, opts[:manual_branch], travis, opts[:br_suff]) ]
             end
-            branchList.each(){|branch|
-                puts "###############################"
-                puts "# Working on #{branch.verbose_name}"
-                puts "###############################"
 
-                if NO_CHECKOUT_ACTIONS.index(action) == nil  then
-                    branch.checkout()
-                end
-                branch.send(action, opts)
-            }
+            loop do
+                system("clear; date") if opts[:watch] != false
+                branchList.each(){|branch|
+                    if NO_CHECKOUT_ACTIONS.index(action) == nil  then
+                        GitMaintain::log(:INFO, "Working on #{branch.verbose_name}")
+                        branch.checkout()
+                    end
+                    branch.send(action, opts)
+                }
+                break if opts[:watch] == false
+                sleep(opts[:watch])
+                travis.emptyCache()
+            end
         end
 
         def initialize(repo, version, travis, branch_suff)
@@ -136,8 +176,8 @@ module GitMaintain
             @branch_suff   = branch_suff
 
             if version =~ /^[0-9]+$/
-                @local_branch  = "dev/stable-v#{@version}/#{@branch_suff}"
-                @remote_branch ="stable-v#{@version}"
+                @local_branch  = @repo.versionToLocalBranch(@version, @branch_suff)
+                @remote_branch = @repo.versionToStableBranch(@version)
                 @branch_type = :std
                 @verbose_name = "v"+version
             else
@@ -146,13 +186,17 @@ module GitMaintain
                 @verbose_name = version
             end
 
-            @head          = @repo.runGit("rev-parse #{@local_branch}")
+            @head          = @repo.runGit("rev-parse --verify --quiet #{@local_branch}")
             @remote_ref    = "#{@repo.stable_repo}/#{@remote_branch}"
-            @stable_head   = @repo.runGit("rev-parse #{@remote_ref}")
+            @stable_head   = @repo.runGit("rev-parse --verify --quiet #{@remote_ref}")
             @stable_base   = @repo.findStableBase(@local_branch)
+        end
+        attr_reader :version, :local_branch, :head, :remote_branch, :remote_ref, :stable_head,
+                    :verbose_name, :exists
 
+        def log(lvl, str)
+            GitMaintain::log(lvl, str)
         end
-        attr_reader :version, :local_branch, :head, :remote_branch, :remote_ref, :stable_head, :verbose_name
 
         def is_targetted?(opts)
             return true if @branch_type == :user_specified
@@ -176,13 +220,18 @@ module GitMaintain
         # Cherry pick an array of commits
         def cp(opts)
             opts[:commits].each(){|commit|
+                prev_head=@repo.runGit("rev-parse HEAD")
+                log(:INFO, "Applying #{@repo.getCommitHeadline(commit)}")
                 @repo.runGit("cherry-pick #{commit}")
                 if $? != 0 then
-                    puts "Cherry pick failure. Starting bash for manual fixes. Exit shell to continue"
-			        @repo.runSystem("bash")
-                    puts "Continuing..."
+                    log(:WARNING, "Cherry pick failure. Starting bash for manual fixes. Exit shell to continue")
+			        @repo.runBash()
 		        end
-		        make_pretty(commit)
+                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)
+                end
             }
         end
 
@@ -196,8 +245,8 @@ module GitMaintain
                 sha = @repo.runGit("rev-parse 'git-maintain/steal/last/#{@stable_base}' 2>&1")
                 if $? == 0 then
                     base_ref=sha
-                    puts "# INFO: Starting from last successfull run:"
-                    puts "# INFO: " + @repo.runGit("show --format=oneline #{base_ref}")
+                    log(:VERBOSE, "Starting from last successfull run:")
+                    log(:VERBOSE, @repo.getCommitHeadline(base_ref))
                 end
             end
 
@@ -209,43 +258,74 @@ module GitMaintain
             # can just steal from this point on the next run
             if res == true then
                 @repo.runGit("tag -f 'git-maintain/steal/last/#{@stable_base}' origin/master")
-                puts "# INFO: Marking new last successfull run at:"
-                puts "# INFO: " + @repo.runGit("show --format=oneline #{master_sha}")
-         end
+                log(:VERBOSE, "Marking new last successfull run at:")
+                log(:VERBOSE, @repo.getCommitHeadline(master_sha))
+            end
         end
 
         # List commits in the branch that are no in the stable branch
         def list(opts)
-         GitMaintain::checkLog(opts, @local_branch, @remote_ref, nil)
+            GitMaintain::log(:INFO, "Working on #{@verbose_name}")
+            GitMaintain::showLog(opts, @local_branch, @remote_ref)
+        end
+
+        # List commits in the stable_branch that are no in the latest release
+        def list_stable(opts)
+            GitMaintain::log(:INFO, "Working on #{@verbose_name}")
+            GitMaintain::showLog(opts, @remote_ref, @repo.runGit("describe --abbrev=0 #{@local_branch}"))
         end
 
         # Merge merge_branch into this one
         def merge(opts)
-            merge_branch = "dev/stable-v#{@version}/#{opts[:do_merge]}"
+            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
+                log(:INFO, "Branch #{merge_branch} does not exists. Skipping...")
+                return
+            end
+
+            # See if there is anything worth merging
+            merge_base_hash = @repo.runGit("merge-base #{merge_branch} #{@local_branch}")
+            if merge_base_hash == hash_to_merge then
+                log(:INFO, "Branch #{merge_branch} has no commit that needs to be merged")
+                return
+            end
+
             rep = GitMaintain::checkLog(opts, merge_branch, @local_branch, "merge")
             if rep == "y" then
                 @repo.runGit("merge #{merge_branch}")
                 if $? != 0 then
-                    puts "Merge failure. Starting bash for manual fixes. Exit shell to continue"
-			        @repo.runSystem("bash")
-                    puts "Continuing..."
+                    log(:WARNING, "Merge failure. Starting bash for manual fixes. Exit shell to continue")
+			        @repo.runBash()
 		        end
             else
-                puts "Skipping merge"
+                log(:INFO, "Skipping merge")
                 return
             end 
         end
 
         # Push the branch to the validation repo
         def push(opts)
+            if same_sha?(@local_branch, @repo.valid_repo + "/" + @local_branch) then
+                log(:INFO, "Nothing to push")
+                return
+            end
+
            @repo.runGit("push #{opts[:push_force] == true ? "-f" : ""} #{@repo.valid_repo} #{@local_branch}")
         end
 
         # Monitor the build status on Travis
         def monitor(opts)
             st = @travis.getValidState(head)
-            puts "Status for v#{@version}: " + st
-            if st == "failed"
+            suff=""
+            case st
+            when "started"
+                suff= " started at #{@travis.getValidTS(head)}"
+            end
+            log(:INFO, "Status for v#{@version}: " + st + suff)
+            if st == "failed" && opts[:watch] == false
                 rep = "y"
                 suff=""
                 while rep == "y"
@@ -268,36 +348,74 @@ module GitMaintain
         def push_stable(opts)
             if (opts[:no_travis] != true && @NO_TRAVIS != true) &&
                @travis.checkValidState(@head) != true then
-                puts "Build is not passed on travis. Skipping push to stable"
+                log(:WARNING, "Build is not passed on travis. Skipping push to stable")
+                return
+            end
+
+            if same_sha?(@local_branch, @remote_ref) then
+                log(:INFO, "Stable is already up-to-date")
+                return
+            end
+
+            if opts[:check_only] == true then
+                GitMaintain::checkLog(opts, @local_branch, @remote_ref, "")
                 return
             end
+
             rep = GitMaintain::checkLog(opts, @local_branch, @remote_ref, "submit")
             if rep == "y" then
                 @repo.runGit("push #{@repo.stable_repo} #{@local_branch}:#{@remote_branch}")
             else
-                puts "Skipping push to stable"
+                log(:INFO, "Skipping push to stable")
                 return
             end
         end
 
          # Monitor the build status of the stable branch on Travis
         def monitor_stable(opts)
-            puts "Status for v#{@version}: " + @travis.getStableState(@stable_head)
+            st = @travis.getStableState(@stable_head)
+            suff=""
+            case st
+            when "started"
+                suff= " started at #{@travis.getStableTS(@stable_head)}"
+            end
+            log(:INFO, "Status for v#{@version}: " + st + suff)
         end
 
         # Reset the branch to the upstream stable one
         def reset(opts)
+            if same_sha?(@local_branch, @remote_ref) then
+                log(:INFO, "Nothing to reset")
+                return
+            end
+
             rep = GitMaintain::checkLog(opts, @local_branch, @remote_ref, "reset")
             if rep == "y" then
                 @repo.runGit("reset --hard #{@remote_ref}")
             else
-                puts "Skipping reset"
+                log(:INFO, "Skipping reset")
                 return
             end
         end
 
         def release(opts)
-            puts "#No release command available for this repo"
+            log(:ERROR,"#No release command available for this repo")
+        end
+
+        def create(opts)
+            return if @head != ""
+            log(:INFO, "Creating missing #{@local_branch} from #{@remote_ref}")
+            @repo.runGit("branch #{@local_branch} #{@remote_ref}")
+        end
+
+        def delete(opts)
+            rep = GitMaintain::confirm(opts, "delete branch #{@local_branch}")
+            if rep == "y" then
+                @repo.runGit("branch -D #{@local_branch}")
+            else
+                log(:INFO, "Skipping deletion")
+                return
+            end
         end
 
         private
@@ -329,7 +447,7 @@ module GitMaintain
 	        # This might happen if someone pointed to a commit that doesn't exist in our
 	        # tree.
 	        if $? != 0 then
-                puts "# WARNING: Commit #{src_commit} points to a SHA #{commit} not in tree"
+                log(:WARNING, "Commit #{src_commit} points to a SHA #{commit} not in tree")
 		        return false
 	        end
 
@@ -396,24 +514,23 @@ module GitMaintain
         def pick_one(commit)
             @repo.runGit("cherry-pick --strategy=recursive -Xpatience -x #{commit} &> /dev/null")
 	        return if  $? == 0
-
-		    if [ @repo.runGit("status -uno --porcelain | wc -l") != 0 ]; then
+            if @repo.runGit("status -uno --porcelain | wc -l") == "0" then
 			    @repo.runGit("reset --hard")
-			    return
+                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.
-            find_alts(commit).each(){|alt_commit|
-			    @repo.runCmd("cherry-pick --strategy=recursive -Xpatience -x #{alt_commit} &> /dev/null")
+            @repo.find_alts(commit).each(){|alt_commit|
+			    @repo.runGit("cherry-pick --strategy=recursive -Xpatience -x #{alt_commit} &> /dev/null")
 			    if $? == 0 then
 				    return
 			    end
-			    @repo.runCmd("reset --hard")
+			    @repo.runGit("reset --hard")
             }
 		    # Still no? Let's go back to the original commit and hand it off to
 		    # the user.
-		    @repo.runCmd("cherry-pick --strategy=recursive -Xpatience -x #{commit} &> /dev/null")
+		    @repo.runGit("cherry-pick --strategy=recursive -Xpatience -x #{commit} &> /dev/null")
             raise CherryPickErrorException.new("Failed to cherry pick commit #{commit}", commit)
 	        return false
         end
@@ -421,11 +538,11 @@ module GitMaintain
         def confirm_one(opts, commit)
  		    rep=""
 		    do_cp=false
-		    puts @repo.runGit("show --format=oneline --no-patch --no-decorate #{commit}")
+		    puts @repo.getCommitHeadline(commit)
 		    while rep != "y" do
 			    puts "Do you want to steal this commit ? (y/n/b/?)"
                 if opts[:no] == true then
-                    puts "Auto-replying no due to --no option"
+                    log(:INFO, "Auto-replying no due to --no option")
                     rep = 'n'
                     break
                 else
@@ -433,10 +550,10 @@ module GitMaintain
                 end
 			    case rep
 				when "n"
-			        puts "Skip this commit"
+			        log(:INFO, "Skip this commit")
 					break
 				when "b"
-					puts "Blacklisting this commit for the current branch"
+					log(:INFO, "Blacklisting this commit for the current branch")
 					add_blacklist(commit)
 					break
 				when "y"
@@ -446,7 +563,7 @@ module GitMaintain
 				when "?"
 					puts @repo.runGit("show #{commit}")
                 else
-					STDERR.puts "Invalid answer $rep"
+					log(:ERROR, "Invalid answer $rep")
 		            puts @repo.runGit("show --format=oneline --no-patch --no-decorate #{commit}")
                 end
 		    end
@@ -476,31 +593,35 @@ module GitMaintain
 		    # Check if it's not blacklisted by a git-notes
 		    if is_blacklisted?(orig_cmt) == true then
 		        # Commit is blacklisted
-			    puts "Skipping 'blacklisted' commit " +
-                     @repo.runGit("show --format=oneline --no-patch --no-decorate #{orig_cmt}")
+			    log(:INFO, "Skipping 'blacklisted' commit " +
+                     @repo.getCommitHeadline(orig_cmt))
                 return true
 		    end
 
             do_cp = confirm_one(opts, orig_cmt)
             return false if do_cp != true
 
+            prev_head=@repo.runGit("rev-parse HEAD")
+
             begin
 		        pick_one(commit)
             rescue CherryPickErrorException => e
-			    puts "Cherry pick failed. Fix, commit (or reset) and exit."
+			    log(:WARNING, "Cherry pick failed. Fix, commit (or reset) and exit.")
 			    @repo.runSystem("/bin/bash")
-                return false
             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")
-			    puts "Custom commit, please double-check!"
+			    log(:WARNING, "Custom commit, please double-check!")
 			    @repo.runSystem("/bin/bash")
 		    end
-		    make_pretty(orig_cmt, msg)
+            if new_head != prev_head
+		        make_pretty(orig_cmt, msg)
+            end
         end
 
         def steal_all(opts, range)
@@ -510,5 +631,12 @@ module GitMaintain
             }
             return res
        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
+
+        end
     end
 end

data/lib/common.rb

@@ -6,6 +6,39 @@ require 'branch'
 
 $LOAD_PATH.pop()
 
+class String
+    # colorization
+    @@is_a_tty = nil
+    def colorize(color_code)
+        @@is_a_tty = STDOUT.isatty() if @@is_a_tty == nil
+        if @@is_a_tty then
+            return "\e[#{color_code}m#{self}\e[0m"
+        else
+            return self
+        end
+    end
+
+    def red
+        colorize(31)
+    end
+
+    def green
+        colorize(32)
+    end
+
+    def brown
+        colorize(33)
+    end
+
+    def blue
+        colorize(34)
+    end
+
+    def magenta
+        colorize(35)
+    end
+end
+
 module GitMaintain
     class Common
         ACTION_LIST = [ :list_actions ]
@@ -18,6 +51,8 @@ module GitMaintain
     ACTION_CLASS = [ Common, Branch, Repo ]
     @@custom_classes = {}
 
+    @@verbose_log = false
+
     def registerCustom(repo_name, classes)
         raise("Multiple class for repo #{repo_name}") if @@custom_classes[repo_name] != nil
         @@custom_classes[repo_name] = classes
@@ -32,10 +67,10 @@ module GitMaintain
     def loadClass(default_class, repo_name, *more)
         custom = @@custom_classes[repo_name]
         if custom != nil && custom[default_class] != nil then
-            puts "# Detected custom #{default_class} class for repo '#{repo_name}'" if ENV['DEBUG'] == "1"
+            log(:DEBUG,"Detected custom #{default_class} class for repo '#{repo_name}'")
             return custom[default_class].new(*more)
         else
-            puts "# Detected NO custom #{default_class} classes for repo '#{repo_name}'" if ENV['DEBUG'] == "1"
+            log(:DEBUG,"Detected NO custom #{default_class} classes for repo '#{repo_name}'")
             return default_class.new(*more)
         end
     end
@@ -110,6 +145,42 @@ module GitMaintain
     end
     module_function :checkLog
 
+    def showLog(opts, br1, br2)
+        log(:INFO, "Diff between #{br1} and #{br2}")
+        puts `git log --format=oneline #{br1} ^#{br2}`
+        return "n"
+    end
+    module_function :showLog
+
+    def _log(lvl, str, out=STDOUT)
+        puts("# " + lvl.to_s() + ": " + str)
+    end
+    module_function :_log
+
+    def log(lvl, str)
+        case lvl
+        when :DEBUG
+            _log("DEBUG".magenta(), str) if ENV["DEBUG"].to_s() != ""
+        when :DEBUG_TRAVIS
+            _log("DEBUG_TRAVIS".magenta(), str) if ENV["DEBUG_TRAVIS"].to_s() != ""
+        when :VERBOSE
+            _log("INFO".blue(), str) if @@verbose_log == true
+        when :INFO
+            _log("INFO".green(), str)
+        when :WARNING
+            _log("WARNING".brown(), str)
+        when :ERROR
+            _log("ERROR".red(), str, STDERR)
+        else
+            _log(lvl, str)
+        end
+    end
+    module_function :log
+
+    def setVerbose(val)
+        @@verbose_log = val
+    end
+    module_function :setVerbose
 end
 $LOAD_PATH.pop()
 

data/lib/repo.rb

@@ -40,7 +40,7 @@ module GitMaintain
             GitMaintain::checkDirectConstructor(self.class)
 
             @path = path
-            @stable_list=nil
+            @branch_list=nil
             @stable_branches=nil
             @suffix_list=nil
 
@@ -57,16 +57,26 @@ module GitMaintain
                                 awk '{ print $2}' | sed -e 's/.*://' -e 's/\\.git//'")
             @remote_stable=runGit("remote -v | egrep '^#{@stable_repo}' | grep fetch |
                                       awk '{ print $2}' | sed -e 's/.*://' -e 's/\\.git//'")
+
+            @branch_format_raw = runGit("config maintain.branch-format 2> /dev/null").chomp()
+            @branch_format = Regexp.new(/#{@branch_format_raw}/)
+            @stable_branch_format = runGit("config maintain.stable-branch-format 2> /dev/null").chomp()
+            @stable_base_format = runGit("config maintain.stable-base-format 2> /dev/null").chomp()
+
             @stable_base_patterns=
                 runGit("config --get-regexp   stable-base | egrep '^stable-base\.' | "+
                        "sed -e 's/stable-base\.//' -e 's/---/\\//g'").split("\n").inject({}){ |m, x|
                 y=x.split(" ");
                 m[y[0]] = y[1]
                 m
-                }
+            }
         end
         attr_reader :path, :remote_valid, :remote_stable, :valid_repo, :stable_repo
 
+        def log(lvl, str)
+            GitMaintain::log(lvl, str)
+        end
+
         def run(cmd)
             return `cd #{@path} && #{cmd}`
         end
@@ -74,10 +84,8 @@ module GitMaintain
             return system("cd #{@path} && #{cmd}")
         end
         def runGit(cmd)
-            if ENV["DEBUG"].to_s() != "" then
-                puts "Called from #{caller[1]}"
-                puts "Running git command '#{cmd}'"
-            end
+            log(:DEBUG, "Called from #{caller[1]}")
+            log(:DEBUG, "Running git command '#{cmd}'")
             return `git --work-tree=#{@path} #{cmd}`.chomp()
         end
         def runGitImap(cmd)
@@ -90,28 +98,54 @@ module GitMaintain
                   fi; git --work-tree=#{@path} imap-send #{cmd}`
         end
 
+        def runBash()
+            runSystem("bash")
+            if $? == 0 then
+                log(:INFO, "Continuing...")
+            else
+                log(:ERROR, "Shell exited with code #{$?}. Exiting")
+                raise("Cancelled by user")
+            end
+        end
+
+        def getCommitHeadline(sha)
+            return runGit("show --format=oneline --no-patch --no-decorate #{sha}")
+        end
+
         def stableUpdate()
-            puts "# Fetching stable updates..."
+            log(:VERBOSE, "Fetching stable updates...")
             runGit("fetch #{@stable_repo}")
         end
-        def getStableList(br_suff)
-            return @stable_list if @stable_list != nil
+        def getBranchList(br_suff)
+            return @branch_list if @branch_list != nil
+
+            @branch_list=runGit("branch").split("\n").map(){|x|
+                x=~ /#{@branch_format_raw}\/#{br_suff}$/ ? 
+                    $1 : nil
+            }.compact().uniq()
+
+            return @branch_list
+        end
+
+        def getStableBranchList()
+            return @stable_branches if @stable_branches != nil
 
-            @stable_list=runGit("branch").split("\n").map(){|x|
-                x=~ /dev\/stable-v[0-9]+\/#{br_suff}/ ?
-                    x.gsub(/\*?\s*dev\/stable-v([0-9]+)\/#{br_suff}\s*$/, '\1') :
-                    nil}.compact().uniq()
+            @stable_branches=runGit("branch -a").split("\n").map(){|x|
+                x=~ /remotes\/#{@@STABLE_REPO}\/#{@stable_branch_format.gsub(/\\1/, '([0-9]+)')}$/ ?
+                    $1 : nil
+            }.compact().uniq()
 
-            return @stable_list
+            return @stable_branches
         end
 
         def getSuffixList()
             return @suffix_list if @suffix_list != nil
 
             @suffix_list = runGit("branch").split("\n").map(){|x|
-                x=~ /dev\/stable-v[0-9]+\/[a-zA-Z0-9_-]+/ ?
-                    x.gsub(/\*?\s*dev\/stable-v[0-9]+\/([a-zA-Z0-9_-]+)\s*$/, '\1') :
-                    nil}.compact().uniq()
+                x=~ @branch_format ? 
+                    /^\*?\s*#{@branch_format_raw}\/([a-zA-Z0-9_-]+)\s*$/.match(x)[-1] :
+                    nil
+            }.compact().uniq()
 
             return @suffix_list
         end
@@ -125,11 +159,11 @@ module GitMaintain
 
             new_tags = local_tags - remote_tags
             if new_tags.empty? then
-                puts "All tags are already submitted."
+                log(:INFO,  "All tags are already submitted.")
                 return
             end
 
-            puts "This will officially release these tags: #{new_tags.join(", ")}"
+            log(:WARNING, "This will officially release these tags: #{new_tags.join(", ")}")
             rep = GitMaintain::confirm(opts, "release them")
             if rep != 'y' then
                 raise "Aborting.."
@@ -143,11 +177,27 @@ module GitMaintain
                           " <" + runGit("config user.email") +">"
                 mail.puts "To: " + runGit("config patch.target")
                 mail.puts "Date: " + `date -R`.chomp()
-                mail.puts "Subject: [ANNOUNCE] " + File.basename(@path) + " " +
-                          (new_tags.length > 1 ?
-                               (new_tags[0 .. -2].join(", ") + " and " + new_tags[-1]) :
-                               new_tags.join(" ")) +
-                          " has been tagged/released"
+
+                if new_tags.length > 4 then
+                    mail.puts "Subject: [ANNOUNCE] " + File.basename(@path) + ": new stable releases"
+                    mail.puts ""
+                    mail.puts "These version were tagged/released:\n * " +
+                              new_tags.join("\n * ")
+                    mail.puts ""
+                else
+                    mail.puts "Subject: [ANNOUNCE] " + File.basename(@path) + " " +
+                              (new_tags.length > 1 ?
+                                   (new_tags[0 .. -2].join(", ") + " and " + new_tags[-1] + " have ") :
+                                   (new_tags.join(" ") + " has ")) +
+                              " been tagged/released"
+                    mail.puts ""
+                end
+                mail.puts "It's available at the normal places:"
+                mail.puts ""
+                mail.puts "git://github.com/#{@remote_stable}"
+                mail.puts "https://github.com/#{@remote_stable}/releases"
+                mail.puts ""
+                mail.puts "---"
                 mail.puts ""
                 mail.puts "Here's the information from the tags:"
                 new_tags.sort().each(){|tag|
@@ -163,22 +213,41 @@ module GitMaintain
                 puts runGitImap("< #{mail_path}; rm -f #{mail_path}")
             end
 
-            puts "Last chance to cancel before submitting"
+            log(:WARNING, "Last chance to cancel before submitting")
             rep= GitMaintain::confirm(opts, "submit these releases")
             if rep != 'y' then
                 raise "Aborting.."
             end
             puts `#{@@SUBMIT_BINARY}`
         end
+
+        def versionToLocalBranch(version, suff)
+            return @branch_format_raw.gsub(/\\\//, '/').
+                gsub(/\(.*\)/, version) + "/#{suff}"
+        end
+
+        def versionToStableBranch(version)
+            return version.gsub(/^(.*)$/, @stable_branch_format)
+        end
+
         def findStableBase(branch)
-            @stable_base_patterns.each(){|pattern, base|
-                return base if branch =~ /#{pattern}\// || branch =~ /#{pattern}$/
+            base=nil
+            if branch =~ @branch_format then
+                base = branch.gsub(/^\*?\s*#{@branch_format_raw}\/.*$/, @stable_base_format)
+            end
+
+            @stable_base_patterns.each(){|pattern, b|
+                if branch =~ /#{pattern}\// || branch =~ /#{pattern}$/
+                    base = b
+                    break
+                end
             }
-            raise("Could not a find a stable base for branch #{branch}")
+            raise("Could not a find a stable base for branch #{branch}") if base == nil
+            return base
         end
 
         def list_branches(opts)
-            puts getStableList(opts[:br_suff])
+            puts getBranchList(opts[:br_suff])
         end
         def list_suffixes(opts)
             puts getSuffixList()
@@ -186,5 +255,23 @@ module GitMaintain
         def submit_release(opts)
             submitReleases(opts)
         end
+
+        def find_alts(commit)
+            alts=[]
+
+            subj=runGit("log -1 --pretty='%s' #{commit}")
+            return alts if $? != 0
+
+            branches = getStableBranchList().map(){|v| @@STABLE_REPO + "/" + versionToStableBranch(v)}
+
+            runGit("log -F --grep \"$#{subj}\" --format=\"%H\" #{branches.join(" ")}").
+                split("\n").each(){|c|
+                next if c == commit
+                cursubj=runGit("log -1 --pretty='%s' #{c}")
+                alts << c if subj == cursubj
+            }
+
+            return alts
+        end
     end
 end

data/lib/travis.rb

@@ -15,6 +15,10 @@ module GitMaintain
         end
 
         private
+        def log(lvl, str)
+            GitMaintain::log(lvl, str)
+        end
+
         def fetch(uri_str, limit = 10)
             # You should choose a better exception.
             raise ArgumentError, 'too many HTTP redirects' if limit == 0
@@ -35,8 +39,8 @@ module GitMaintain
             return @cachedJson[query_label] if @cachedJson[query_label] != nil
             url = TRAVIS_URL + query
             uri = URI(url)
-            puts "# Querying travis..."
-            puts "# #{url}" if ENV["DEBUG_TRAVIS"].to_s() != ""
+            log(:INFO, "Querying travis...")
+            log(:DEBUG_TRAVIS, url)
             response = fetch(uri)
             raise("Travis request failed '#{url}'") if response.code.to_s() != '200'
 
@@ -59,6 +63,11 @@ module GitMaintain
             job_id = br["job_ids"].last().to_s()
             return getJson("log_" + job_id, 'jobs/' + job_id + '/log', false)
         end
+        def getTS(sha1, resp)
+            br = findBranch(sha1, resp)
+            raise("Travis build not found") if br == nil
+            return br["started_at"]
+        end
         def checkState(sha1, resp)
             return getState(sha1, resp) == "passed"
         end
@@ -70,11 +79,11 @@ module GitMaintain
             return getJson(:br_stable, 'repos/' + @repo.remote_stable + '/branches')
         end
         def findBranch(sha1, resp)
-            puts "# Looking for build for #{sha1}" if ENV["DEBUG_TRAVIS"].to_s() != ""
+            log(:DEBUG_TRAVIS, "Looking for build for #{sha1}")
             resp["branches"].each(){|br|
                 commit=resp["commits"].select(){|e| e["id"] == br["commit_id"]}.first()
                 raise("Incomplete JSON received from Travis") if commit == nil
-                puts "# Found entry for sha #{commit["sha"]}" if ENV["DEBUG_TRAVIS"].to_s() != ""
+                log(:DEBUG_TRAVIS, "Found entry for sha #{commit["sha"]}")
                 next if commit["sha"] != sha1
                 return br
             }
@@ -91,6 +100,9 @@ module GitMaintain
         def getValidLog(sha1)
             return getLog(sha1, getBrValidJson())
         end
+        def getValidTS(sha1)
+            return getTS(sha1, getBrValidJson())
+        end
 
         def getStableState(sha1)
             return getState(sha1, getBrStableJson())
@@ -101,5 +113,11 @@ module GitMaintain
         def getStableLog(sha1)
             return getLog(sha1, getBrStableJson())
         end
+        def getStableTS(sha1)
+            return getTS(sha1, getBrStableJson())
+        end
+        def emptyCache()
+            @cachedJson={}
+        end
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: git-maintain
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Nicolas Morey-Chaisemartin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-05 00:00:00.000000000 Z
+date: 2019-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: github-release
@@ -62,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Your ultimate script for maintaining stable branches.