git-prepare-branch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d820e9fda828430f381da9a0173811a060e2c73
+  data.tar.gz: 27d972cc3a0993b61e6479a312eebf0f8d628e94
+SHA512:
+  metadata.gz: b2ffc9dd90b096e11080164a6f31db67b9fa4f6bcb8023ae69b38d1c7241108857dafc46248163a195480626ab1c7a2c9cb44614e9195c5537e1a929519d7421
+  data.tar.gz: 3565a768eae5d3387864727057cdcc3925eace47b57f34f8db568a1729fb58b3da6528f8de2b4e0a0def4ca36adbb0de50eb4cc00c7970a16bf680be3694b61a

data/README.md

@@ -0,0 +1,70 @@
+# git-prepare-branch
+
+This tool is for developers who prefer to use interactive rebasing to prepare
+their branches for code review and merging. It provides a wrapper around some
+git commands along with shortcut keys.
+
+## Installation
+
+Currently installation is via rubygems
+
+```
+gem install git-prepare-branch
+```
+
+## Usage
+
+With your feature branch checked out and assuming you are merging into master
+
+```
+git prepare-branch
+```
+
+If you are merging into another branch run
+
+```
+git prepare-branch some-other-branch
+```
+
+You will then see a log of all the commits to be merged.
+
+Pressing `?` will bring up a list of the available command keys. They array_to_sentence_string
+
+```
+f   filter files     Filters commits to just those affected files that match the specified filter
+
+r   begin rebase     Start an interactive rebase
+
+s   show             Show a specific commit
+
+d   sum diff         Show the combined diff from one SHA to another (inclusive)
+
+v   cycle view       Cycles through applying different view options to the list of commits
+```
+
+If you pause mid rebase - for example if you have chosen to edit a commit - there are a different set of commands available
+
+```
+a   abort rebase        Abort the current rebase
+
+c   continue rebase     Continue with the current rebase
+```
+
+If you pause mid rebase and there are conflicts detected, another set of commands are available
+
+```
+a   abort rebase           Abort the current rebase
+
+m   show my changes        Show the diff of the content in this branch causing the conflict
+
+t   show other commits     Show the commits that may have introduced the conflicting changes
+
+o   show other diff        Show the combined diff of the commits that may have introduced the change
+
+d   show diff              Show the diff of the conflicts
+```
+
+## What are the actual git commands being run?
+
+The entire set of commands are defined in [bin/git-prepare-branch](bin/git-prepare-branch).
+The rest of the code in the application is to allow for the interface and the declarative DSL.

