ghi 0.3.1 → 0.9.0.dev

metadata

@@ -1,70 +1,92 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: ghi
-version: !ruby/object:Gem::Version
-  version: 0.3.1
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  hash: -1101288818
+  prerelease: 6
+  segments: 
+  - 0
+  - 9
+  - 0
+  - dev
+  version: 0.9.0.dev
 platform: ruby
-authors:
+authors: 
 - Stephen Celis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-13 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &70100746900540 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - <
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: *70100746900540
-description: GitHub Issues on the command line. Use your `$EDITOR`, not your browser.
+
+date: 2012-04-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: |
+  GitHub Issues on the command line. Use your `$EDITOR`, not your browser.
+
 email: stephen@stephencelis.com
-executables:
+executables: 
 - ghi
 extensions: []
-extra_rdoc_files:
-- README.rdoc
-files:
-- bin/ghi
-- lib/ghi/api.rb
-- lib/ghi/cli.rb
-- lib/ghi/issue.rb
+
+extra_rdoc_files: []
+
+files: 
+- lib/ghi/authorization.rb
+- lib/ghi/client.rb
+- lib/ghi/commands/assign.rb
+- lib/ghi/commands/close.rb
+- lib/ghi/commands/command.rb
+- lib/ghi/commands/comment.rb
+- lib/ghi/commands/config.rb
+- lib/ghi/commands/edit.rb
+- lib/ghi/commands/help.rb
+- lib/ghi/commands/label.rb
+- lib/ghi/commands/list.rb
+- lib/ghi/commands/milestone.rb
+- lib/ghi/commands/open.rb
+- lib/ghi/commands/show.rb
+- lib/ghi/commands/version.rb
+- lib/ghi/commands.rb
+- lib/ghi/formatting/colors.rb
+- lib/ghi/formatting.rb
+- lib/ghi/json.rb
 - lib/ghi.rb
-- spec/ghi/api_spec.rb
-- spec/ghi/cli_spec.rb
-- spec/ghi/issue_spec.rb
-- spec/ghi_spec.rb
-- README.rdoc
-homepage: http://github.com/stephencelis/ghi
+- bin/ghi
+has_rdoc: true
+homepage: https://github.com/stephencelis/ghi
 licenses: []
+
 post_install_message: 
-rdoc_options:
-- --main
-- README.rdoc
-require_paths:
+rdoc_options: []
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: GitHub Issues command line interface
 test_files: []
-has_rdoc: true
+

data/README.rdoc

