gerrit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e622e3bacf3ff603e41ef0aaad895a33c5c0c531
+  data.tar.gz: 463bc6a58c060e6ad3d8825fc108e9b0fcd3f1f6
+SHA512:
+  metadata.gz: 25f0ee6364cd63cdc9d3a2519a6bccff966f03735b5bffba41400be186b23316a7df56b1f0bbf108322be73fc6fa41c4d488214ffe1825477dc95677e8b7ff8a
+  data.tar.gz: 6e95f4c7472f6ab0c5f422c44316cec1296665ca3f0a0fd6a9cd1b309237d50e20f809266e0710741bba71cede221dca108742e80995599eec8acf0871097c81

data/bin/gerrit

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'gerrit/cli'
+
+input = Gerrit::Input.new(STDIN)
+output = Gerrit::Output.new(STDOUT)
+exit Gerrit::CLI.new(input: input, output: output).run(ARGV)

data/lib/gerrit/cli.rb

@@ -0,0 +1,72 @@
+require 'gerrit'
+
+module Gerrit
+  # Command line application interface.
+  class CLI
+    # Set of semantic exit codes we can return.
+    #
+    # @see http://www.gsp.com/cgi-bin/man.cgi?section=3&topic=sysexits
+    module ExitCodes
+      OK          = 0   # Successful execution
+      USAGE       = 64  # User error (bad command line or invalid input)
+      SOFTWARE    = 70  # Internal software error (bug)
+      CONFIG      = 78  # Configuration error (invalid file or options)
+    end
+
+    # Create a CLI that outputs to the given output destination.
+    #
+    # @param input [Gerrit::Input]
+    # @param output [Gerrit::Output]
+    def initialize(input:, output:)
+      @ui = UI.new(input, output)
+    end
+
+    # Parses the given command-line arguments and executes appropriate logic
+    # based on those arguments.
+    #
+    # @param [Array<String>] arguments
+    # @return [Integer] exit status code
+    def run(arguments)
+      config = Configuration.load_applicable
+      run_command(config, arguments)
+
+      ExitCodes::OK
+    rescue => ex
+      ErrorHandler.new(@ui).handle(ex)
+    end
+
+    private
+
+    # Executes the appropriate command given the list of command line arguments.
+    #
+    # @param config [Gerrit::Configuration]
+    # @param ui [Gerrit::UI]
+    # @param arguments [Array<String>]
+    # @raise [Gerrit::Errors::GerritError] when any exceptional circumstance occurs
+    def run_command(config, arguments)
+      # Display help documentation by default
+      arguments = ['help'] if arguments.empty?
+
+      command_class = find_command(arguments)
+      command_class.new(config, @ui, arguments).run
+    end
+
+    # Finds the {Command} corresponding to the given set of arguments.
+    #
+    # @param [Array<String>] arguments
+    # @return [Class]
+    def find_command(arguments)
+      cmd = arguments.first
+
+      begin
+        require 'gerrit/command/base'
+        require "gerrit/command/#{Utils.snake_case(cmd)}"
+      rescue LoadError => ex
+        raise Errors::CommandInvalidError,
+              "`gerrit #{cmd}` is not a valid command"
+      end
+
+      Command.const_get(Utils.camel_case(cmd))
+    end
+  end
+end

data/lib/gerrit/client.rb