data/bin/git-prepare-branch

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/git-prepare-branch'
+
+LOG_FILE = ENV['LOG']
+
+if LOG_FILE
+  logger = GitPrepareBranch::Logger.new(
+    stream: IO.new(IO.sysopen(LOG_FILE, 'a+'))
+  )
+else
+  logger = GitPrepareBranch::NullLogger.new
+end
+
+onto = ARGV[0] || 'master'
+
+VIEWS = [
+  'log --oneline --decorate --reverse ',
+  'log --oneline --decorate --reverse --stat --name-only',
+  'log --oneline --decorate --reverse --stat',
+  'diff --stat',
+  'diff --dirstat'
+]
+
+GitPrepareBranch::App.configure(logger: logger) do
+  on :load do
+    variable :view, value: VIEWS[0]
+    variable :file_filter
+    variable :current_branch, capture: 'git rev-parse --abbrev-ref HEAD'
+    variable :prefix, capture: 'git rev-parse --show-prefix'
+    variable :num_commits, capture: 'git rev-list --count %{onto}..'
+    variable :num_files, capture: 'git diff --name-only %{onto}.. | wc -l'
+  end
+
+  on :display do
+    variable :mid_rebase?,
+      value: ->(context) {
+        context.terminal.capture(
+          'if test -d "$(git rev-parse --git-path rebase-merge)" || test -d "$(git rev-parse --git-path rebase-apply)"; then echo 1; fi'
+        ).strip == '1'
+      }
+
+    variable :conflicts?,
+      value: ->(context) {
+        !context.terminal.capture("git status -s | grep -e '^UU'").strip.empty?
+      }
+  end
+
+  screen :default do
+    heading '❯ %{current_branch} => %{onto} - %{num_commits} commits, %{num_files} files', style: :header
+    display 'git %{view} %{onto}.. *%{file_filter}*'
+    description "prepare-branch\n\nPrepare a branch for rebasing"
+
+    command 'f', 'filter files',
+      -> (context, inputs) {
+        context.variables[:file_filter] = inputs[:file_filter]
+      },
+      description: 'Filters commits to just those affected files that match the specified filter',
+      input: {
+        file_filter: {
+          prompt: 'Enter a file pattern',
+          autocomplete_strategy: :file
+        }
+      }
+
+    command 'r', 'begin rebase',
+      'git rebase -i %{onto}',
+      description: 'Start an interactive rebase'
+
+    command 's', 'show',
+      'git show %{sha}',
+      input: {
+        sha: {
+          prompt: 'Enter a sha',
+          autocomplete_strategy: :sha
+        }
+      },
+      description: 'Show a specific commit',
+      prompt_to_continue: true
+
+    command 'd', 'sum diff',
+      'git diff -w --find-renames --find-copies --patience %{start_sha}~...%{end_sha}',
+      input: {
+        start_sha: {
+          prompt: 'Enter the starting sha',
+          autocomplete_strategy: :sha
+        },
+        end_sha: {
+          prompt: 'Enter the end sha',
+          autocomplete_strategy: :sha
+        }
+      },
+      description: 'Show the combined diff from one sha to another (inclusive)',
+      prompt_to_continue: true
+
+    command 'D', 'entire diff',
+      'git diff -w --find-renames --find-copies --patience %{onto}..',
+      description: 'Show the entire combined diff as if the branch was squashed into a single commit',
+      prompt_to_continue: true
+
+    command 'v', 'cycle view',
+      -> (context, _) {
+        context.variables[:view] = VIEWS[(VIEWS.index(context.variables[:view]) + 1) % VIEWS.length]
+      },
+      description: 'Cycles through applying different view options to the list of commits'
+
+    command 'V', 'cycle view (reverse)',
+      -> (context, _) {
+        context.variables[:view] = VIEWS[(VIEWS.index(context.variables[:view]) - 1) % VIEWS.length]
+      },
+      description: 'Cycles back through applying different view options to the list of commits (reverse of v)'
+
+  end
+
+  screen :mid_rebase do
+    heading '❯ Rebasing %{current_branch} onto %{onto} (paused)', style: :header_ok
+    display 'git show --stat'
+    description "prepare-branch - mid rebase"
+
+    command 'a', 'abort rebase', 'git rebase --abort', description: 'Abort the current rebase'
+    command 'c', 'continue rebase', 'git rebase --continue', description: 'Continue with the current rebase'
+  end
+
+  screen :conflicts do
+    heading '❯ Conflicts rebasing %{current_branch} onto %{onto}', style: :header_warning
+    display 'git status -s'
+    description "prepare-branch - conflicts"
+
+    command 'a', 'abort rebase', 'git rebase --abort', description: 'Abort the current rebase'
+
+    command 'm', 'show my changes',
+      'git diff --name-only --diff-filter=U --relative=%{prefix} | xargs git show $(< $(git rev-parse --git-path rebase-merge/stopped-sha)) --oneline',
+      description: 'Show the diff of the content in this branch causing the conflict',
+      prompt_to_continue: true
+
+    command 't', 'show other commits',
+      'git diff --name-only --relative=%{prefix} --diff-filter=U | xargs git log $(git merge-base HEAD $(< $(git rev-parse --git-path rebase-merge/stopped-sha)))... --oneline',
+      description: 'Show the commits that may have introduced the conflicting changes',
+      prompt_to_continue: true
+
+    command 'o', 'show other diff',
+      'git diff --name-only --relative=%{prefix} --diff-filter=U | xargs git diff $(git merge-base HEAD $(< $(git rev-parse --git-path rebase-merge/stopped-sha)))...',
+      description: 'Show the combined diff of the commits that may have introduced the change',
+      prompt_to_continue: true
+
+    command 'd', 'show diff',
+      'git diff',
+      description: 'Show the diff of the conflicts',
+      prompt_to_continue: true
+  end
+
+  routing -> (context) {
+    if context.variables.mid_rebase?
+      return :conflicts if context.variables.conflicts?
+      return :mid_rebase
+    end
+    :default
+  }
+end.start(
+  onto: { value: onto }
+)

data/lib/git-prepare-branch.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'git-prepare-branch/app'
+require_relative 'git-prepare-branch/command'
+require_relative 'git-prepare-branch/configurator'
+require_relative 'git-prepare-branch/context'
+require_relative 'git-prepare-branch/logger'
+require_relative 'git-prepare-branch/null_logger'
+require_relative 'git-prepare-branch/screen'
+require_relative 'git-prepare-branch/styles'
+require_relative 'git-prepare-branch/terminal'
+require_relative 'git-prepare-branch/variable'

