gish 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 88e892754c58c48d94420e68a0d72518d1764db6
+  data.tar.gz: 42cfa7282ce8820f148ac2f0929b9e03ff304de6
+SHA512:
+  metadata.gz: fc489d2112e59c0ce29cb09b913e7cb68ea78f853e315e9d1257a9ef3a7e925e67e80a3cfb810e7413aff9211b9bbacd33504ac6d8d4140cc92bc32e919c86c5
+  data.tar.gz: 1ae384ef55e4687054533ed97450b8727b72aaad8b08e06e09ef401cfaa058d2c6836c030525a2b53405cbed74f3b5924dba3260ede5aa0ab0480055f454b0a6

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gish.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Baris Balic
+
+MIT License
+
+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,69 @@
+# Gish
+
+Github Issues on the command-line.  Not much else to say about it.
+
+## Installation
+
+  $ gem install gish
+
+When you first use Gish you will be prompted for your github credentials, and asked if you would like to use Gish with private repositories.  This information is used to create a [personal access token](https://github.com/blog/1509-personal-api-tokens) for your Github account, this token will then be stored and used instead of your credentials.
+
+You may also want to consider setting the environment variables `GISH_EDITOR` and `GISH_BROWSER`.  These will be used to launch an editor or browser respectively when the need arises.  When they are not set, Gish defaults to `EDITOR` and `BROWSER`, and finally `vi` and `open`.
+
+Why 'open'? Because I'm an OSX user and there's no *nix analogue as far as I can tell.
+
+## Usage
+  
+Gish has too many commands, subcommands and options to list here, thankfully it's uses the excellent [thor](http://whatisthor.com/) under the hood so you can use the help command like so to see your options...
+
+```Bash
+  $ gish help
+  $ gish subcommand help
+```
+
+Some commands may allow for excessive input, namely opening and commenting on issues.  In these cases, if you don't specify a message with "-m", Gish will spawn an editor for you to write the message in.
+
+Oh, one more thing!  Gish expects you to be running against the repository under the origin remote, if you want to override this, use -r/--repository, like so:
+
+```shell
+  $ gish list -r andrew/24pullrequests
+``` 
+
+### Examples
+
+Here are some examples to get you started.
+
+|command|outcome|
+|-------|-------|
+|gish list | List 20 issues|
+|gish show 1 | Show issue #1|
+|gish show 1 -i| Show issue #1 and include comments|
+|gish comment 1 -m ":+1"| Comment on issue #1|
+|gish comment 1| Comment on issue #1 using an editor|
+|gish close 1| Close issue #1|
+|gish label 1 such-feature| Add the label such-feature to issue #1|
+
+When listing issues, the number of comments on an issue will be displayed at the end of a line.
+
+```
+#9 barisbalic           Emoji!                                                                 [2]
+#8 barisbalic           Fix editor input for open command                                      [0]
+#7 barisbalic           Support API paging                                                     [0]
+#6 barisbalic           Current repository check is lame                                       [1]
+#5 barisbalic           Format issue and comment times                                         [0]
+#4 barisbalic           Enhance terminal output                                                [0]
+#2 barisbalic           Check issue assignee                                                   [0]
+#1 barisbalic           Add config subcommand                                                  [0]
+```
+
+
+
+## Contributing
+
+Contributions are very welcome, whether it's refactoring or taking care of the [issues](http://github.com/gish/issues).
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/gish

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative('../lib/gish')
+
+Gish::Runner.start(ARGV)

data/gish.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gish/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gish"
+  spec.version       = Gish::VERSION
+  spec.authors       = ["Baris Balic"]
+  spec.email         = ["leafybasil@gmail.com"]
+  spec.description   = %q{Gish brings Github Issues to the command-line.}
+  spec.summary       = %q{A fairly functional command-line interface for the most excellent Gitub Issues.}
+  spec.homepage      = "http://github.com/barisbalic/gish"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency 'octokit'
+  spec.add_dependency 'thor'
+end

data/lib/gish/cli/comments.rb

@@ -0,0 +1,30 @@
+module Gish
+  module Cli
+    class Comments < Thor
+      no_tasks do
+        include InputHelpers
+      end
+
+      desc 'list ISSUE_NUMBER', 'List all comments for the issue.'
+      def list(issue_number)
+        puts Gish.comments(issue_number)
+      end
+      
+      desc 'update COMMENT_NUMBER', 'Update a comment.'
+      method_option :message, :aliases => '-m', :type => :string, :desc => 'Specify the message inline.'
+      def update(comment_number)
+        existing_comment = Gish.issue_comment(comment_number).body
+        message = capture_editor_input(existing_comment) unless options.message? && options.message != 'message'
+        message ||= options.message
+        Gish.update_comment(comment_number, message)
+      end
+
+      desc 'delete COMMENT_NUMBER', 'Delete a comment.'
+      method_option :force, :type => :boolean, :aliases => '-f', :desc => 'Force yes, no prompt!'
+      def delete(comment_number)
+        return unless options.force? || confirm('Are you sure you want to delete this comment? (y/n)... ')
+        Gish.delete_comment(comment_number)
+      end
+    end
+  end
+end

data/lib/gish/cli/labels.rb

@@ -0,0 +1,32 @@
+module Gish
+  module Cli
+    class Labels < Thor
+      no_tasks do
+        include InputHelpers
+      end
+
+      desc 'list', 'List all labels for this repository.'
+      def list
+        puts Gish.list_labels
+      end
+
+      desc 'create NAME [color]', 'Create a new label for this repository.'
+      def create(name, color=nil)
+        Gish.create_label(name, color)
+      end
+
+      desc 'update NAME [color]', 'Update an existing label.'
+      def update(name, title, color=nil)
+        Gish.update_label(name, title, color)
+      end
+
+      desc 'delete NAME', 'Delete an existing label.'
+      method_option :force, :type => :boolean, :aliases => '-f', :desc => 'Force yes, no prompt!'
+      def delete(name, *names)
+        return unless options.force? || confirm('Are you sure you want to delete this label(s)? (y/n)... ')
+        names << name
+        Gish.delete_labels(names)
+      end
+    end
+  end
+end

data/lib/gish/commands/assignee.rb

@@ -0,0 +1,10 @@
+module Gish
+  module Commands
+    module Assignee
+      def list_assignees
+        assignees = request('assignee') { client.repository_assignees(Gish.repository) }
+        assignees.map{|a| a.login }
+      end
+    end
+  end
+end

data/lib/gish/commands/comment.rb

@@ -0,0 +1,17 @@
+module Gish
+  module Commands
+    module Comment
+      def update_comment(comment_number, comment)
+        request { client.update_comment(Gish.repository, comment_number, comment) }
+      end
+
+      def delete_comment(comment_number)
+        request { client.delete_comment(Gish.repository, comment_number) }
+      end
+
+      def issue_comment(comment_number)
+        request { client.issue_comment(Gish.repository, comment_number) }
+      end
+    end
+  end
+end

data/lib/gish/commands/issue.rb

@@ -0,0 +1,67 @@
+module Gish
+  module Commands
+    module Issue
+      def list(options)
+        issues = request { client.issues(Gish.repository, options) }
+        issues.map {|i| Gish::Issue.new(i).headline }
+      end
+
+      def show(issue_number)
+        issue = request { client.issue(Gish.repository, issue_number) }
+        Gish::Issue.new(issue) if issue
+      end
+
+      def reopen(issue_number)
+        request { client.reopen_issue(Gish.repository, issue_number) }
+      end
+
+      def create(title, body, labels=[], assignee)
+        options = {:labels => labels}
+        options.merge!({:assignee => assignee}) unless assignee.nil?
+        request { client.create_issue(Gish.repository, title, body, options) }
+      end
+
+      def close(issue_number, comment=nil)
+        request { client.close_issue(Gish.repository, issue_number)}
+      end
+
+      def comments(issue_number)
+        comments = request { client.issue_comments(Gish.repository, issue_number) }
+        comments.map {|c| Gish::Comment.new(c) }
+      end
+
+      def comment(issue_number, comment)
+        request { client.add_comment(Gish.repository, issue_number, comment) }
+      end
+
+      def label(issue_number, label, labels=[])
+        labels << label
+        sanitized_labels = labels.map{|l| l.strip }
+        request { client.add_labels_to_an_issue(Gish.repository, issue_number, sanitized_labels) }
+      end
+
+      def unlabel(issue_number, label, labels=[])
+        labels << label
+        labels.each do |l|
+          request { client.remove_label(Gish.repository, issue_number, l.strip) }
+        end
+      end      
+
+      def assign(issue_number, user_login)
+        options = {:assignee => user_login}
+        issue = request { client.issue(Gish.repository, issue_number) }
+        request { client.update_issue(Gish.repository, issue_number, issue.title, issue.body, options) }
+      end
+
+      def unassign(issue_number)
+        issue = request { client.issue(Gish.repository, issue_number) }
+        request { client.update_issue(Gish.repository, issue_number, issue.title, issue.body, {:assignee => ''}) }
+      end
+
+      def browse(issue_number=nil)
+        command = "#{Gish.browser} '#{Gish.github_url}/issues/#{issue_number}'"
+        %x{#{command}}
+      end
+    end
+  end
+end

data/lib/gish/commands/label.rb

@@ -0,0 +1,27 @@
+module Gish
+  module Commands
+    module Label
+      def list_labels
+        labels = request { client.labels(Gish.repository) }
+        labels.map{|l| Gish::Label.new(l) }
+      end
+
+      def delete_labels(labels)
+        labels.each do |l|
+          request { client.delete_label!(Gish.repository, l) }
+        end
+      end
+
+      def update_label(name, new_name, color)
+        opts = {:name => new_name}
+        opts[:color] = color unless color.nil?
+
+        request { client.update_label(Gish.repository, name, opts) }
+      end
+
+      def create_label(name, color=nil)
+        request { client.add_label(Gish.repository, name, color) }
+      end
+    end
+  end
+end

data/lib/gish/configuration.rb

@@ -0,0 +1,68 @@
+require 'octokit'
+
+module Gish
+  module Configuration
+    include InputHelpers
+    attr_accessor :editor, :access_token, :repository, :browser
+
+    def self.extended(base)
+      base.defaults
+    end
+
+    def editor=(editor)
+      @editor = editor
+    end
+
+    def access_token=(access_token)
+      @access_token = access_token
+    end
+
+    def repository=(repository)
+      @repository = repository
+    end
+
+    def browser=(browser)
+      @browser = browser
+    end
+
+    def github_url
+      "http://github.com/#{@repository}"
+    end
+
+    def defaults
+      @config_file = File.expand_path('~/.gish')
+      self.access_token = retrieve_or_generate_token
+      self.editor = (ENV['GISH_EDITOR'] || ENV['EDITOR']) || 'vi'
+      self.browser = (ENV['GISH_BROWSER'] || ENV['BROWSER']) || 'open'
+      self.repository = default_repository
+    end
+
+    private 
+
+    def default_repository
+      url = %x(git config --get remote.origin.url)
+      url.match(/:(.*)\.git/)[1] rescue ''
+    end
+
+    def retrieve_or_generate_token
+      return File.read(@config_file) if File.exists?(@config_file)
+
+      puts "(step 1 of 2) Gish needs your login details to create a personal use token.  This only happens once and your credentials will not be stored."
+      username = prompt('Username: ')
+      password = prompt('Password: ')
+
+      puts "(step 2 of 2) Gish works with public repositories by default, but if you want to use it with We are about to create a token, but first you need to decide if you want to use Gish with private repositories, we need to know now!"
+      private_access = confirm("Use with private repositories? (y/n) ")
+
+      github = Octokit::Client.new(:login => username, :password => password)      
+      options = {
+        :note => 'Gish: Github Issues on the command-line.',
+        :note_url => 'http://github.com/barisbalic/gish/'
+      }
+      options.merge!({:scopes => ['repo']}) if private_access
+      authorization = github.create_authorization(options)
+
+      File.open(@config_file, 'w+') { |file| file.write(authorization.token) }
+    end
+  end
+end

data/lib/gish/helpers/input_helpers.rb

@@ -0,0 +1,27 @@
+require 'securerandom'
+
+module Gish
+  module InputHelpers
+    def prompt(message)
+      print message
+      STDIN.gets.chomp
+    end
+
+    def confirm(message)
+      print message
+      STDIN.gets.chomp == 'y'
+    end
+
+    def capture_editor_input(content=nil)
+      unique_file = "/tmp/#{SecureRandom.hex}"
+      File.open(unique_file, 'w+'){|f| f.write(content) }
+
+      command = "#{Gish.editor} #{unique_file} < `tty` > `tty`"
+      %x{#{command}}
+      ouput = %x{cat #{unique_file}}
+      
+      File.delete(unique_file)
+      ouput.length < 1 ? nil : ouput
+    end
+  end
+end

data/lib/gish/helpers/terminal_helpers.rb

@@ -0,0 +1,20 @@
+module Gish
+  module TerminalHelpers
+    def console_width
+      size = %x{stty size}
+      size.split(' ').last
+    end
+
+    def bold(message)
+      "\033[1m#{message}\033[0m"
+    end
+
+    def underline(message)
+      "\033[4m#{message}\033[0m"
+    end
+
+    def format_label(label)
+      "\033[30m\033[47m #{label} \033[0m"
+    end
+  end
+end

data/lib/gish/presentation/comment.rb

@@ -0,0 +1,18 @@
+module Gish
+  class Comment
+    include TerminalHelpers
+
+    def initialize(github_comment)
+      @body = github_comment.body.gsub("\r\n", "\n")
+      @user = github_comment.user.login
+      @id = github_comment.id
+      @created_at = github_comment.created_at
+    end
+
+    def to_s
+      output = "\n#{@id} #{bold(@user)} commented on #{@created_at}"
+      output << "\n\"#{@body}\"\n"
+      output
+    end
+  end
+end

data/lib/gish/presentation/issue.rb

@@ -0,0 +1,46 @@
+module Gish
+  class Issue
+    include TerminalHelpers
+    
+    def initialize(github_issue)
+      @url = github_issue.html_url
+      @number = github_issue.number.to_s
+      @state = github_issue.state
+      @title = github_issue.title
+      @body = github_issue.body
+      @labels = github_issue.labels
+      @user = github_issue.user.login
+      @comment_count = github_issue.comments
+      @assignee = github_issue.assignee.login rescue nil
+      @created_at = github_issue.created_at
+    end
+
+    def headline
+      user = @user.ljust(20, ' ')
+      title = short_title.ljust(70, ' ') 
+      number = @number.ljust(5, ' ')
+      "##{number} #{bold(user)} #{title} [#{@comment_count}]"
+    end
+
+    def to_s
+      output = underline("##{@number} #{@title}")
+      output << " [#{@state}]"
+      output << "\nOpened by #{bold(@user)} on #{@created_at}"
+      output << "\nAssigned to #{bold(@assignee)}" unless @assignee.nil?
+      output << "\n\n#{@body}\n\n"
+      output << "#{label_names.join(' ')}" unless @labels.empty?
+      output
+    end
+
+    private
+
+    def short_title
+      return "#{@title}" unless @title.length > 60
+      "#{@title[0..69]}"
+    end
+
+    def label_names
+      @labels.map{ |l| format_label(l.name) }
+    end
+  end
+end

data/lib/gish/presentation/label.rb

@@ -0,0 +1,12 @@
+module Gish
+  class Label
+    def initialize(github_label)
+      @name = github_label.name
+      @color = github_label.color
+    end
+
+    def to_s
+      "#{@color}  #{@name}"
+    end
+  end
+end

data/lib/gish/runner.rb

@@ -0,0 +1,114 @@
+require 'thor'
+
+require_relative 'cli/labels'
+require_relative 'cli/comments'
+
+module Gish
+  class Runner < Thor
+    no_tasks do
+      include InputHelpers
+    end
+
+    class_option :repository, :type=> :string , :aliases => '-r', :desc => 'Specify the repository.'
+    def initialize(*args)
+      super
+      return unless options.repository? && options.repository != 'repository'
+      Gish.repository = options.repository
+    end
+    
+    desc 'labels SUBCOMMAND ...ARGS', 'Manage labels for the repository.'
+    subcommand 'labels', Gish::Cli::Labels
+
+    desc 'label ISSUE_NUMBER LABEL [LABEL]...', 'Add one or more labels to an issue.'
+    def label(issue_number, label, *more_labels)
+      Gish.label(issue_number, label, more_labels)
+    end
+
+    desc 'unlabel ISSUE_NUMBER LABEL [LABEL]...', 'Remove a label from an issue.'
+    def unlabel(issue_number, label, *more_labels)
+      Gish.unlabel(issue_number, label, more_labels)
+    end
+
+    desc 'comments SUBCOMMAND ...ARGS', 'Manage comments for an issue.'
+    subcommand 'comments', Gish::Cli::Comments
+
+    desc 'comment ISSUE_NUMBER', 'Comment on an issue.'
+    method_option :message, :type => :string, :aliases => '-m', :desc => 'Specify the message inline.'
+    def comment(issue_number)
+      message = capture_editor_input unless options.message? || options.message == 'message'
+      message ||= options.message
+      Gish.comment(issue_number, message)
+    end
+
+    desc 'list [COUNT]', 'List issues.'
+    method_option :closed, :type => :boolean, :aliases => '-c', :desc => 'Show closed issues.'
+    method_option :order, :type => :string, :aliases => '-o', :desc => 'Ordering by asc or desc.'
+    def list(count=20)
+      args = {:per_page => count}
+      args[:state] = 'closed' if options.closed?
+      args[:direction] = 'asc' if options.order == 'asc' 
+      puts Gish.list(args)
+    end
+
+    desc 'show ISSUE_NUMBER', 'Display the issue in full.'
+    method_option :include_comments, :type => :boolean, :aliases => '-i', :desc => 'Include comments.'
+    def show(issue_number)
+      puts Gish.show(issue_number)
+      puts "\n"
+      puts Gish.comments(issue_number) if options.include_comments?
+    end
+
+    desc 'close ISSUE_NUMBER', 'Close an issue.'
+    method_option :force, :type => :boolean, :aliases => '-f', :desc => 'Force yes, no prompt!'
+    method_option :message, :type => :string, :aliases => '-m', :desc => 'Provide a message before closing.'
+    def close(issue_number)
+      return unless options.force? || options.message? || confirm("Are you sure you want to close issue ##{issue_number} (y/n)... ")
+      message = capture_editor_input if options.message? && options.message == 'message'
+      message ||= options.message
+      Gish.comment(issue_number, message) if options.message?
+      Gish.close(issue_number)
+    end
+
+    desc 'reopen ISSUE_NUMBER', 'Reopen a closed issue.'
+    def reopen(issue_number)
+      Gish.reopen(issue_number)
+    end
+
+    desc 'browse [ISSUE_NUMBER]', 'View issues in your browser.'
+    def browse(issue_number=nil)
+      Gish.browse(issue_number)
+    end
+
+    desc 'assignees', 'List assignees for the repository.'
+    def assignees
+      puts Gish.list_assignees
+    end
+
+    desc 'assign ISSUE_NUMBER USER_LOGIN', 'Assign an issue to a user.'
+    def assign(issue_number, user_login)
+      Gish.assign(issue_number, user_login)
+    end
+
+    desc 'unassign ISSUE_NUMBER', 'Unassign an issue.'
+    def unassign(issue_number)
+      Gish.unassign(issue_number)
+    end
+
+    desc 'open TITLE', 'Open a new issue.'
+    method_option :labels, :type => :array, :aliases => '-l', :desc => 'Add labels.'
+    method_option :assignee, :type => :string, :aliases => '-a', :desc => 'Assign someone to the issue.'
+    method_option :message, :type => :string, :aliases => '-m', :desc => 'Specify the message inline.'
+    def open(title)
+      labels = (options.labels || []).map{|l| l.strip }
+      message = capture_editor_input unless options.message? && options.message != 'message'
+      message ||= options.message
+      assignee = options.assignee
+      Gish.create(title, message, labels, assignee)
+    end
+
+    desc 'version', 'Display the version of Gish.'
+    def version
+      puts "v#{Gish::VERSION}"
+    end
+  end
+end

data/lib/gish/version.rb

@@ -0,0 +1,3 @@
+module Gish
+  VERSION = "0.9.0"
+end

data/lib/gish.rb

@@ -0,0 +1,37 @@
+require "gish/version"
+require "gish/helpers/input_helpers"
+require "gish/helpers/terminal_helpers"
+require "gish/configuration"
+require "gish/commands/issue"
+require "gish/commands/comment"
+require "gish/commands/label"
+require "gish/commands/assignee"
+require "gish/presentation/issue"
+require "gish/presentation/label"
+require "gish/presentation/comment"
+require 'gish/runner'
+
+module Gish
+  extend Configuration
+
+  def self.client
+    @github ||= Octokit::Client.new(:access_token => Gish.access_token)
+  end
+
+  def self.request(resource='issue/comment/label')
+    begin
+      yield()
+    rescue Octokit::NotFound
+      puts "Could not find #{resource}."
+      exit 1
+    rescue Octokit::Unauthorized
+      puts "Something is wrong with your personal access token."
+      exit 1
+    end    
+  end
+
+  extend Gish::Commands::Label
+  extend Gish::Commands::Issue
+  extend Gish::Commands::Comment
+  extend Gish::Commands::Assignee
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: gish
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Baris Balic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gish brings Github Issues to the command-line.
+email:
+- leafybasil@gmail.com
+executables:
+- gish
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/gish
+- gish.gemspec
+- lib/gish.rb
+- lib/gish/cli/comments.rb
+- lib/gish/cli/labels.rb
+- lib/gish/commands/assignee.rb
+- lib/gish/commands/comment.rb
+- lib/gish/commands/issue.rb
+- lib/gish/commands/label.rb
+- lib/gish/configuration.rb
+- lib/gish/helpers/input_helpers.rb
+- lib/gish/helpers/terminal_helpers.rb
+- lib/gish/presentation/comment.rb
+- lib/gish/presentation/issue.rb
+- lib/gish/presentation/label.rb
+- lib/gish/runner.rb
+- lib/gish/version.rb
+homepage: http://github.com/barisbalic/gish
+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.0.3
+signing_key: 
+specification_version: 4
+summary: A fairly functional command-line interface for the most excellent Gitub Issues.
+test_files: []