@@ -1,126 +0,0 @@
-= ghi
-
-http://github.com/stephencelis/ghi
-
-
-GitHub Issues on the command line. Use your <tt>$EDITOR</tt>, not your
-browser.
-
-== HOW?
-
-Get:
-
-  % gem install ghi
-
-
-Go:
-
-  Usage: ghi [options]
-      -l, --list [state|term|number]
-          --search, --show
-      -v, --verbose
-          --ssl
-      -o, --open [title|number]
-          --reopen
-      -c, --closed, --close [number]
-      -e, --edit [number]
-      -r, --repo, --repository [name]
-      -m, --comment [number|comment]
-      -t, --label [number] [label]
-          --claim [number]
-      -d, --unlabel [number] [label]
-      -u, --url [state|number]
-          --[no-]color
-          --[no-]pager
-      -V, --version
-      -h, --help
-
-
-== EXAMPLE?
-
-ghi works simply from within a repository. Some short examples:
-
-  ghi -l                    # Lists all open issues
-  ghi                       # Shorter shorthand for "ghi -l"
-  ghi -v                    # Lists all open issues, verbosely (includes body)
-  ghi -lc                   # Lists all closed issues
-  ghi -l "doesn't work"     # Searches for open issues matching "doesn't work"
-  ghi -l invalid -c         # Searches for closed issues matching "invalid"
-  ghi -l1                   # Shows issue 1
-  ghi -1                    # Shorter shorthand for "ghi -l1"
-  ghi 1                     # Shorter shorthand still
-  ghi -o                    # Opens a new issue (in your $EDITOR)
-  ghi -o "New issue"        # Opens a new issue with the title "New issue"
-  ghi -o "Title" -m "Body"  # Opens a new issue with specified title and body
-  ghi -e1                   # Edits issue number 1 (in your $EDITOR)
-  ghi -e1 -m "New body"     # Edits issue number 1 with the specified body
-  ghi -c1                   # Closes issue 1
-  ghi -c1 -m                # Closes issue with comment (from your $EDITOR)
-  ghi -c1 -m "Comment"      # Closes issue with specified comment
-  ghi -o1                   # Reopens 1 (accepts comments, too)
-  ghi -m1                   # Comments on issue 1 (in your $EDITOR)
-  ghi -t1 "tag"             # Labels issue 1 with "tag"
-  ghi -d1 "tag"             # Removes the label, "tag"
-  ghi --claim 1             # Tags issue 1 with your GitHub username
-  ghi -u                    # Loads issues in your browser.
-  ghi -u1                   # Loads an issue in your browser.
-
-
-ghi also works anywhere:
-
-  ghi -rghi                 # Your fork of "ghi"
-  ghi -rstephencelis/ghi    # Mine: "stephencelis/ghi"
-  ghi stephencelis/ghi      # Shorthand to merely list open.
-
-
-ghi uses ANSI colors if you use them in git.
-
-ghi looks for a <tt>$GHI_PAGER</tt> variable for paging.
-
-Always favor SSL by setting it:
-
-  git config --global github.ssl true
-
-
-== CONTRIBUTORS
-
-* Jamie Macey (http://blog.tracefunc.com)
-* Hiroshi Nakamura (http://github.com/nahi)
-* David J. Hamilton
-
-
-=== CONTRIBUTE?
-
-Running the tests should be as simple as a `bundle` and
-`bundle exec spec spec`.
-
-ghi is not under currently under the control of any gem packaging system. To
-build, use RubyGems:
-
-  % gem build ghi.gemspec
-  % sudo gem install ghi*.gem
-
-
-== LICENSE
-
-(The MIT License)
-
-(c) 2009-* Stephen Celis, stephen@stephencelis.com.
-
-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/lib/ghi/api.rb

@@ -1,145 +0,0 @@
-require "net/https"
-require "yaml"
-require "cgi"
-
-class GHI::API
-  class GHIError < StandardError
-  end
-
-  class InvalidRequest < GHIError
-  end
-
-  class InvalidConnection < GHIError
-  end
-
-  class ResponseError < GHIError
-  end
-
-  API_HOST = "github.com"
-  API_PATH = "/api/v2/yaml/issues/:action/:user/:repo"
-
-  attr_reader :user, :repo
-
-  def initialize(user, repo, use_ssl = false)
-    raise InvalidConnection if user.nil? || repo.nil?
-    @user, @repo, @use_ssl = user, repo, use_ssl
-  end
-
-  def search(term, state = :open)
-    get(:search, state, term)["issues"].map { |attrs| GHI::Issue.new(attrs) }
-  end
-
-  def list(state = :open)
-    get(:list, state)["issues"].map { |attrs| GHI::Issue.new(attrs) }
-  end
-
-  def show(number)
-    GHI::Issue.new get(:show, number)["issue"]
-  end
-
-  def comments(number)
-    get(:comments, number)["comments"]
-  end
-
-  def open(title, body)
-    if title.empty? && body.empty?
-      raise GHIError, "Aborting request due to empty issue."
-    end
-    GHI::Issue.new post(:open, "title" => title, "body" => body)["issue"]
-  end
-
-  def edit(number, title, body)
-    if title.empty? && body.empty?
-      raise GHIError, "Aborting request due to empty issue."
-    end
-    res = post :edit, number, "title" => title, "body" => body
-    GHI::Issue.new res["issue"]
-  end
-
-  def close(number)
-    GHI::Issue.new post(:close, number)["issue"]
-  end
-
-  def reopen(number)
-    GHI::Issue.new post(:reopen, number)["issue"]
-  end
-
-  def add_label(label, number)
-    post("label/add", label, number)["labels"]
-  end
-
-  def remove_label(label, number)
-    post("label/remove", label, number)["labels"]
-  end
-
-  def comment(number, comment)
-    if comment.empty?
-      raise GHIError, "Aborting request due to empty comment."
-    end
-    post(:comment, number, "comment" => comment)["comment"]
-  end
-
-  private
-
-  def get(*args)
-    res = nil
-    http = Net::HTTP.new(API_HOST, @use_ssl ? 443 : 80)
-    http.use_ssl = true if @use_ssl
-    http.start do
-      if @use_ssl
-        req = Net::HTTP::Post.new path(*args)
-        req.set_form_data auth
-      else
-        req = Net::HTTP::Get.new(path(*args) + auth(true))
-      end
-      res = YAML.load http.request(req).body
-    end
-
-    raise ResponseError, errors(res) if res["error"] || res[:error]
-    res
-  rescue ArgumentError, URI::InvalidURIError
-    raise ResponseError, "GitHub hiccuped on your request"
-  rescue SocketError
-    raise ResponseError, "couldn't find the internet"
-  end
-
-  def post(*args)
-    params = args.last.is_a?(Hash) ? args.pop : {}
-
-    res = nil
-    http = Net::HTTP.new(API_HOST, @use_ssl ? 443 : 80)
-    http.use_ssl = true if @use_ssl
-    http.start do
-      req = Net::HTTP::Post.new path(*args)
-      req.set_form_data params.merge(auth)
-      res = YAML.load http.request(req).body
-    end
-
-    raise ResponseError, errors(res) if res["error"] || res[:error]
-    res
-  rescue ArgumentError, URI::InvalidURIError
-    raise ResponseError, "GitHub hiccuped on your request"
-  rescue SocketError
-    raise ResponseError, "couldn't find the internet"
-  end
-
-  def errors(response)
-    return response[:error] if response.key? :error
-    [*response["error"]].map { |e| e["error"] } * ", "
-  end
-
-  def auth(query = false)
-    if query
-      "?login=#{GHI.login}&token=#{GHI.token}"
-    else
-      { "login" => GHI.login, "token" => GHI.token }
-    end
-  end
-
-  def path(action, *args)
-    @path ||= API_PATH.sub(":user", user).sub(":repo", repo)
-    path  = @path.sub ":action", action.to_s
-    path << "/#{args.join("/")}" unless args.empty?
-    path
-  end
-end

data/lib/ghi/cli.rb

@@ -1,657 +0,0 @@
-require "optparse"
-require "tempfile"
-require "ghi"
-require "ghi/api"
-require "ghi/issue"
-
-begin
-  require "launchy"
-rescue LoadError
-  # No launchy!
-end
-
-module GHI::CLI #:nodoc:
-  module FileHelper
-    def launch_editor(file)
-      system "#{editor} #{file.path}"
-    end
-
-    def gets_from_editor(issue)
-      if windows?
-        warn "Please supply the message with the -m option"
-        exit 1
-      end
-
-      if in_repo?
-        File.open message_path, "a+", &file_proc(issue)
-      else
-        Tempfile.open message_filename, &file_proc(issue)
-      end
-
-      return @message if comment?
-      return @message.shift.strip, @message.join.sub(/\b\n\b/, " ").strip
-    end
-
-    def delete_message
-      File.delete message_path
-    rescue Errno::ENOENT, TypeError
-      nil
-    end
-
-    def message_path
-      File.join gitdir, message_filename
-    end
-
-    private
-
-    def editor
-      ENV["GHI_EDITOR"] || ENV["GIT_EDITOR"] ||
-        `git config --get-all core.editor`.split.first || ENV["EDITOR"] || "vi"
-    end
-
-    def gitdir
-      @gitdir ||= `git rev-parse --git-dir 2>/dev/null`.chomp
-    end
-
-    def message_filename
-      @message_filename ||= "GHI_#{action.to_s.upcase}#{number}_MESSAGE"
-    end
-
-    def file_proc(issue)
-      lambda do |file|
-        file << edit_format(issue).join("\n") if File.zero? file.path
-        file.rewind
-        launch_editor file
-        @message = File.readlines(file.path).find_all { |l| !l.match(/^#/) }
-
-        if message.to_s =~ /\A\s*\Z/
-          raise GHI::API::InvalidRequest, "can't file empty message"
-        end
-        raise GHI::API::InvalidRequest, "no change" if issue == message
-      end
-    end
-
-    def in_repo?
-      !gitdir.empty? && user == local_user && repo == local_repo
-    end
-  end
-
-  module FormattingHelper
-    def list_header(term = nil)
-      if term
-        "# #{state.to_s.capitalize} #{term.inspect} issues on #{user}/#{repo}"
-      else
-        "# #{state.to_s.capitalize} issues on #{user}/#{repo}"
-      end
-    end
-
-    def list_format(issues, verbosity = nil)
-      unless issues.empty?
-        if verbosity
-          issues.map { |i| ["=" * 79] + show_format(i) }
-        else
-          issues.map { |i| "  #{i.number.to_s.rjust 3}: #{truncate(i.title, 72)} #{label_format(i.labels)}" }
-        end
-      else
-        "none"
-      end
-    end
-    
-    def label_format(labels)
-      labels and labels.map {|l| "[#{l}]"}.join(' ')
-    end
-
-    def edit_format(issue)
-      l = []
-      l << issue.title if issue.title && !comment?
-      l << ""
-      l << issue.body  if issue.body  && !comment?
-      if comment?
-        l << "# Please enter your comment."
-      else
-        l << "# Please explain the issue. The first line will become the title."
-      end
-      l << "# Lines beginning '#' will be ignored; ghi aborts empty messages."
-      l << "# All line breaks will be honored in accordance with GFM:"
-      l << "#"
-      l << "#   http://github.github.com/github-flavored-markdown"
-      l << "#"
-      l << "# On #{user}/#{repo}:"
-      l << "#"
-      l += show_format(issue, false).map { |line| "# #{line}" }
-    end
-
-    def show_format(issue, verbose = true)
-      l = []
-      l << "      number:  #{issue.number}"                    if issue.number
-      l << "       state:  #{issue.state}"                     if issue.state
-      l << "       title:  #{indent(issue.title, 15, 0).join}" if issue.title
-      l << "      labels:  #{label_format(issue.labels)}"      unless issue.labels.nil? || issue.labels.empty?
-      l << "        user:  #{issue.user || GHI.login}"
-      l << "       votes:  #{issue.votes}"                     if issue.votes
-      l << "  created at:  #{issue.created_at}"                if issue.created_at
-      l << "  updated at:  #{issue.updated_at}"                if issue.updated_at
-      return l unless verbose
-      l << ""
-      l += indent(issue.body)[0..-2]
-
-      comments = api.comments(issue.number)
-      unless comments.empty?
-        l << "=" * 79
-        comments.each do |c|
-          l << "#{c["user"]} commented:"
-          l << ""
-          l += indent(c["body"])
-          l << "-" * 79
-        end
-      end
-
-      l
-    end
-
-    def action_format(value = nil)
-      key = "#{action.to_s.capitalize.sub(/e?$/, "ed")} issue #{number}"
-      "#{key}: #{truncate(value.to_s, 78 - key.length)}"
-    end
-
-    def truncate(string, length)
-      result = string.scan(/.{0,#{length - 3}}(?:\s|\Z)/).first.strip
-      result << "..." if result != string
-      result
-    end
-
-    def indent(string, level = 4, first = level)
-      string = string.gsub(/\n{3,}/, "\n\n")
-      lines = string.scan(/.{0,#{79 - level}}(?:\s|\Z)/).map { |line|
-        " " * level + line
-      }
-      lines.first.sub!(/^\s+/) {} if first != level
-      lines
-    end
-
-    private
-
-    def comment?
-      ![:open, :edit].include?(action)
-    end
-
-    def puts(*args)
-      args = args.flatten.each { |arg|
-        arg.gsub!(/\b\*(.+)\*\b/) { "\e[1m#$1\e[0m" } # Bold
-        arg.gsub!(/\b_(.+)_\b/) { "\e[4m#$1\e[0m" } # Underline
-        arg.gsub!(/(state:)?(# Open.*|  open)$/) { "#$1\e[32m#$2\e[0m" }
-        arg.gsub!(/(state:)?(# Closed.*|  closed)$/) { "#$1\e[31m#$2\e[0m" }
-        marked = [GHI.login, search_term, tag, "(?:#|gh)-\d+"].compact * "|"
-        unless arg.include? "\e"
-          arg.gsub!(/(#{marked})/i) { "\e[1;4;33m#{$&}\e[0m" }
-        end
-      } if colorize?
-    rescue NoMethodError
-      # Do nothing.
-    ensure
-      $stdout.puts(*args)
-    end
-
-    def colorize?
-      return @colorize if defined? @colorize
-      @colorize = if $stdout.isatty && !windows?
-        !`git config --get-regexp color`.chomp.empty?
-      else
-        false
-      end
-    end
-
-    def prepare_stdout
-      return if @prepared || @no_pager || !$stdout.isatty || pager.nil?
-      colorize? # Check for colorization.
-      $stdout = pager
-      @prepared = true
-    end
-
-    def pager
-      return @pager if defined? @pager
-      pager = ENV["GHI_PAGER"] || ENV["GIT_PAGER"] ||
-        `git config --get-all core.pager`.split.first || ENV["PAGER"] ||
-        "less -EMRX"
-
-      @pager = IO.popen(pager, "w")
-    end
-
-    def windows?
-      RUBY_PLATFORM.include? "mswin"
-    end
-  end
-
-  class Executable
-    include FileHelper, FormattingHelper
-
-    attr_reader :message, :local_user, :local_repo, :user, :repo, :api,
-      :action, :search_term, :number, :title, :body, :tag, :args, :verbosity,
-      :use_ssl
-
-    def parse!(*argv)
-      @args, @argv = argv, argv.dup
-
-      remotes = `git config --get-regexp remote\..+\.url`.split /\n/
-      repo_expression = %r{([^:/]+)/([^/\s]+?)(?:\.git)?$}
-      if remote = remotes.find { |r| r.include? "github.com" }
-        remote.match repo_expression
-        @user, @repo = $1, $2
-      end
-
-      option_parser.parse!(*args)
-
-      if action.nil? && fallback_parsing(*args).nil?
-        puts option_parser
-        exit
-      end
-    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => e
-      if fallback_parsing(*e.args).nil?
-        warn "#{File.basename $0}: #{e.message}"
-        puts option_parser
-        exit 1
-      end
-    rescue OptionParser::MissingArgument, OptionParser::AmbiguousOption => e
-      warn "#{File.basename $0}: #{e.message}"
-      puts option_parser
-      exit 1
-    ensure
-      run!
-      $stdout.close_write
-    end
-
-    def run!
-      @api = GHI::API.new user, repo, use_ssl
-
-      case action
-        when :search        then search
-        when :list          then list
-        when :show          then show
-        when :open          then open
-        when :edit          then edit
-        when :close         then close
-        when :reopen        then reopen
-        when :comment       then prepare_comment && comment
-        when :label, :claim then prepare_label   && label
-        when :unlabel       then prepare_label   && unlabel
-        when :url           then url
-      end
-    rescue GHI::API::InvalidConnection
-      if action
-        code = 1
-        warn "#{File.basename $0}: not a GitHub repo"
-        puts option_parser if args.flatten.empty?
-        exit 1
-      end
-    rescue GHI::API::InvalidRequest => e
-      warn "#{File.basename $0}: #{e.message} (#{user}/#{repo})"
-      delete_message
-      exit 1
-    rescue GHI::API::ResponseError => e
-      warn "#{File.basename $0}: #{e.message} (#{user}/#{repo})"
-      exit 1
-    rescue GHI::API::GHIError => e
-      warn e.message
-      exit 1
-    end
-
-    def commenting?
-      @commenting
-    end
-
-    def state
-      @state || :open
-    end
-
-    private
-
-    def option_parser
-      @option_parser ||= OptionParser.new { |opts|
-        opts.banner = "Usage: #{File.basename $0} [options]"
-
-        opts.on("-l", "--list", "--search", "--show [state|term|number]") do |v|
-          @action = :list
-          case v
-          when nil, /^o(?:pen)?$/
-            # Defaults.
-          when /^\d+$/
-            @action = :show
-            @number = v.to_i
-          when /^c(?:losed)?$/
-            @state = :closed
-          when /^[uw]$/
-            @action = :url
-          when /^v$/
-            @verbosity = true
-          else
-            @action = :search
-            @search_term = v
-          end
-        end
-
-        opts.on("-v", "--verbose") do |v|
-          if v
-            @action ||= :list
-            @verbosity = true
-          end
-        end
-
-        opts.on("--ssl") do |ssl|
-          @use_ssl = true
-        end
-
-        opts.on("-o", "--open", "--reopen [title|number]") do |v|
-          @action = :open
-          case v
-          when /^\d+$/
-            @action = :reopen
-            @number = v.to_i
-          when /^l$/
-            @action = :list
-          when /^m$/
-            @title = args * " "
-          when /^[uw]$/
-            @action = :url
-          else
-            @title = v
-          end
-        end
-
-        opts.on("-c", "--closed", "--close [number]") do |v|
-          case v
-          when /^\d+$/
-            @action = :close
-            @number = v.to_i unless v.nil?
-          when /^l$/
-            @action = :list
-            @state = :closed
-          when /^[uw]$/
-            @action = :url
-            @state = :closed
-          when nil
-            if @action.nil? || @number
-              @action = :close
-            else
-              @state = :closed
-            end
-          else
-            raise OptionParser::InvalidArgument
-          end
-        end
-
-        opts.on("-e", "--edit [number]") do |v|
-          case v
-          when /^\d+$/
-            @action = :edit
-            @number = v.to_i
-          when nil
-            raise OptionParser::MissingArgument
-          else
-            raise OptionParser::InvalidArgument
-          end
-        end
-
-        opts.on("-r", "--repo", "--repository [name]") do |v|
-          case v
-          when nil
-            raise OptionParser::MissingArgument
-          else
-            repo = v.split "/"
-            if repo.length == 1
-              if @repo && `git remote 2>/dev/null`[/^#{repo}$/]
-                repo << @repo
-              else
-                repo.unshift(GHI.login)
-              end
-            end
-            @user, @repo = repo
-          end
-        end
-
-        opts.on("-m", "--comment [number|comment]") do |v|
-          case v
-          when /^\d+$/, nil
-            @action ||= :comment
-            @number ||= v.to_i unless v.nil?
-            @commenting = true
-          else
-            @body = v
-          end
-        end
-
-        opts.on("-t", "--label [number] [label]") do |v|
-          raise OptionParser::MissingArgument if v.nil?
-          @action ||= :label
-          @number = v.to_i
-        end
-
-        opts.on("--claim [number]") do |v|
-          raise OptionParser::MissingArgument if v.nil?
-          @action = :claim
-          @number = v.to_i
-          @tag = GHI.login
-        end
-
-        opts.on("-d", "--unlabel [number] [label]") do |v|
-          @action = :unlabel
-          case v
-          when /^\d+$/
-            @number = v.to_i
-          when /^\w+$/
-            @tag = v
-          end
-        end
-
-        opts.on("-u", "-w", "--url", "--web [state|number]") do |v|
-          @action = :url
-          case v
-          when /^\d+$/
-            @number = v.to_i
-          when /^c(?:losed)?$/
-            @state = :closed
-          when /^u(?:nread)?$/
-            @state = :unread
-          end
-        end
-
-        opts.on("--[no-]color") do |v|
-          @colorize = v
-        end
-
-        opts.on("--[no-]pager") do |v|
-          @no_pager = (v == false)
-        end
-
-        opts.on_tail("-V", "--version") do
-          puts "#{File.basename($0)}: v#{GHI::VERSION}"
-          exit
-        end
-
-        opts.on_tail("-h", "--help") do
-          puts opts
-          exit
-        end
-      }
-    end
-
-    def search
-      prepare_stdout
-      puts list_header(search_term)
-      issues = api.search search_term, state
-      puts list_format(issues, verbosity)
-    end
-
-    def list
-      prepare_stdout
-      puts list_header
-      issues = api.list(state)
-      puts list_format(issues, verbosity)
-    end
-
-    def show
-      prepare_stdout
-      issue = api.show number
-      puts show_format(issue)
-    end
-
-    def open
-      if title.nil?
-        new_title, new_body = gets_from_editor GHI::Issue.new("title" => body)
-      elsif @commenting && body.nil?
-        new_title, new_body = gets_from_editor GHI::Issue.new("title" => title)
-      end
-      new_title ||= title
-      new_body  ||= body
-      issue = api.open new_title, new_body
-      delete_message
-      @number = issue.number
-      puts action_format(issue.title)
-    end
-
-    def edit
-      shown = api.show number
-      new_title, new_body = gets_from_editor(shown) if body.nil?
-      new_title ||= shown.title
-      new_body  ||= body
-      issue = api.edit number, new_title, new_body
-      delete_message
-      puts action_format(issue.title)
-    end
-
-    def close
-      raise GHI::API::InvalidRequest, "need a number" if number.nil?
-      issue = api.close number
-      if @commenting || new_body = body
-        new_body ||= gets_from_editor issue
-        comment = api.comment number, new_body
-      end
-      puts action_format(issue.title)
-      puts "(commented)" if comment
-    end
-
-    def reopen
-      issue = api.reopen number
-      if @commenting || new_body = body
-        new_body ||= gets_from_editor issue
-        comment = api.comment number, new_body
-      end
-      puts action_format(issue.title)
-      puts "(commented)" if comment
-    end
-
-    def prepare_label
-      @tag ||= (body || args * " ")
-      raise GHI::API::InvalidRequest, "need a label" if @tag.empty?
-      true
-    end
-
-    def label
-      labels = api.add_label tag, number
-      puts action_format
-      puts indent(labels.join(", "))
-    end
-
-    def unlabel
-      labels = api.remove_label tag, number
-      puts action_format
-      puts indent(labels.empty? ? "no labels" : labels.join(", "))
-    end
-
-    def prepare_comment
-      @body = args.flatten.first
-      @commenting = false unless body.nil?
-      true
-    end
-
-    def comment
-      @body ||= gets_from_editor api.show(number)
-      comment = api.comment(number, body)
-      delete_message
-      puts "(comment})"
-    end
-
-    def url
-      url = "https://github.com/#{user}/#{repo}/issues"
-      if number.nil?
-        url << "/#{state}" unless state == :open
-      else
-        url << "/#{number}"
-      end
-      defined?(Launchy) ? Launchy.open(url) : puts(url)
-    end
-
-    #-
-    # Because these are mere fallbacks, any options used earlier will muddle
-    # things: `ghi list` will work, `ghi list -c` will not.
-    #
-    # Argument parsing will have to better integrate with option parsing to
-    # overcome this.
-    #+
-    def fallback_parsing(*arguments)
-      arguments = arguments.flatten
-      case command = arguments.shift
-      when nil, "list"
-        @action = :list
-        if arg = arguments.shift
-          @state ||= arg.to_sym if %w(open closed).include? arg
-          @user, @repo = arg.split "/" if arg.count("/") == 1
-        end
-      when "search"
-        @action = :search
-        @search_term ||= arguments.shift
-      when "show", /^-?(\d+)$/
-        @action = :show
-        @number ||= ($1 || arguments.shift[/\d+/]).to_i
-      when "open"
-        if arguments.first =~ /^\d+$/
-          @action = :reopen
-          @number ||= arguments.shift[/\d+/].to_i
-        else
-          @action = :open
-          @title = arguments.join(' ')
-        end
-      when "edit"
-        @action = :edit
-        @number ||= arguments.shift[/\d+/].to_i
-      when "close"
-        @action = :close
-        @number ||= arguments.shift[/\d+/].to_i
-      when "reopen"
-        @action = :reopen
-        @number ||= arguments.shift[/\d+/].to_i
-      when "label"
-        @action = :label
-        @number ||= arguments.shift[/\d+/].to_i
-        @label ||= arguments.shift
-      when "unlabel"
-        @action = :unlabel
-        @number ||= arguments.shift[/\d+/].to_i
-        @label ||= arguments.shift
-      when "comment"
-        @action = :comment
-        @number ||= arguments.shift[/\d+/].to_i
-      when "claim"
-        @action = :claim
-        @number ||= arguments.shift[/\d+/].to_i
-      when %r{^([^/]+)/([^/]+)$}
-        @action = :list
-        @user, @repo = $1, $2
-      when "url", "web"
-        @action = :url
-        @number ||= arguments.shift[/\d+/].to_i
-      end
-
-      @use_ssl ||= `git config github.ssl`.chomp == 'true'
-
-      if @action
-        @args = @argv.dup
-        args.delete_if { |arg| arg == command }
-        option_parser.parse!(*args)
-        return true
-      end
-      unless command.start_with? "-"
-        warn "#{File.basename $0}: what do you mean, '#{command}'?"
-      end
-    end
-  end
-end