data/lib/git-prepare-branch/app.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+require_relative 'logger'
+require_relative 'configurator'
+require_relative 'context'
+require_relative 'terminal'
+require_relative 'variable'
+
+module GitPrepareBranch
+  class App
+    attr_reader :logger
+
+    attr_accessor :title, :router
+
+    def initialize(logger: nil)
+      @logger = logger || Logger.new
+    end
+
+    def add_event_handler(event, &block)
+      event_handlers[event] ||= []
+      event_handlers[event] << block
+    end
+
+    def add_screen screen
+      screen.context = context
+      screens[screen.name] = screen
+    end
+
+    def add_variable name, capture: nil, value: nil
+      context.variables[name] = Variable.new(name, context: context, capture: capture, value: value).value
+    end
+
+    def configure(&block)
+      Configurator.new(self).apply(&block)
+      self
+    end
+
+    def context
+      @context ||= Context.new(
+        terminal: terminal,
+        variables: {}
+      )
+    end
+
+    def current_screen
+      screens[current_screen_name]
+    end
+
+    def current_screen_name
+      router.call(context)
+    end
+
+    def screens
+      @screens ||= {}
+    end
+
+    def start(variables = [])
+      variables.each { |name, args| add_variable(name, args) }
+      trigger :load
+      while true do
+        begin
+          terminal.clear
+          trigger :display
+          terminal.write_line format(current_screen.heading, context.variables.to_h), current_screen.heading_style
+          terminal.call current_screen.display, context.variables.to_h
+          terminal.say 'Press a command key or ? for help', :hint
+          begin
+            result = terminal.wait_for_keypress
+            current_screen.handle_keypress result, context
+          rescue Interrupt
+          end
+        rescue Interrupt
+          exit
+        end
+      end
+    end
+
+    def terminal
+      @terminal ||= Terminal.new(logger: logger)
+    end
+
+    def trigger event
+      return unless event_handlers[event]
+
+      event_handlers[event].each do |block|
+        block.call(context)
+      end
+    end
+
+    class << self
+      def configure(*options, &block)
+        self.new(*options).configure(&block)
+      end
+    end
+
+    private
+
+    def event_handlers
+      @event_handlers ||= {}
+    end
+  end
+end

data/lib/git-prepare-branch/command.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module GitPrepareBranch
+  class Command
+    attr_reader :key, :name, :command, :options
+
+    def initialize(key, name, command, options={})
+      @key = key
+      @name = name
+      @command = command
+      @options = options
+    end
+
+    def call(context)
+      inputs = capture_inputs(context)
+      run_proc(context, inputs) if command.is_a?(Proc)
+      run_as_shell_command(context, inputs) if command.is_a?(String)
+      context.terminal.prompt_to_continue if options[:prompt_to_continue]
+    end
+
+    def description
+      options[:description]
+    end
+
+    private
+
+    def capture_inputs(context)
+      return {} unless options[:input]
+      options[:input].each_with_object({}) do |(key, value), object|
+        object[key] = context.terminal.ask value[:prompt], autocomplete_strategy: [value[:autocomplete_strategy], context.variables]
+      end
+    end
+
+    def run_as_shell_command(context, inputs)
+      context.terminal.call format(
+        command,
+        context.variables.to_h.merge(inputs)
+      )
+    end
+
+    def run_proc(context, inputs)
+      command.call(context, inputs)
+    end
+  end
+end

data/lib/git-prepare-branch/command_keys.rb

@@ -0,0 +1,6 @@
+module GitPrepareBranch
+  class CommandKeys
+    CTRL_C = "\u0003"
+    CTRL_D = "\u0004"
+  end
+end

data/lib/git-prepare-branch/configurator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'screen'
+
+module GitPrepareBranch
+  class Configurator
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def apply(&block)
+      instance_exec(&block)
+    end
+
+    def on(event, &block)
+      app.add_event_handler event, &block
+    end
+
+    def routing(routes)
+      @app.router = routes
+    end
+
+    def screen(name, &block)
+      app.add_screen ScreenDSL.new(Screen.new(name)).apply(&block).screen
+    end
+
+    def title(value)
+      app.title = value
+    end
+
+    def variable(name, capture: nil, value: nil)
+      app.add_variable name, capture: capture, value: value
+    end
+
+    class ScreenDSL
+      attr_reader :screen
+
+      def initialize(screen)
+        @screen = screen
+      end
+
+      def apply(&block)
+        self.tap do |s|
+          instance_exec(&block)
+        end
+      end
+
+      def command(*args)
+        screen.add_command(*args)
+      end
+
+      def description(value)
+        screen.description = value
+      end
+
+      def display(command)
+        screen.display = command
+      end
+
+      def heading(message, options={})
+        screen.heading = message
+        screen.heading_style = options[:style]
+      end
+
+      def title(value)
+        screen.title = value
+      end
+    end
+  end
+end

data/lib/git-prepare-branch/context.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module GitPrepareBranch
+  class Context
+    attr_reader :terminal, :variables
+
+    def initialize(terminal:, variables:)
+      @terminal = terminal
+      @variables = OpenStruct.new(variables)
+    end
+  end
+end

data/lib/git-prepare-branch/logger.rb

@@ -0,0 +1,20 @@
+module GitPrepareBranch
+  class Logger
+    def initialize(stream: $stdout)
+      @stream = stream
+    end
+
+    def log message
+      stream << format_message(message)
+      stream.flush
+    end
+
+    private
+
+    attr_reader :stream
+
+    def format_message(message)
+      "#{Time.now}: #{message}\n"
+    end
+  end
+end

data/lib/git-prepare-branch/null_logger.rb

@@ -0,0 +1,6 @@
+module GitPrepareBranch
+  class NullLogger
+    def initialize(stream:nil); end
+    def log(message); end
+  end
+end

data/lib/git-prepare-branch/screen.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative 'command_keys'
+
+module GitPrepareBranch
+  class Screen
+    attr_reader :name, :context
+    attr_accessor :context, :title, :heading, :heading_style, :description, :display
+
+    def initialize(name)
+      @name = name
+    end
+
+    def add_command(key, name, command, options={})
+      commands[key] = Command.new(key, name, command, options)
+    end
+
+    def commands
+      @commands ||= {}
+    end
+
+    def handle_keypress key, context
+      help if ['h', '?'].include?(key)
+      exit if ['q', CommandKeys::CTRL_C, CommandKeys::CTRL_D].include?(key)
+      return unless commands.keys.include?(key)
+      commands[key].call(context)
+    end
+
+    def help
+      terminal.clear
+      terminal.say "DESCRIPTION"
+      terminal.hr
+      terminal.say "#{description}\n\n"
+      terminal.say "COMMANDS"
+      terminal.hr
+      commands.each_with_object('') do |(key, command), result|
+        terminal.say "#{key}   #{command.name.ljust(longest_command_name_length)}     #{command.description}"
+        terminal.say "\n"
+      end
+      terminal.prompt_to_continue
+    end
+
+    def longest_command_name_length
+      @longest_command_name_length ||= commands.collect{|(_, c)| c.name.length}.max
+    end
+
+    private
+
+    def terminal
+      context.terminal
+    end
+  end
+end

data/lib/git-prepare-branch/styles.rb

@@ -0,0 +1,48 @@
+require 'rainbow'
+
+module GitPrepareBranch
+  class Styles
+    def initialize(styler: nil)
+      @styler = styler || Rainbow.global.method(:wrap)
+    end
+
+    def apply(text, style = :default)
+      return text if style == :default
+      send(style, text)
+    end
+
+    def bold(text)
+      style(text).bright
+    end
+
+    def footer(text)
+      style(text).color(:dimgray)
+    end
+
+    def header(text)
+      style(text).color(:white).bg(:darkslateblue)
+    end
+
+    def header_ok(text)
+      style(text).color(:white).bg(:darkgreen)
+    end
+
+    def header_warning(text)
+      style(text).color(:white).bg(:red)
+    end
+
+    def hint(text)
+      style(text).color(:dimgray)
+    end
+
+    alias hr footer
+
+    private
+
+    attr_reader :styler
+
+    def style(text)
+      styler.call(text)
+    end
+  end
+end

data/lib/git-prepare-branch/terminal.rb