@@ -0,0 +1,67 @@
+require 'json'
+
+module Gerrit
+  # Client for executing commands against the Gerrit server.
+  class Client
+    # Create a client using the given configuration settings.
+    #
+    # @param config [Gerrit::Configuration]
+    def initialize(config)
+      @config = config
+    end
+
+    # Executes a command against the Gerrit server, returning the output.
+    #
+    # @param command [Array<String>]
+    # @return [String]
+    def execute(command)
+      user = @config[:user]
+      host = @config[:host]
+      port = @config[:port]
+      ssh_cmd = %W[ssh -p #{port} #{user}@#{host} gerrit] + command
+
+      result = Subprocess.spawn(ssh_cmd)
+      unless result.success?
+        raise Errors::GerritCommandFailedError,
+              "Command `#{ssh_cmd.join(' ')}` failed:\n" \
+              "STATUS: #{result.status}\n" \
+              "STDOUT: #{result.stdout.inspect}\n" \
+              "STDERR: #{result.stderr.inspect}\n"
+      end
+
+      result.stdout
+    end
+
+    # Returns all groups visible to the user.
+    #
+    # @return [Array<String>]
+    def groups
+      execute(%w[ls-groups]).split("\n")
+    end
+
+    # Returns members associated with a group.
+    #
+    # @param group [String] full name of the group
+    # @param recursive [Boolean] whether to include members of sub-groups.
+    # @return [Array<String>]
+    def members(group, recursive: true)
+      flags = []
+      flags << '--recursive' if recursive
+      execute(%w[ls-members] + ["'#{group}'"] + flags)
+    end
+
+    # Returns basic information about a change.
+    def change(change_id_or_number)
+      rows = execute(%W[query --format=JSON
+                        --current-patch-set
+                        change:#{change_id_or_number}]).split("\n")[0..-2]
+
+      if rows.empty?
+        raise Errors::CommandFailedError,
+              "No change matches the id '#{change_id_or_number}'"
+      else
+        JSON.parse(rows.first)
+      end
+    end
+  end
+end

data/lib/gerrit/command/base.rb

@@ -0,0 +1,62 @@
+require 'gerrit/client'
+
+module Gerrit::Command
+  # Abstract base class of all commands.
+  #
+  # @abstract
+  class Base
+    # @param config [Gerrit::Configuration]
+    # @param ui [Gerrit::UI]
+    # @param arguments [Array<String>]
+    def initialize(config, ui, arguments)
+      @config = config
+      @ui = ui
+      @arguments = arguments
+    end
+
+    # Parses arguments and executes the command.
+    def run
+      # TODO: include a parse step here and remove duplicate parsing code from
+      # individual commands
+      execute
+    end
+
+    # Executes the command given the previously-parsed arguments.
+    def execute
+      raise NotImplementedError, 'Define `execute` in Command subclass'
+    end
+
+    private
+
+    # @return [Array<String>]
+    attr_reader :arguments
+
+    # @return [Gerrit::Configuration]
+    attr_reader :config
+
+    # @return [Gerrit::UI]
+    attr_reader :ui
+
+    # Returns a client for making requests to the Gerrit server.
+    #
+    # @return [Gerrit::Client]
+    def client
+      @client ||= Gerrit::Client.new(@config)
+    end
+
+    # Returns information about this repository.
+    #
+    # @return [Gerrit::Repo]
+    def repo
+      @repo ||= Gerrit::Repo.new(@config)
+    end
+
+    # Execute a process and return the result including status and output.
+    #
+    # @param args [Array<String>]
+    # @return [#status, #stdout, #stderr]
+    def spawn(args)
+      Subprocess.spawn(args)
+    end
+  end
+end

data/lib/gerrit/command/checkout.rb

@@ -0,0 +1,37 @@
+module Gerrit::Command
+  # Check out a patchset locally.
+  class Checkout < Base
+    def execute
+      result = spawn(%W[git fetch #{repo.remote_url} #{change_refspec}])
+      if result.success?
+        spawn(%w[git checkout FETCH_HEAD])
+      end
+    end
+
+    private
+
+    # Returns the latest refspec for the given change number.
+    def change_refspec
+      change_md = change_metadata
+      change_number = change_md['number']
+      patchset = change_md['currentPatchSet']['number']
+
+      # Gerrit takes the last two digits of the change number to nest under a
+      # directory with that name so they don't exceed the per-directory file limit
+      prefix = change_number.rjust(2, '0').to_s[-2..-1]
+
+      "refs/changes/#{prefix}/#{change_number}/#{patchset}"
+    end
+
+    def change_metadata
+      change_num_or_id =
+        if arguments[1]
+          arguments[1]
+        else
+          ui.ask('Enter change number or Change-ID').argument(:required).read_string
+        end
+
+      client.change(change_num_or_id)
+    end
+  end
+end

data/lib/gerrit/command/groups.rb

@@ -0,0 +1,10 @@
+module Gerrit::Command
+  # List all groups the user can view.
+  class Groups < Base
+    def execute
+      client.groups.each do |group|
+        ui.print group
+      end
+    end
+  end
+end

data/lib/gerrit/command/help.rb

@@ -0,0 +1,8 @@
+module Gerrit::Command
+  # Displays help documentation.
+  class Help < Base
+    def execute
+      ui.print 'Usage: gerrit [command]'
+    end
+  end
+end

data/lib/gerrit/command/members.rb

@@ -0,0 +1,37 @@
+module Gerrit::Command
+  # Lists members of a group.
+  #
+  # This allows you to list the members of a group by regex.
+  class Members < Base
+    def execute
+      ui.print client.members(find_group), newline: false
+    end
+
+    private
+
+    def find_group
+      matches = client.groups.grep(/#{search_term}/i)
+
+      if matches.empty?
+        ui.error 'No groups match the given name/regex'
+        raise Gerrit::Errors::CommandFailedError
+      elsif matches.size >= 2
+        ui.warning 'Multiple groups match the given regex:'
+        matches.each do |group|
+          ui.print group
+        end
+        raise Gerrit::Errors::CommandFailedError
+      end
+
+      matches[0]
+    end
+
+    def search_term
+      if arguments[1]
+        arguments[1]
+      else
+        ui.ask('Enter group name or regex').argument(:required).read_string
+      end
+    end
+  end
+end

data/lib/gerrit/command/projects.rb

@@ -0,0 +1,12 @@
+module Gerrit::Command
+  # Displays a list of all projects the user has permissions to see.
+  #
+  # This is a light wrapper around `ls-projects` since it will just append any
+  # additional arguments to the underlying command.
+  class Projects < Base
+    def execute
+      ui.print client.execute(%w[ls-projects] + arguments[1..-1]),
+               newline: false
+    end
+  end
+end

data/lib/gerrit/command/version.rb

@@ -0,0 +1,8 @@
+module Gerrit::Command
+  # Displays version information.
+  class Version < Base
+    def execute
+      ui.info Gerrit::VERSION
+    end
+  end
+end

data/lib/gerrit/configuration.rb

@@ -0,0 +1,84 @@
+require 'pathname'
+require 'yaml'
+
+module Gerrit
+  # Stores runtime configuration for the application.
+  #
+  # This is intended to define helper methods for accessing configuration so
+  # this logic can be shared amongst the various components of the system.
+  class Configuration
+    # Name of the configuration file.
+    FILE_NAME = '.gerrit.yaml'
+
+    class << self
+      # Loads appropriate configuration file given the current working
+      # directory.
+      #
+      # @return [Gerrit::Configuration]
+      def load_applicable
+        current_directory = File.expand_path(Dir.pwd)
+        config_file = applicable_config_file(current_directory)
+
+        if config_file
+          from_file(config_file)
+        else
+          raise Errors::ConfigurationMissingError,
+                'No configuration file was found'
+        end
+      end
+
+      # Loads a configuration from a file.
+      #
+      # @return [Gerrit::Configuration]
+      def from_file(config_file)
+        options =
+          if yaml = YAML.load_file(config_file)
+            yaml.to_hash
+          else
+            {}
+          end
+
+        new(options)
+      end
+
+      private
+
+      # Returns the first valid configuration file found, starting from the
+      # current working directory and ascending to ancestor directories.
+      #
+      # @param directory [String]
+      # @return [String, nil]
+      def applicable_config_file(directory)
+        Pathname.new(directory)
+                .enum_for(:ascend)
+                .map { |dir| dir + FILE_NAME }
+                .find do |config_file|
+          config_file if config_file.exist?
+        end
+      end
+    end
+
+    # Creates a configuration from the given options hash.
+    #
+    # @param options [Hash]
+    def initialize(options)
+      @options = options
+    end
+
+    # Access the configuration as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @return [Array,Hash,Number,String]
+    def [](key)
+      @options[key.to_s]
+    end
+
+    # Compares this configuration with another.
+    #
+    # @param other [HamlLint::Configuration]
+    # @return [true,false] whether the given configuration is equivalent
+    def ==(other)
+      super || @options == other.instance_variable_get('@options')
+    end
+  end
+end

data/lib/gerrit/constants.rb

@@ -0,0 +1,7 @@
+# Global application constants.
+module Gerrit
+  EXECUTABLE_NAME = 'gerrit'
+
+  REPO_URL = 'https://github.com/sds/gerrit'
+  BUG_REPORT_URL = "#{REPO_URL}/issues"
+end

data/lib/gerrit/error_handler.rb

@@ -0,0 +1,45 @@
+module Gerrit
+  # Central location of all logic for how exceptions are presented to the user.
+  class ErrorHandler
+    # Creates exception handler that can display output to user via the given
+    # user interface.
+    #
+    # @param [Gerrit::UI] user interface to print output to
+    def initialize(ui)
+      @ui = ui
+    end
+
+    # Display appropriate output to the user for the given exception, returning
+    # a semantic exit status code.
+    #
+    # @return [Integer] exit status code
+    def handle(ex)
+      case ex
+      when Errors::UsageError
+        CLI::ExitCodes::USAGE
+      when Errors::ConfigurationError
+        ui.error ex.message
+        CLI::ExitCodes::CONFIG
+      else
+        print_unexpected_exception(ex)
+        CLI::ExitCodes::SOFTWARE
+      end
+    end
+
+    private
+
+    attr_reader :ui
+
+    def print_unexpected_exception(ex)
+      ui.bold_error ex.message
+      ui.error ex.backtrace.join("\n")
+      ui.warning 'Report this bug at ', newline: false
+      ui.info BUG_REPORT_URL
+      ui.newline
+      ui.info 'To help fix this issue, please include:'
+      ui.print '- The above stack trace'
+      ui.print '- Ruby version: ', newline: false
+      ui.info RUBY_VERSION
+    end
+  end
+end

data/lib/gerrit/errors.rb

@@ -0,0 +1,29 @@
+# Collection of errors that can be thrown by the application.
+#
+# This implements an exception hierarchy which exceptions to be grouped by type
+# so the {ExceptionHandler} can display them appropriately.
+module Gerrit::Errors
+  # Base class for all errors reported by this tool.
+  class GerritError < StandardError; end
+
+  # Base class for all errors that are a result of incorrect user usage.
+  class UsageError < GerritError; end
+
+  # Base class for all configuration-related errors.
+  class ConfigurationError < GerritError; end
+
+  # Raised when a configuration file is not present.
+  class ConfigurationMissingError < ConfigurationError; end
+
+  # Raised when a command has failed due to user error.
+  class CommandFailedError < UsageError; end
+
+  # Raised when invalid/non-existent command was used.
+  class CommandInvalidError < UsageError; end
+
+  # Raised when remote Gerrit command returned a non-zero exit status.
+  class GerritCommandFailedError < GerritError; end
+
+  # Raised when run in a directory not part of a valid git repository.
+  class InvalidGitRepo < UsageError; end
+end

data/lib/gerrit/input.rb

@@ -0,0 +1,18 @@
+module Gerrit
+  # Provides interface for collecting input from the user.
+  class Input
+    # Creates an {Gerrit::Input} wrapping the given IO stream.
+    #
+    # @param [IO] input the input stream
+    def initialize(input)
+      @input = input
+    end
+
+    # Blocks until a line of input is returned from the input source.
+    #
+    # @return [String, nil]
+    def get
+      @input.gets
+    end
+  end
+end

data/lib/gerrit/output.rb

@@ -0,0 +1,25 @@
+module Gerrit
+  # Encapsulates all communication to an output source.
+  class Output
+    # Creates a {Gerrit::Output} which displays nothing.
+    #
+    # @return [Gerrit::Output]
+    def self.silent
+      new(File.open('/dev/null', 'w'))
+    end
+
+    # Creates a new {Gerrit::Output} instance.
+    #
+    # @param stream [IO] the output destination stream.
+    def initialize(stream)
+      @output_stream = stream
+    end
+
+    # Print the specified output.
+    #
+    # @param [String] output the output to display
+    def print(output)
+      @output_stream.print(output)
+    end
+  end
+end

data/lib/gerrit/repo.rb

@@ -0,0 +1,71 @@
+require 'pathname'
+
+module Gerrit
+  # Exposes information about the current git repository.
+  class Repo
+    # @param config [Gerrit::Configuration]
+    def initialize(config)
+      @config = config
+    end
+
+    # Returns the absolute path to the root of the current repository the
+    # current working directory resides within.
+    #
+    # @return [String]
+    # @raise [Gerrit::Errors::InvalidGitRepoError] if the current directory
+    #   doesn't reside within a git repository
+    def root
+      @root ||=
+        begin
+          git_dir = Pathname.new(File.expand_path('.'))
+                            .enum_for(:ascend)
+                            .find do |path|
+            (path + '.git').exist?
+          end
+
+          unless git_dir
+            raise Errors::InvalidGitRepoError, 'no .git directory found'
+          end
+
+          git_dir.to_s
+        end
+    end
+
+    # Returns an absolute path to the .git directory for a repo.
+    #
+    # @return [String]
+    def git_dir
+      @git_dir ||=
+        begin
+          git_dir = File.expand_path('.git', root)
+
+          # .git could also be a file that contains the location of the git directory
+          unless File.directory?(git_dir)
+            git_dir = File.read(git_dir)[/^gitdir: (.*)$/, 1]
+
+            # Resolve relative paths
+            unless git_dir.start_with?('/')
+              git_dir = File.expand_path(git_dir, repo_dir)
+            end
+          end
+
+          git_dir
+        end
+    end
+
+    # Returns the project name for this repo.
+    #
+    # Uses the project name specified by the configuration, otherwise just uses
+    # the repo root directory.
+    #
+    # @return [String]
+    def project
+      @config[:project] || File.basename(root)
+    end
+
+    # Returns the Gerrit remote URL for this repo.
+    def remote_url
+      "ssh://#{@config[:user]}@#{@config[:host]}:#{@config[:port]}/#{project}"
+    end
+  end
+end

data/lib/gerrit/subprocess.rb

@@ -0,0 +1,53 @@
+require 'childprocess'
+require 'tempfile'
+
+module Gerrit
+  # Manages execution of a child process, collecting the exit status and
+  # standard out/error output.
+  class Subprocess
+    # Encapsulates the result of a process.
+    #
+    # @attr_reader status [Integer] exit status code returned by process
+    # @attr_reader stdout [String] standard output stream output
+    # @attr_reader stderr [String] standard error stream output
+    Result = Struct.new(:status, :stdout, :stderr) do
+      def success?
+        status == 0
+      end
+    end
+
+    class << self
+      # Spawns a new process using the given array of arguments (the first
+      # element is the command).
+      #
+      # @param args [Array<String>]
+      # @return [Result]
+      def spawn(args)
+        process = ChildProcess.build(*args)
+
+        out, err = assign_output_streams(process)
+
+        process.start
+        process.wait
+
+        err.rewind
+        out.rewind
+
+        Result.new(process.exit_code, out.read, err.read)
+      end
+
+      private
+
+      # @param process [ChildProcess]
+      # @return [Array<IO>]
+      def assign_output_streams(process)
+        %w[out err].map do |stream_name|
+          ::Tempfile.new(stream_name).tap do |stream|
+            stream.sync = true
+            process.io.send("std#{stream_name}=", stream)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gerrit/ui.rb

@@ -0,0 +1,103 @@
+require 'forwardable'
+require 'tty'
+
+module Gerrit
+  # Manages all interaction with the user.
+  class UI
+    extend Forwardable
+
+    def_delegators :@shell, :ask, :confirm
+
+    # Creates a {UI} that mediates between the given input/output streams.
+    #
+    # @param input [Gerrit::Input]
+    # @param output [Gerrit::Output]
+    def initialize(input, output)
+      @input = input
+      @output = output
+      @pastel = Pastel.new
+      @shell = TTY::Shell.new
+    end
+
+    # Get user input, stripping extraneous whitespace.
+    #
+    # @return [String, nil]
+    def user_input
+      if input = @input.get
+        input.strip
+      end
+    end
+
+    # Print the specified output.
+    #
+    # @param output [String]
+    # @param newline [Boolean] whether to append a newline
+    def print(output, newline: true)
+      @output.print(output)
+      @output.print("\n") if newline
+    end
+
+    # Print output in bold face.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def bold(*args, **kwargs)
+      print(@pastel.bold(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicative of error.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def error(args, **kwargs)
+      print(@pastel.red(*args), **kwargs)
+    end
+
+    # Print the specified output in a bold face and color indicative of error.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def bold_error(*args, **kwargs)
+      print(@pastel.bold.red(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicative of success.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def success(*args, **kwargs)
+      print(@pastel.green(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicative of a warning.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def warning(*args, **kwargs)
+      print(@pastel.yellow(*args), **kwargs)
+    end
+
+    # Print the specified output in a color indicating information.
+    #
+    # @param args [Array]
+    # @param kwargs [Hash]
+    def info(*args, **kwargs)
+      print(@pastel.cyan(*args), **kwargs)
+    end
+
+    # Print a blank line.
+    def newline
+      print('')
+    end
+
+    # Prints a table.
+    #
+    # Customize the table by passing a block and operating on the table object
+    # passed to that block to add rows and customize its appearance.
+    def table(&block)
+      t = TTY::Table.new
+      block.call(t)
+      print(t.render(:unicode))
+    end
+  end
+end

data/lib/gerrit/utils.rb

@@ -0,0 +1,30 @@
+module Gerrit
+  # A miscellaneous set of utility functions.
+  module Utils
+    module_function
+
+    # Converts a string containing underscores/hyphens/spaces into CamelCase.
+    #
+    # @param [String] string
+    # @return [String]
+    def camel_case(string)
+      string.split(/_|-| /)
+            .map { |part| part.sub(/^\w/) { |c| c.upcase } }
+            .join
+    end
+
+    # Convert string containing camel case or spaces into snake case.
+    #
+    # @see stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+    #
+    # @param [String] string
+    # @return [String]
+    def snake_case(string)
+      string.gsub(/::/, '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+    end
+  end
+end

data/lib/gerrit/version.rb

@@ -0,0 +1,4 @@
+# Defines the gem version.
+module Gerrit
+  VERSION = '0.1.0'
+end

data/lib/gerrit.rb

@@ -0,0 +1,11 @@
+require 'gerrit/constants'
+require 'gerrit/errors'
+require 'gerrit/error_handler'
+require 'gerrit/configuration'
+require 'gerrit/input'
+require 'gerrit/output'
+require 'gerrit/ui'
+require 'gerrit/repo'
+require 'gerrit/subprocess'
+require 'gerrit/utils'
+require 'gerrit/version'

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: gerrit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+- !ruby/object:Gem::Dependency
+  name: tty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Tool providing an effective CLI workflow with Gerrit
+email:
+- shane@dasilva.io
+executables:
+- gerrit
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/gerrit
+- lib/gerrit.rb
+- lib/gerrit/cli.rb
+- lib/gerrit/client.rb
+- lib/gerrit/command/base.rb
+- lib/gerrit/command/checkout.rb
+- lib/gerrit/command/groups.rb
+- lib/gerrit/command/help.rb
+- lib/gerrit/command/members.rb
+- lib/gerrit/command/projects.rb
+- lib/gerrit/command/version.rb
+- lib/gerrit/configuration.rb
+- lib/gerrit/constants.rb
+- lib/gerrit/error_handler.rb
+- lib/gerrit/errors.rb
+- lib/gerrit/input.rb
+- lib/gerrit/output.rb
+- lib/gerrit/repo.rb
+- lib/gerrit/subprocess.rb
+- lib/gerrit/ui.rb
+- lib/gerrit/utils.rb
+- lib/gerrit/version.rb
+homepage: https://github.com/sds/gerrit
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Gerrit command line interface
+test_files: []
+has_rdoc: