git-maintain 0.9.0 → 0.12.0

data/lib/branch.rb

@@ -10,16 +10,15 @@ module GitMaintain
 
     class Branch
         ACTION_LIST = [
-            :cp, :steal, :list, :list_stable,
-            :merge, :push, :monitor,
-            :push_stable, :monitor_stable,
+            :cp, :steal, :list,
+            :merge, :pull, :push, :monitor,
             :release, :reset, :create, :delete
         ]
         NO_FETCH_ACTIONS = [
             :cp, :merge, :monitor, :release, :delete
         ]
         NO_CHECKOUT_ACTIONS = [
-            :create, :delete, :list, :list_stable, :push, :monitor, :monitor_stable
+            :create, :delete, :list, :push, :monitor
         ]
         ALL_BRANCHES_ACTIONS = [
             :create
@@ -30,12 +29,10 @@ module GitMaintain
             :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",
+            :pull => "Rebase branches on top of the upstream one",
             :monitor => "Check the CI state of all branches",
-            :push_stable => "Push to stable repo",
-            :monitor_stable => "Check the CI state of all stable branches",
             :release => "Create new release on all concerned branches",
             :reset => "Reset branch against upstream",
         }
@@ -58,6 +55,7 @@ module GitMaintain
             opts[:watch] = false
             opts[:delete_remote] = false
             opts[:no_edit] = false
+            opts[:stable] = false
 
             optsParser.on("-v", "--base-version [MIN_VER]", Integer, "Older release to consider.") {
                 |val| opts[:base_ver] = val}
@@ -84,41 +82,49 @@ module GitMaintain
             when :delete
                 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 }
             when :merge
                 optsParser.banner += "-m <suffix>"
                 optsParser.on("-m", "--merge [SUFFIX]", "Merge branch with suffix.") {
                     |val| opts[:do_merge] = val}
-            when :monitor, :monitor_stable
+            when :monitor
                 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 }
+            when :pull
+                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).") {
-                    |val| opts[:push_force] = val}
-            when :push_stable
+                    opts[:push_force] = true}
+                optsParser.on("--stable", "Push to stable repo.") {
+                    opts[:stable] = true }
                 optsParser.banner += "[-T]"
                 optsParser.on("-T", "--no-ci", "Ignore CI build status and push anyway.") {
-                    |val| opts[:no_ci] = true}
+                    opts[:no_ci] = true}
                 optsParser.on("-c", "--check", "Check if there is something to be pushed.") {
-                    |val| opts[:check_only] = true}
+                    opts[:check_only] = true}
             when :release
-                 optsParser.on("--no-edit", "Do not edit release commit nor tag.") {
-                     opts[:no_edit] = true }
+                optsParser.on("--no-edit", "Do not edit release commit nor tag.") {
+                    opts[:no_edit] = true }
             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] == :push_stable ||
-               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
@@ -128,6 +134,11 @@ module GitMaintain
                     raise "Action #{opts[:action]} can NOT be done on 'master' suffixed branches"
                 end
             end
+            if opts[:action] == :push
+                if opts[:stable] == true && opts[:push_force] == true then
+                    raise "Action push  can NOT be use both --stable and --force"
+                end
+            end
             opts[:version] = [ /.*/ ] if opts[:version].length == 0
         end
 
@@ -192,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)
@@ -213,9 +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)
@@ -223,7 +242,7 @@ module GitMaintain
                 @stable_base   = @remote_ref
             end
         end
-        attr_reader :version, :local_branch, :head, :remote_branch, :remote_ref, :stable_head,
+        attr_reader :version, :local_branch, :head, :remote_branch, :valid_ref, :remote_ref, :stable_head,
                     :verbose_name, :exists, :stable_base
 
         def log(lvl, str)
@@ -243,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
 
@@ -254,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()
-		        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
@@ -274,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")
@@ -305,16 +330,15 @@ module GitMaintain
             end
         end
 
-        # List commits in the branch that are no in the stable branch
         def list(opts)
             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}"))
+            if opts[:stable] == true then
+                # List commits in the stable_branch that are no in the latest release
+                GitMaintain::showLog(opts, @remote_ref, @repo.runGit("describe --abbrev=0 #{@local_branch}"))
+            else
+                # List commits in the branch that are no in the stable branch
+                GitMaintain::showLog(opts, @local_branch, @remote_ref)
+            end
         end
 
         # Merge merge_branch into this one
@@ -322,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
@@ -337,25 +362,68 @@ 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()
-		        end
+		    @repo.runBash("PS1_WARNING='MERGING'")
+		end
             else
                 log(:INFO, "Skipping merge")
                 return
             end 
         end
 