@@ -0,0 +1,132 @@
+require 'readline'
+require 'io/console'
+
+require_relative 'styles'
+
+module GitPrepareBranch
+  class Terminal
+    CLEAR = 'clear'
+    DEFAULT_PROMPT = ' ❯ '
+    DEFAULT_WIDTH = 20
+    HR_CHARACTER = '─'
+    BLANK_CHARACTER = ' '
+    NUM_BLANK_LINES_BEFORE_PROMPT = 3
+
+    AUTOCOMPLETE_STRATEGIES = {
+      default: -> (_, _) {},
+      sha: -> (variables, s) {
+        `git rev-list #{variables[:onto]}...`
+          .split(/\n/)
+          .grep(/^#{s}/)
+      },
+      file: ->(variables, s) {
+        `git diff --name-only --relative=#{variables[:prefix]} #{variables[:onto]}...`
+          .split(/\n/)
+          .grep(/#{s}/)
+      }
+    }
+
+    def initialize(out: $stdout, err: $stderr, prompt: DEFAULT_PROMPT, logger: nil, styles: nil)
+      @out = out
+      @err = err
+      @prompt = prompt
+      @logger = logger || Logger.new
+      @styles = styles || Styles.new
+    end
+
+    def ask(question, autocomplete_strategy: :default)
+      set_autocomplete_strategy autocomplete_strategy
+      Readline.readline("#{question}#{prompt}", true).chomp.strip
+    end
+
+    def blank_lines(quantity = 1)
+      quantity.times { out.puts }
+    end
+
+    def call(command, values = {})
+      command = normalise_command(command, values)
+      logger.log "CMD: #{command}"
+      result = system command, out: out, err: err
+      logger.log "OUT: #{out}"
+      logger.log "ERR: #{err}"
+      result
+    end
+
+    def capture(command, values = {})
+      command = normalise_command(command, values)
+      logger.log "CAP: #{command}"
+      result = `#{command}`.chomp.strip
+      logger.log "OUT: #{result}"
+      result
+    end
+
+    def clear
+      call CLEAR
+    end
+
+    def enable_raw
+      system("stty raw -echo")
+    end
+
+    def hr
+      out.puts styles.hr(HR_CHARACTER * width)
+    end
+
+    def prompt_to_continue
+      blank_lines NUM_BLANK_LINES_BEFORE_PROMPT
+      hr
+      say styles.footer('Press any key to continue')
+      wait_for_keypress {}
+    end
+
+    def reset_raw
+      system("stty -raw echo")
+    end
+
+    def say(output, style = :default)
+      puts styles.apply(output, style)
+    end
+
+    def wait_for_keypress
+      while true do
+        begin
+          enable_raw
+          char = STDIN.getc
+          return char
+        ensure
+          reset_raw
+        end
+      end
+    end
+
+    def write_line(output, style = :default)
+      puts styles.apply(make_full_width(output), style)
+    end
+
+    private
+
+    attr_reader :out, :err, :prompt, :logger, :styles
+
+    def normalise_command(command, values = {})
+      format(command, values)
+    end
+
+    def set_autocomplete_strategy strategy
+      Readline.completion_append_character = " "
+      strategy = Array(strategy)
+      Readline.completion_proc = AUTOCOMPLETE_STRATEGIES[strategy[0]].curry.call(strategy[1])
+    end
+
+    def width
+      begin
+        IO.console.winsize[1]
+      rescue NotImplementedError
+        DEFAULT_WIDTH
+      end
+    end
+
+    def make_full_width(text)
+      text + (BLANK_CHARACTER * [width - text.length, 0].max)
+    end
+  end
+end

data/lib/git-prepare-branch/variable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GitPrepareBranch
+  class Variable
+    attr_reader :name, :context, :value, :capture
+
+    def initialize(name, context:, value: nil, capture: nil)
+      @name = name
+      @context = context
+      @capture = capture
+      @value = calculate_value(value)
+    end
+
+    private
+
+    def calculate_value(value)
+      return context.terminal.capture(capture_with_variables_injected) unless capture.nil?
+      return value.call(context) if value.kind_of? Proc
+      value
+    end
+
+    def capture_with_variables_injected
+      format(capture, context.variables.to_h)
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: git-prepare-branch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Phillips
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Command to assist in preparing Git branches for review
+email: adam@29ways.co.uk
+executables:
+- git-prepare-branch
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/git-prepare-branch
+- lib/git-prepare-branch.rb
+- lib/git-prepare-branch/app.rb
+- lib/git-prepare-branch/command.rb
+- lib/git-prepare-branch/command_keys.rb
+- lib/git-prepare-branch/configurator.rb
+- lib/git-prepare-branch/context.rb
+- lib/git-prepare-branch/logger.rb
+- lib/git-prepare-branch/null_logger.rb
+- lib/git-prepare-branch/screen.rb
+- lib/git-prepare-branch/styles.rb
+- lib/git-prepare-branch/terminal.rb
+- lib/git-prepare-branch/variable.rb
+homepage: https://github.com/adamphillips/git-prepare-branch
+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.6.13
+signing_key: 
+specification_version: 4
+summary: Command to assist in preparing Git branches for review
+test_files: []