git-maintain 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c79a790fc66646271a7722a583509c1ce9d5c69dd1e69d0762b09fb5a5c19ab
+  data.tar.gz: 2d3a81431bbd6d4394f3eaa17c524b8b3ff1b7f752da10f165d5fadaa41b1c4f
+SHA512:
+  metadata.gz: ab558a35d36b5c767590b1dabe14bcedff7a51e7d74deb83ba142a543332450e14aa357099d9444dd83fd54c8d793229de39f4f260dcc3b0d2490abc9413bfab
+  data.tar.gz: 3b1d4a0166512d02d48673b676fbe924a364d90b01c5e343a8fa65ae412db910b9634fd0b947367e4bfe97cf3d5f28ea7ddce3863e79b5e2b7a7530a0ec345e2

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2018 SUSE
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,194 @@
+git-maintain is a simple ruby script to deal with all the hassle of maintaining stable branches in a project.
+
+The idea is to script most of the maintenance tasks so the maintainer can focus on just reviewing and not on writing up release notes, looking for commits and such.
+
+- Note: the workflow is highly inspired to the git-topic-branches (https://github.com/nmorey/git-topic-branches)
+  and both can be used at the same time
+- Note2: Releasing on github is done through the git-release (https://github.com/mpalmer/github-release)
+
+# Command summary
+
+- **cp**: Backport commits and eventually push them to github
+- **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
+- **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
+- **push_stable**: Push to stable repo
+- **monitor_stable**: Check the travis state of all stable branches
+- **release**: Create new release on all concerned branches
+- **reset**: Reset branch against upstream
+- **submit_release**: Push the to stable and create the release packages
+
+# Configuration
+
+## Basic shell setup
+- git-maintain should be in your path
+- Load git-maintain-completion.sh for shell completion
+
+## Remote setup
+- the 'github' remote should be your own WIP github to test out branches before submitting to the official repo
+- the 'origin' remote should be the official repo in read-only mode to avoid any accidental pushes
+- the 'stable' remote should be the official repo in RW mode
+
+## Stealing commits
+
+The steal feature uses was shamelessly copied it from https://git.kernel.org/pub/scm/linux/kernel/git/sashal/stable-tools.git/tree/
+
+## Making releases
+The release process being very specific to each project, the release command does nothing by default.
+However the behaviour can be overriden for specific repo (detected by repo name)
+
+Check the lib/addons/RDMACore.rb for an example.
+In this case, the release command bump the version in all the appropriate files (after computing the previous and next version numbers), commit and tags the commit.
+
+
+# How do I use it
+
+## Branch setup
+As said, this uses the branching schemes recommended/compatible of git-topic-branches.
+
+A non compulsory recommendation is to create
+I personnaly uses this scheme for my rdma-core work:
+```
+$ git branch
+dev/stable-v15/master
+dev/stable-v15/pending
+dev/stable-v16/master
+dev/stable-v16/pending
+dev/stable-v17/master
+dev/stable-v17/pending
+dev/stable-v17/test
+dev/stable-v18/master
+dev/stable-v18/pending
+* dev/stable-v19/master
+```
+
+I also use the git-topic-branches features:
+```
+git config --get-regexp devel-base
+devel-base.dev---stable-v19 origin/stable-v19
+devel-base.dev---stable-v18 origin/stable-v18
+devel-base.dev---stable-v17 origin/stable-v17
+devel-base.dev---stable-v16 origin/stable-v16
+devel-base.dev---stable-v15 origin/stable-v15
+```
+This allows me to:
+- autorebase on the stable branches. This is useful for dealing with development branches for stable branches
+- Detect when all my patches have made it to the upstream repo
+
+I also set the right config value for the 'steal' command to work
+```
+$ git config --get-regexp stable-base
+stable-base.dev---stable-v19 v19
+stable-base.dev---stable-v18 v18
+stable-base.dev---stable-v17 v17
+stable-base.dev---stable-v16 v16
+stable-base.dev---stable-v15 v15
+```
+This will allow 'git maintain steal' to figure out what should be backported in the stable branches.
+
+## Day-to-day workflow
+
+Watch the mailing-lists (and/or github and/or the upstream branches) for patches that are tagged for maintainance.
+Apply them to the appropriate branches
+
+```git maintain cp -s deadbeef --version '1[789]'```
+
+And push them to my own github repo so that Travis will check everything out
+
+```git maintain push --version '1[789]'```
+
+Some time later, check their status
+
+```git maintain monitor --version '1[789]'```
+
+If everything looks good, push to the stable repo
+
+```git maintain push_stable --version '1[789]'```
+
+If patches have been sent to the ML but are not yet accepted, I usually try them out on a "pending" branch.
+
+```git maintain cp -s deadbeef --version '1[789]' -b pending```
+
+Note that it is your own job to create the branches (yet!)
+
+Push it to my own github too.
+
+```git maintain push --version '1[789]' -b pending```
+
+Once this gets accepted (and Travis is OK too), I merge this branch back to my 'master'
+
+```git maintain merge --version '1[789]' -m pending```
+
+The default -b option here is master so it is not required to specify it. Also branch suffixed with something else than master cannot be pushed to stable branches for safety reasons.
+
+If this is all broken and the patch should not be applied, I simply reset my branch
+
+```git maintain reset --version '1[789]' -m pending```
+
+Note: This has been made as safe as possible and is querying you before doing anything destructive.
+
+## Stealing commits
+
+This uses a ruby version of the 'steal-stable-commits' script originally available here https://git.kernel.org/pub/scm/linux/kernel/git/sashal/stable-tools.git/tree/
+
+It allows to automatically cherry-pick commits that have been marked as fixing a bug in your branch.
+
+What it does is parse the master branch for commits that contains the standard
+
+```Fixes: deadbeef00 ("broken commit msg")```
+
+It will then check if the broken commit is in your branch (and not already fixed). It will then prompt you for reviewing the fix and apply it on your local stable branch.
+
+If the developers from your project follow this, it removes a lot of the hassle of finding which patch applies to which branches, It will do it for you !
+
+You can get more infos on how all this works here: https://git.kernel.org/pub/scm/linux/kernel/git/sashal/stable-tools.git/tree/README (stable steal-commits section).
+
+One of the added feature is the ability to blacklist a commit for certain branch.
+(Useful when there is a commit broken in your stable branch but the fix breaks the ABI or simply won't apply.)
+
+Blacklisting the fix (for a specific branch) will prevent it from ever popping up when stealing commits.
+Blacklisting is done through git-notes. It attaches a note to the "fix" commit in master and simply add the name of the branch it is blacklisted in. To run-blacklist the commit, edit the note and remove the branch name.
+
+Note that blacklisted commites will show an info message when skipped so you don't have to dig through all the notes to find which one you wanted.
+
+To run:
+
+```git maintain steal```
+
+
+## Releases
+
+Once some work has been done, it is time for a new release.
+
+First, unless you're working for the rdma-core repo, you'll need to add your own 'add-on' class to do automatize tyour release process. Please look at 'addons/RDMACore.rb' for an example.
+
+Then all you need to do is create your release(s)
+
+```git maintain release --version '1[789]'```
+
+This will run your addon code. What you usually want to do in there is create a tag and eventually bump version numbers, add releases notes, etc.
+
+I strongly advise here to then use the 'push_stable' command. It will update the branches, but NOT push the tag.
+This means that if something has been broken by the release commit (if any), there is still time to fix it.
+
+The tag will not have been propagated anywhere else and can be deleted manually.
+
+```git maintain push_stable --version '1[789]'```
+
+You can then monitor the status on Travis
+
+```git maintain monitor_stable --version '1[789]'```
+
+
+Once everything is green, it is time to submit your release
+
+```git maintain submit_release --version '1[789]'```
+
+This will submit the all pending tags to github, and prepare an email for the project mailing list (requires the 'patch.target' option from git-topic-branches)
+
+Review your email, send it and your day is over !
+
+Enjoy, and feel free to report bugs, missing features and/or send patches
+

data/bin/git-maintain

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'net/http'
+require 'json'
+
+BACKPORT_LIB_DIR = File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.push(BACKPORT_LIB_DIR)
+require 'common'
+$LOAD_PATH.pop()
+
+opts = {
+    :br_suff => "master",
+    :no => false,
+}
+
+actionParser = OptionParser.new(nil, 60)
+actionParser.banner = "Usage: #{__FILE__} <action> [action options]"
+actionParser.separator ""
+actionParser.separator "Options:"
+actionParser.on("-h", "--help", "Display usage.") { |val| puts actionParser.to_s; exit 0 }
+actionParser.separator "Possible actions:"
+GitMaintain::getActionAttr("ACTION_HELP").each(){|x|
+    actionParser.separator "\t " + x
+}
+rest = actionParser.order!(ARGV);
+if rest.length <= 0 then
+    STDERR.puts("Error: No action provided")
+    puts actionParser.to_s()
+    exit 1
+end
+
+action_s = ARGV[0]
+action = action_s.to_sym()
+raise("Invalid action '#{action_s}'") if GitMaintain::getActionAttr("ACTION_LIST").index(action) == nil
+opts[:action] = action
+ARGV.shift()
+
+optsParser = OptionParser.new(nil, 60)
+optsParser.banner = "Usage: #{__FILE__} #{action_s} "
+optsParser.separator ""
+optsParser.separator "Options:"
+optsParser.on("-h", "--help", "Display usage.") { |val| puts optsParser.to_s; exit 0 }
+optsParser.on("-b", "--branch-suffix [SUFFIX]", "Branch suffix. Default is 'master'.") {
+    |val| opts[:br_suff] = val}
+optsParser.on("-n", "--no", "Assume no to all questions.") {
+    |val| opts[:no] = true}
+GitMaintain::setOpts(action, optsParser, opts)
+
+rest = optsParser.order!(ARGV);
+raise("Extra Unexpected extra arguments provided: " + rest.map(){|x|"'" + x + "'"}.join(", ")) if rest.length != 0
+
+GitMaintain::checkOpts(opts)
+GitMaintain::execAction(opts, opts[:action])
+

data/git-maintain-completion.sh

@@ -0,0 +1,99 @@
+export _GIT_MAINTAIN_CMD_AWK=$(([ -f /bin/awk ] && echo "/bin/awk") || echo "/usr/bin/awk")
+export _GIT_MAINTAIN_CMD_SORT=$(([ -f /bin/sort ] && echo "/bin/sort") || echo "/usr/bin/sort")
+export _GIT_MAINTAIN_CMD_EGREP=$(([ -f /bin/egrep ] && echo "/bin/egrep") || echo "/usr/bin/egrep")
+export _GIT_MAINTAIN_CMD_SED=$(([ -f /bin/sed ] && echo "/bin/sed") || echo "/usr/bin/sed")
+
+_git_maintain_genoptlist(){
+	local COMMAND=$*
+	${COMMAND}  --help 2>&1 | \
+		${_GIT_MAINTAIN_CMD_AWK} 'BEGIN { found = 0 } { if(found == 1) print $$0; if($$1 == "Options:") {found = 1}}' | \
+		${_GIT_MAINTAIN_CMD_EGREP} -e "^[[:space:]]*--" -e "^[[:space:]]*-[a-zA-Z0-9]" | \
+		${_GIT_MAINTAIN_CMD_SED} -e 's/^[[:space:]]*//' -e 's/^-[^-], //' | \
+		${_GIT_MAINTAIN_CMD_AWK} '{ print $1}' | \
+		${_GIT_MAINTAIN_CMD_SED} -e 's/^\(.*\)\[no-\]\(.*$\)/\1\2\n\1no-\2/' | \
+		${_GIT_MAINTAIN_CMD_SORT} -u
+}
+_complete_git_maintain_branch(){
+	case $prev in
+		-b|--branch-suffix)
+			__gitcomp_nl "$(git maintain list_suffixes)"
+			;;
+		-v|--base-version)
+			BRANCHES=
+			__gitcomp_nl "$(git maintain list_branches)"
+			;;
+	esac
+}
+
+_git_maintain_cp()
+{
+   local OPT_LIST=$(_git_maintain_genoptlist git maintain cp)
+
+    case "$prev" in
+		-c|--sha1);;
+		*)
+			__gitcomp_nl "$OPT_LIST"
+	        _complete_git_maintain_branch
+			;;
+	esac;
+}
+
+_git_maintain_merge()
+{
+   local OPT_LIST=$(_git_maintain_genoptlist git maintain merge)
+    _get_comp_words_by_ref cur
+
+    case "$prev" in
+		-m|--merge)
+			__gitcomp_nl "$(git maintain list_suffixes)"
+			;;
+		*)
+			__gitcomp_nl "$OPT_LIST"
+	        _complete_git_maintain_branch
+			;;
+	esac;
+}
+
+_git_maintain(){
+	local direct_call=${1:-1}
+	local cmd_word=$(expr $direct_call + 1)
+
+	__git_has_doubledash && return
+
+	_get_comp_words_by_ref cur
+	_get_comp_words_by_ref prev
+	_get_comp_words_by_ref cword
+
+
+	if [ $cword -eq $cmd_word ]; then
+		case "$cur" in
+			-*)
+				__gitcomp_nl "$(_git_maintain_genoptlist git maintain)"
+				return
+				;;
+			*)
+				__gitcomp_nl "$(git maintain list_actions | grep -v list_actions)"
+				return
+				;;
+		esac
+    else
+		_get_comp_words_by_ref words
+		local cmd_name=${words[$cmd_word]}
+		completion_func="_git_maintain_${cmd_name}"
+		declare -f $completion_func > /dev/null
+		 if [ $? -eq 0 ]; then
+			 $completion_func
+		 else
+			 OPT_LIST=$(_git_maintain_genoptlist git maintain $cmd_name)
+			 case "$prev" in
+				 *)
+					__gitcomp_nl "$OPT_LIST"
+			 esac
+		 fi
+	fi
+
+}
+
+__git_maintain(){
+	_git_maintain 0
+} && complete -F __git_maintain git-maintain