+        def pull(opts)
+            remoteRef = opts[:stable] == true ? @remote_ref : @valid_ref
+
+            # Make sure branch exists
+            begin
+                @repo.ref_exist?(remoteRef)
+            rescue NoRefError
+                log(:INFO, "Branch #{remoteRef} does not exists. Skipping...")
+                return
+            end
+            @repo.runGitInteractive("rebase #{remoteRef}")
+
+        end
         # Push the branch to the validation repo
         def push(opts)
-            if same_sha?(@local_branch, @repo.valid_repo + "/" + @local_branch) ||
+            remoteRef = opts[:stable] == true ? @remote_ref : @valid_ref
+
+            # Check both where we want to push and the final remote_ref
+            # We may have destroyed the validation branch but if we already merged
+            # in the final repo, no need to worry about it.
+            if same_sha?(@local_branch, remoteRef) ||
                same_sha?(@local_branch, @remote_ref) then
                 log(:INFO, "Nothing to push on #{@local_branch}")
                 return
             end
-            return "#{@local_branch}:#{@local_branch}"
+
+            # For stable branches, we need to check for CI
+            if opts[:stable] == true &&
+               (opts[:no_ci] != true && @NO_CI != true) &&
+               @ci.checkValidState(self, @head) != true then
+                log(:WARNING, "Build is not passed on CI. Skipping push to stable")
+                return
+            end
+
+            if opts[:check_only] == true then
+                GitMaintain::checkLog(opts, @local_branch, @remote_ref, "")
+                return
+            end
+
+            # For validation/CI push, let's go and push already
+            return "#{@local_branch}:#{@local_branch}" if opts[:stable] != true
+
+            # For stable, we need to confirm with the user that he really wants to push
+            rep = GitMaintain::checkLog(opts, @local_branch, @remote_ref, "submit")
+            if rep == "y" then
+                return "#{@local_branch}:#{@remote_branch}"
+            else
+                log(:INFO, "Skipping push to stable")
+                return
+            end
         end
 
         def self.push_epilogue(opts, branches)
@@ -364,17 +432,26 @@ module GitMaintain
 
             return if branches.length == 0
 
+            repo = (opts[:stable] == true) ? opts[:repo].stable_repo : opts[:repo].valid_repo
             opts[:repo].runGit("push #{opts[:push_force] == true ? "-f" : ""} "+
-                               "#{opts[:repo].valid_repo} #{branches.join(" ")}")
+                               "#{repo} #{branches.join(" ")}")
         end
 
         # Monitor the build status on CI
         def monitor(opts)
-            st = @ci.getValidState(self, @head)
+            ts = st = head = nil
             suff=""
+            if opts[:stable] == true then
+                st = @ci.getStableState(self, @stable_head)
+                ts = @ci.getStableTS(self, @stable_head) if st == "started"
+            else
+                st = @ci.getValidState(self, @head)
+                ts = @ci.getValidTS(self, @head) if st == "started"
+            end
+
             case st
             when "started"
-                suff= " started at #{@ci.getValidTS(self, @head)}"
+                suff= " at #{ts}"
             end
             log(:INFO, "Status for v#{@version}: " + st + suff)
             if @ci.isErrored(self, st) && opts[:watch] == false
@@ -396,52 +473,6 @@ module GitMaintain
             end
         end
 
-        # Push branch to the stable repo
-        def push_stable(opts)
-            if same_sha?(@local_branch, @remote_ref) then
-                log(:INFO, "Stable is already up-to-date")
-                return
-            end
-
-            if (opts[:no_ci] != true && @NO_CI != true) &&
-               @ci.checkValidState(self, @head) != true then
-                log(:WARNING, "Build is not passed on CI. Skipping push to stable")
-                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
-                return "#{@local_branch}:#{@remote_branch}"
-            else
-                log(:INFO, "Skipping push to stable")
-                return
-            end
-        end
-
-
-        def self.push_stable_epilogue(opts, branches)
-            # Compact to remove empty entries
-            branches.compact!()
-
-            return if branches.length == 0
-            opts[:repo].runGit("push #{opts[:repo].stable_repo} #{branches.join(" ")}")
-        end
-         # Monitor the build status of the stable branch on CI
-        def monitor_stable(opts)
-            st = @ci.getStableState(self, @stable_head)
-            suff=""
-            case st
-            when "started"
-                suff= " started at #{@ci.getStableTS(self, @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
@@ -470,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
@@ -507,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
 
@@ -523,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")
@@ -642,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
@@ -681,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
@@ -706,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.runSystem("/bin/bash")
+		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.runSystem("/bin/bash")
-		    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