data/lib/addons/RDMACore.rb

@@ -0,0 +1,61 @@
+module GitMaintain
+    class RDMACoreBranch < Branch
+        REPO_NAME = "rdma-core"
+
+        def release(opts)
+            prev_ver=@repo.runGit("show HEAD:CMakeLists.txt  | egrep \"[sS][eE][tT]\\\\(PACKAGE_VERSION\"").
+                         chomp().gsub(/[sS][eE][tT]\(PACKAGE_VERSION\s*"([0-9.]*)".*$/, '\1')
+            ver_nums = prev_ver.split(".")
+            new_ver =  (ver_nums[0 .. -2] + [ver_nums[-1].to_i() + 1 ]).join(".")
+            git_prev_ver = "v" + (ver_nums[-1] == "0" ? ver_nums[0 .. -2].join(".") : prev_ver)
+
+            puts "Preparing release #{prev_ver} => #{new_ver}"
+            rep = GitMaintain::checkLog(opts, @local_branch, git_prev_ver, "release")
+            if rep != "y" then
+                puts "Skipping release"
+                return
+            end
+
+            # Prepare tag message
+            tag_path=`mktemp`.chomp()
+            puts tag_path
+            tag_file = File.open(tag_path, "w+")
+            tag_file.puts "rdma-core-#{new_ver}:"
+            tag_file.puts ""
+            tag_file.puts "Updates from version #{prev_ver}"
+            tag_file.puts " * Backport fixes:"
+            tag_file.puts `git log HEAD ^#{git_prev_ver} --format='   * %s'`
+            tag_file.close()
+
+            # Update version number in relevant files
+            @repo.run("sed -i -e 's/\\(Version:[[:space:]]*\\)[0-9.]*/\\1#{new_ver}/g' redhat/rdma-core.spec suse/rdma-core.spec")
+            @repo.run("sed -i -e 's/\\([sS][eE][tT](PACKAGE_VERSION[[:space:]]*\"\\)[0-9.]*\"/\\1#{new_ver}\"/g' CMakeLists.txt")
+
+            @repo.run("cat <<EOF > debian/changelog.new
+rdma-core (#{new_ver}-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- $(git config user.name) <$(git config user.email)>  $(date '+%a, %d %b %Y %T %z')
+
+$(cat debian/changelog)
+EOF
+mv debian/changelog.new debian/changelog")
+
+            # Add and commit
+            @repo.runGit("add  redhat/rdma-core.spec suse/rdma-core.spec CMakeLists.txt debian/changelog")
+            @repo.runGit("commit -m 'Bump to version #{new_ver}' --verbose --edit --signoff")
+            if $? != 0 then
+                raise("Failed to commit on branch #{local_branch}")
+            end
+            @repo.runGit("tag -a -s v#{new_ver} --edit -F #{tag_path}")
+            if $? != 0 then
+                raise("Failed to tag branch #{local_branch}")
+            end
+            `rm -f #{tag_path}`
+        end
+    end
+
+    GitMaintain::registerCustom(RDMACoreBranch::REPO_NAME,
+                                { GitMaintain::Branch => RDMACoreBranch })
+end

data/lib/branch.rb

@@ -0,0 +1,460 @@
+module GitMaintain
+
+    class CherryPickErrorException < StandardError
+        def initialize(str, commit)
+            @commit = commit
+            super(str)
+        end
+        attr_reader :commit
+    end
+
+    class Branch
+        ACTION_LIST = [
+            :cp, :steal, :list, :merge,
+            :push, :monitor,
+            :push_stable, :monitor_stable,
+            :release, :reset
+        ]
+        NO_FETCH_ACTIONS = [
+            :cp, :merge, :monitor, :release
+        ]
+        NO_CHECKOUT_ACTIONS = [
+            :list, :push, :monitor, :monitor_stable
+        ]
+        ACTION_HELP = [
+            "* cp: Backport commits and eventually push them to github",
+            "* 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",
+            "* 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",
+            "* push_stable: Push to stable repo",
+            "* monitor_stable: Check the travis state of all stable branches",
+            "* release: Create new release on all concerned branches",
+            "* reset: Reset branch against upstream",
+        ]
+
+        def self.load(repo, version, travis, branch_suff)
+            repo_name = File.basename(repo.path)
+            return GitMaintain::loadClass(Branch, repo_name, repo, version, travis, branch_suff)
+        end
+
+        def self.set_opts(action, optsParser, opts)
+            opts[:base_ver] = 0
+            opts[:version] = /.*/
+            opts[:commits] = []
+            opts[:do_merge] = false
+            opts[:push_force] = false
+            opts[:no_travis] = 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}
+
+            case action
+            when :cp
+                optsParser.banner += "-c <sha1> [-c <sha1> ...]"
+                optsParser.on("-c", "--sha1 [SHA1]", String, "Commit to cherry-pick. Can be used multiple time.") {
+                    |val| opts[:commits] << val}
+            when :merge
+                optsParser.banner += "-m <suffix>"
+                optsParser.on("-m", "--merge [SUFFIX]", "Merge branch with suffix.") {
+                    |val| opts[:do_merge] = val}
+            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
+                optsParser.banner += "[-T]"
+                optsParser.on("-T", "--no-travis", "Ignore Travis build status and push anyway.") {
+                    |val| opts[:no_travis] = val}
+            end
+        end
+
+        def self.check_opts(opts)
+            if opts[:action] == :push_stable ||
+               opts[:action] == :release then
+                if opts[:br_suff] != "master" then
+                    raise "Action #{opts[:action]} can only 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
+                repo.stableUpdate()
+            end
+
+            repo.getStableList(opts[:br_suff]).each(){|br|
+                branch = Branch::load(repo, br, travis, opts[:br_suff])
+                case branch.is_targetted?(opts)
+                when :too_old
+                    puts "# Skipping older v#{branch.version}"
+                    next
+                when :no_match
+                    puts "# Skipping v#{branch.version} not matching #{opts[:version].to_s()}"
+                    next
+                end
+
+                puts "###############################"
+                puts "# Working on v#{branch.version}"
+                puts "###############################"
+
+                if NO_CHECKOUT_ACTIONS.index(action) == nil  then
+                    branch.checkout()
+                end
+                branch.send(action, opts)
+            }
+        end
+
+        def initialize(repo, version, travis, branch_suff)
+            GitMaintain::checkDirectConstructor(self.class)
+
+            @repo          = repo
+            @version       = version
+            @travis        = travis
+            @branch_suff   = branch_suff
+
+            @local_branch  = "dev/stable-v#{@version}/#{@branch_suff}"
+            @head          = @repo.runGit("rev-parse #{@local_branch}")
+
+            @remote_branch ="stable-v#{@version}"
+            @remote_ref    = "#{Repo::STABLE_REPO}/#{@remote_branch}"
+            @stable_head   = @repo.runGit("rev-parse #{@remote_ref}")
+            @stable_base   = @repo.findStableBase(@local_branch)
+        end
+        attr_reader :version, :local_branch, :head, :remote_branch, :remote_ref, :stable_head
+
+        def is_targetted?(opts)
+            if @version.to_i < opts[:base_ver] then
+                return :too_old
+            end
+            if @version !~ opts[:version] then
+                return :no_match
+            end
+            return true
+        end
+
+        # 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"
+            end
+        end
+
+        # Cherry pick an array of commits
+        def cherry_pick(opts)
+            if opts[:commits].length > 0 then
+                @repo.runGit("cherry-pick #{opts[:commits].join(" ")}")
+                if $? != 0 then
+                    puts "Cherry pick failure. Starting bash for manual fixes. Exit shell to continue"
+			        @repo.runSystem("bash")
+                    puts "Continuing..."
+		        end
+            end
+        end
+
+        # Steal upstream commits that are not in the branch
+        def steal(opts)
+             steal_all(opts, "#{@stable_base}..origin/master")
+        end
+
+        # List commits in the branch that are no in the stable branch
+        def list(opts)
+         GitMaintain::checkLog(opts, @local_branch, @remote_ref, nil)
+        end
+
+        # Merge merge_branch into this one
+        def merge(opts)
+            merge_branch = "dev/stable-v#{@version}/#{opts[:do_merge]}"
+            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..."
+		        end
+            else
+                puts "Skipping merge"
+                return
+            end 
+        end
+
+        # Push the branch to the validation repo
+        def push(opts)
+           @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"
+                rep = "y"
+                suff=""
+                while rep == "y"
+                    rep = GitMaintain::confirm(opts, "see the build log#{suff}")
+                    if rep == "y" then
+                        log = @travis.getValidLog(head)
+                        tmp = `mktemp`.chomp()
+                        tmpfile = File.open(tmp, "w+")
+                        tmpfile.puts(log)
+                        tmpfile.close()
+                        system("less -r #{tmp}")
+                        `rm -f #{tmp}`
+                    end
+                    suff=" again"
+                end
+            end
+        end
+
+        # Push branch to the stable repo
+        def push_stable(opts)
+            if opts[:no_travis] != true &&
+               @travis.checkValidState(@head) != true then
+                puts "Build is not passed on travis. Skipping push to stable"
+                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"
+                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)
+        end
+
+        # Reset the branch to the upstream stable one
+        def reset(opts)
+            rep = GitMaintain::checkLog(opts, @local_branch, @remote_ref, "reset")
+            if rep == "y" then
+                @repo.runGit("reset --hard #{@remote_ref}")
+            else
+                puts "Skipping reset"
+                return
+            end
+        end
+
+        def release(opts)
+            puts "#No release command available for this repo"
+        end
+
+        private
+        def add_blacklist(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
+            }
+            return false
+        end
+
+        def make_pretty(orig_commit, commit="")
+            orig_sha=@repo.runGit("rev-parse #{orig_commit}")
+            msg_commit = (commit.to_s() == "") ? orig_sha : commit
+
+            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.close()
+	        @repo.runGit("commit -s --amend -F #{msg_path}")
+            `rm -f #{msg_path}`
+        end
+
+        def is_in_tree?(commit)
+	        fullhash=@repo.runGit("rev-parse #{commit}")
+	        # This might happen if someone pointed to a commit that doesn't exist in our
+	        # tree.
+	        if $? != 0 then
+		        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.runGit("log -1 --pretty=\"%s\" #{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}\" "+
+                         "#{@stable_base}..HEAD").split("\n").each(){|cmt|
+                cursubj=@repo.runGit("log -1 --format=\"%s\" #{cmt}")
+                if cursubj = subj then
+	                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 | "+
+                                  "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) then
+                      return true
+                  else
+                      return false
+                  end
+            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(/.* /, "")
+
+	        # Sanity check our extraction
+            if full =~ /stable/ then
+                return false
+            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
+        end
+
+        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
+			    @repo.runGit("reset --hard")
+			    return
+		    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")
+			    if $? == 0 then
+				    return
+			    end
+			    @repo.runCmd("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")
+            raise CherryPickErrorException.new("Failed to cherry pick commit #{commit}", commit)
+	        return false
+        end
+
+        def confirm_one(opts, commit)
+ 		    rep=""
+		    do_cp=false
+		    puts @repo.runGit("show --format=oneline --no-patch --no-decorate #{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"
+                    rep = 'n'
+                    break
+                else
+                    rep = STDIN.gets.chomp()
+                end
+			    case rep
+				when "n"
+			        puts "Skip this commit"
+					break
+				when "b"
+					puts "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
+					STDERR.puts "Invalid answer $rep"
+		            puts @repo.runGit("show --format=oneline --no-patch --no-decorate #{commit}")
+                end
+		    end
+            return do_cp
+        end
+
+        def steal_one(opts, commit)
+		    subj=@repo.runGit("log -1 --format=\"%s\" #{commit}")
+		    msg=''
+
+		    # 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 the commit doesn't apply for us, skip it
+		    if is_relevant?(orig_cmt) != true
+                return
+		    end
+
+		    if is_in_tree?(orig_cmt) == true
+		        # Commit is already in the stable branch, skip
+                return
+		    end
+
+		    # 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}")
+                return
+		    end
+
+            do_cp = confirm_one(opts, orig_cmt)
+            return if do_cp != true
+
+            begin
+		        pick_one(commit)
+            rescue CherryPickErrorException => e
+			    puts "Cherry pick failed. Fix, commit (or reset) and exit."
+			    @repo.runSystem("/bin/bash")
+                return
+            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")
+			    puts "Custom commit, please double-check!"
+			    @repo.runSystem("/bin/bash")
+		    end
+		    make_pretty(orig_cmt, msg)
+        end
+
+        def steal_all(opts, range)
+ 	        @repo.runGit("log --no-merges --format=\"%H\" #{range} | tac").split("\n").each(){|commit|
+                steal_one(opts, commit)
+            }
+       end
+    end
+end

data/lib/common.rb

@@ -0,0 +1,123 @@
+$LOAD_PATH.push(BACKPORT_LIB_DIR)
+
+require 'travis'
+require 'repo'
+require 'branch'
+
+$LOAD_PATH.pop()
+
+module GitMaintain
+    class Common
+        ACTION_LIST = [ :list_actions ]
+        ACTION_HELP = []
+        def self.execAction(opts, action)
+            puts GitMaintain::getActionAttr("ACTION_LIST").join("\n")
+        end
+    end
+
+    ACTION_CLASS = [ Common, Branch, Repo ]
+    @@custom_classes = {}
+
+    def registerCustom(repo_name, classes)
+        raise("Multiple class for repo #{repo_name}") if @@custom_classes[repo_name] != nil
+        @@custom_classes[repo_name] = classes
+    end
+    module_function :registerCustom
+
+    def getCustom(repo_name)
+        return @@custom_classes[repo_name]
+    end
+    module_function :getCustom
+
+    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"
+            return custom[default_class].new(*more)
+        else
+            puts "# Detected NO custom #{default_class} classes for repo '#{repo_name}'" if ENV['DEBUG'] == "1"
+            return default_class.new(*more)
+        end
+    end
+    module_function :loadClass
+
+    # Check that the constructor was called through loadClass
+    def checkDirectConstructor(theClass)
+        # Look for the "new" in the calling tree
+        depth = 1
+        while caller_locations(depth, 1)[0].label != "new"
+            depth +=1
+        end
+        # The function that called the constructer is just one step below
+        raise("Use GitMaintain::loadClass to construct a #{theClass} class") if
+                caller_locations(depth + 1, 1)[0].label != "loadClass"
+    end
+    module_function :checkDirectConstructor
+
+    def getActionAttr(attr)
+        return ACTION_CLASS.map(){|x| x.const_get(attr)}.flatten()
+    end
+    module_function :getActionAttr
+
+    def setOpts(action, optsParser, opts)
+         ACTION_CLASS.each(){|x|
+            next if x::ACTION_LIST.index(action) == nil
+            next if x.singleton_methods().index(:set_opts) == nil
+            x.set_opts(action, optsParser, opts)
+            break
+        }
+    end
+    module_function :setOpts
+
+    def checkOpts(opts)
+        ACTION_CLASS.each(){|x|
+            next if x.singleton_methods().index(:check_opts) == nil
+            x.check_opts(opts)
+        }
+    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
+        }
+    end
+    module_function :execAction
+
+    def confirm(opts, msg)
+        rep = 't'
+        while rep != "y" && rep != "n" && rep != '' do
+            puts "Do you wish to #{msg} ? (y/N): "
+            if opts[:no] == true then
+                puts "Auto-replying no due to --no option"
+                rep = 'n'
+            else
+                rep = STDIN.gets.chomp()
+            end
+        end
+        return rep
+    end
+    module_function :confirm
+
+    def checkLog(opts, br1, br2, action_msg)
+        puts "Diff between #{br1} and #{br2}"
+        puts `git shortlog #{br1} ^#{br2}`
+        return "n" if action_msg.to_s() == ""
+        rep = confirm(opts, "#{action_msg} this branch")
+        return rep
+    end
+    module_function :checkLog
+
+end
+$LOAD_PATH.pop()
+
+
+# Load all custom classes
+$LOAD_PATH.push(BACKPORT_LIB_DIR + "/addons/")
+Dir.entries(BACKPORT_LIB_DIR + "/addons/").each(){|entry|
+    next if (!File.file?(BACKPORT_LIB_DIR + "/addons/" + entry) || entry !~ /\.rb$/ );
+    require entry.sub(/.rb$/, "")
+}
+$LOAD_PATH.pop()

data/lib/repo.rb

@@ -0,0 +1,182 @@
+module GitMaintain
+    class Repo
+        VALID_REPO = "github"
+        STABLE_REPO = "stable"
+        SUBMIT_BINARY="/usr/bin/git-release.ruby2.5"
+
+        ACTION_LIST = [
+            :list_branches,
+            # Internal commands for completion
+            :list_suffixes, :submit_release
+        ]
+        ACTION_HELP = [
+            "* submit_release: Push the to stable and create the release packages",
+        ]
+
+        def self.load(path=".")
+            dir = Dir.pwd()
+            repo_name = File.basename(dir)
+            return GitMaintain::loadClass(Repo, repo_name, dir)
+        end
+
+        def self.check_opts(opts)
+            if opts[:action] == :submit_release then
+                if opts[:br_suff] != "master" then
+                    raise "Action #{opts[:action]} can only be done on 'master' suffixed branches"
+                end
+            end
+        end
+
+        def self.execAction(opts, action)
+            repo   = Repo::load()
+
+            if action == :submit_release then
+                repo.stableUpdate()
+            end
+            repo.send(action, opts)
+        end
+
+        def initialize(path=nil)
+            GitMaintain::checkDirectConstructor(self.class)
+
+            @path = path
+            @stable_list=nil
+            @stable_branches=nil
+            @suffix_list=nil
+
+            if path == nil
+                @path = Dir.pwd()
+            end
+            @remote_valid=runGit("remote -v | egrep '^#{VALID_REPO}' | grep fetch |
+                                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//'")
+            @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
+
+        def run(cmd)
+            return `cd #{@path} && #{cmd}`
+        end
+        def runSystem(cmd)
+            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
+            return `git --work-tree=#{@path} #{cmd}`.chomp()
+        end
+        def runGitImap(cmd)
+            return `export GIT_ASKPASS=$(dirname $(dirname $(which git)))/lib/git-core/git-gui--askpass;
+                  if [ ! -f $GIT_ASKPASS ]; then
+                  	export GIT_ASKPASS=$(dirname $(which git))/git-gui--askpass;
+                  fi;
+                  if [ ! -f $GIT_ASKPASS ]; then
+                  	export GIT_ASKPASS=/usr/lib/ssh/ssh-askpass;
+                  fi; git --work-tree=#{@path} imap-send #{cmd}`
+        end
+
+        def stableUpdate()
+            puts "# Fetching stable updates..."
+            runGit("fetch #{STABLE_REPO}")
+        end
+        def getStableList(br_suff)
+            return @stable_list if @stable_list != 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()
+
+            return @stable_list
+        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()
+
+            return @suffix_list
+        end
+
+        def submitReleases()
+            remote_tags=runGit("ls-remote --tags #{STABLE_REPO} |
+                                 egrep 'refs/tags/v[0-9.]*$'").split("\n").map(){
+                |x| x.gsub(/.*refs\/tags\//, '')
+            }
+            local_tags =runGit("tag -l | egrep '^v[0-9.]*$'").split("\n")
+
+            new_tags = local_tags - remote_tags
+            if new_tags.empty? then
+                puts "All tags are already submitted."
+                #                return
+            end
+
+            puts "This will officially release these tags: #{new_tags.join(", ")}"
+            rep = GitMaintain::confirm("release them")
+            if rep != 'y' then
+                raise "Aborting.."
+            end
+
+            mail_path=`mktemp`.chomp()
+            mail = File.open(mail_path, "w+")
+            mail.puts "From " + runGit("rev-parse HEAD") + " " + `date`.chomp()
+            mail.puts "From: " + runGit("config user.name") +
+                      " <" + 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"
+            mail.puts ""
+            mail.puts "Here's the information from the tags:"
+            new_tags.sort().each(){|tag|
+                mail.puts `git show #{tag} --no-decorate -q | awk '!p;/^-----END PGP SIGNATURE-----/{p=1}'`
+                mail.puts ""
+            }
+            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.close()
+
+            puts runGitImap("< #{mail_path}; rm -f #{mail_path}")
+
+            puts "Last chance to cancel before submitting"
+            rep= GitMaintain::confirm("submit these releases")
+            if rep != 'y' then
+                raise "Aborting.."
+            end
+            puts `#{SUBMIT_BINARY}`
+        end
+        def findStableBase(branch)
+            @stable_base_patterns.each(){|pattern, base|
+                return base if branch =~ /#{pattern}\//
+            }
+            raise("Could not a find a stable base for branch #{branch}")
+        end
+
+        def list_branches(opts)
+            puts getStableList(opts[:br_suff])
+        end
+        def list_suffixes(opts)
+            puts getSuffixList()
+        end
+        def submit_release(opts)
+            submitReleases()
+        end
+    end
+end

data/lib/travis.rb

@@ -0,0 +1,105 @@
+module GitMaintain
+    class TravisChecker
+        TRAVIS_URL='https://api.travis-ci.org/'
+
+        def self.load(repo)
+            repo_name = File.basename(repo.path)
+            return GitMaintain::loadClass(TravisChecker, repo_name, repo)
+        end
+
+        def initialize(repo)
+            GitMaintain::checkDirectConstructor(self.class)
+
+            @repo = repo
+            @cachedJson={}
+        end
+
+        private
+        def fetch(uri_str, limit = 10)
+            # You should choose a better exception.
+            raise ArgumentError, 'too many HTTP redirects' if limit == 0
+
+            response = Net::HTTP.get_response(URI(uri_str))
+
+            case response
+            when Net::HTTPSuccess then
+                response
+            when Net::HTTPRedirection then
+                location = response['location']
+                fetch(location, limit - 1)
+            else
+                response.value
+            end
+        end
+        def getJson(query_label, query, json=true)
+            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() != ""
+            response = fetch(uri)
+            raise("Travis request failed '#{url}'") if response.code.to_s() != '200'
+
+            if json == true
+                @cachedJson[query_label] = JSON.parse(response.body)
+            else
+                @cachedJson[query_label] = response.body
+            end
+            return @cachedJson[query_label]
+        end
+        def getState(sha1, resp)
+            br = findBranch(sha1, resp)
+            return "not found" if br == nil
+
+            return br["state"]
+        end
+        def getLog(sha1, resp)
+            br = findBranch(sha1, resp)
+            raise("Travis build not found") if br == nil
+            job_id = br["job_ids"].last().to_s()
+            return getJson("log_" + job_id, 'jobs/' + job_id + '/log', false)
+        end
+        def checkState(sha1, resp)
+            return getState(sha1, resp) == "passed"
+        end
+
+        def getBrValidJson()
+            return getJson(:br_valid, 'repos/' + @repo.remote_valid + '/branches')
+        end
+        def getBrStableJson()
+            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() != ""
+            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() != ""
+                next if commit["sha"] != sha1
+                return br
+            }
+            return nil
+        end
+
+        public
+        def getValidState(sha1)
+            return getState(sha1, getBrValidJson())
+        end
+        def checkValidState(sha1)
+            return checkState(sha1, getBrValidJson())
+        end
+        def getValidLog(sha1)
+            return getLog(sha1, getBrValidJson())
+        end
+
+        def getStableState(sha1)
+            return getState(sha1, getBrStableJson())
+        end
+        def checkStableState(sha1)
+            return checkState(sha1, getBrStableJson())
+        end
+        def getStableLog(sha1)
+            return getLog(sha1, getBrStableJson())
+        end
+    end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: git-maintain
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Nicolas Morey-Chaisemartin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-13 00:00:00.000000000 Z
+dependencies: []
+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.
+email: nmoreychaisemartin@suse.de
+executables:
+- git-maintain
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/git-maintain
+- git-maintain-completion.sh
+- lib/addons/RDMACore.rb
+- lib/branch.rb
+- lib/common.rb
+- lib/repo.rb
+- lib/travis.rb
+homepage: https://github.com/nmorey/git-maintain
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Your ultimate script for maintaining stable branches.
+test_files: []