ghi 0.3.1 → 0.9.0.dev

data/bin/ghi

@@ -1,6 +1,4 @@
 #!/usr/bin/env ruby
 
-$: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-require "ghi/cli"
-$stdout.sync = true
-GHI::CLI::Executable.new.parse!(ARGV)
+require 'ghi'
+GHI.execute ARGV

data/lib/ghi.rb

@@ -1,57 +1,127 @@
-require "net/http"
-require "yaml"
-YAML::ENGINE.yamler = "syck" if YAML.const_defined? :ENGINE
+require 'optparse'
 
 module GHI
-  VERSION = "0.3.1"
+  autoload :Authorization, 'ghi/authorization'
+  autoload :Client,        'ghi/client'
+  autoload :Commands,      'ghi/commands'
+  autoload :Formatting,    'ghi/formatting'
 
   class << self
-    def login
-      return @login if defined? @login
-      @login = ENV["GITHUB_USER"] || `git config --get github.user`.chomp
-      if @login.empty?
-        warn "Please configure your GitHub username."
-        puts
-        puts "E.g., git config --global github.user [your username]"
-        puts "Or set the environment variable GITHUB_USER"
-        abort
+    def execute args
+      STDOUT.sync = true
+
+      if index = args.index { |arg| arg !~ /^-/ }
+        command_name = args.delete_at index
+        command_args = args.slice! index, args.length
+      end
+      command_args ||= []
+
+      option_parser = OptionParser.new do |opts|
+        opts.banner = <<EOF
+usage: ghi [--version] [--help] <command> [<args>] [ -- [<user>/]<repo>]
+EOF
+#         opts.banner = <<EOF
+# usage: ghi [--version] [-p|--paginate|--no-pager] [--help] <command> [<args>]
+#            [ -- [<user>/]<repo>]
+# EOF
+        opts.on('--version') { command_name = 'version' }
+        opts.on '-p', '--paginate', '--[no-]pager' do |paginate|
+          
+        end
+        opts.on '--help' do
+          command_args.unshift(*args)
+          command_args.unshift command_name if command_name
+          args.clear
+          command_name = 'help'
+        end
+        opts.on '--[no-]color' do |colorize|
+          Formatting::Colors.colorize = colorize
+        end
+        opts.on('-v') { self.v = true }
+        opts.on('-h') { raise OptionParser::InvalidOption }
       end
-      @login
-    end
 
-    def token
-      return @token if defined? @token
-      # env values are frozen
-      @token = (ENV["GITHUB_TOKEN"] || `git config --get github.token`.chomp).dup
-      if @token.empty?
-        warn "Please configure your GitHub token."
-        puts
-        puts "E.g., git config --global github.token [your token]"
-        puts "Or set the environment variable GITHUB_TOKEN"
-        puts
-        puts "Find your token here: https://github.com/account/admin"
-        abort
-      elsif @token.sub!(/^!/, '')
-        @token = `#@token`
+      begin
+        option_parser.parse! args
+      rescue OptionParser::InvalidOption => e
+        warn e.message.capitalize
+        abort option_parser.banner
       end
-      @token
+
+      if command_name.nil? || command_name == 'help'
+        Commands::Help.execute command_args, option_parser.banner
+      else
+        command_name = fetch_alias command_name, command_args
+        begin
+          command = Commands.const_get command_name.capitalize
+        rescue NameError
+          abort "ghi: '#{command_name}' is not a ghi command. See 'ghi --help'."
+        end
+
+        # Post-command help option parsing.
+        Commands::Help.execute [command_name] if command_args.first == '--help'
+
+        begin
+          command.execute command_args
+        rescue OptionParser::ParseError, Commands::MissingArgument => e
+          warn "#{e.message.capitalize}\n"
+          abort command.new([]).options.to_s
+        rescue Client::Error => e
+          if e.response.is_a?(Net::HTTPNotFound) && Authorization.token.nil?
+            raise Authorization::Required
+          else
+            abort e.message
+          end
+        rescue SocketError => e
+          abort "Couldn't find internet."
+        rescue Errno::ECONNREFUSED => e
+          abort "Couldn't connect to GitHub."
+        rescue Errno::ETIMEDOUT => e
+          abort 'Timed out looking for GitHub.'
+        end
+      end
+    rescue Authorization::Required => e
+      retry if Authorization.authorize!
+      warn e.message
+      if Authorization.token
+        warn <<EOF
+
+Not authorized for this action with your token. To regenerate a new token:
+EOF
+      end
+      warn <<EOF
+
+Please run 'ghi config --auth <username>:<password>'
+EOF
+      exit 1
     end
 
+    attr_accessor :v
+    alias v? v
+
     private
 
-    def user?(username)
-      url = "http://github.com/api/v2/yaml/user/show/#{username}"
-      !YAML.load(Net::HTTP.get(URI.parse(url)))["user"].nil?
-    rescue ArgumentError, URI::InvalidURIError
-      false
-    end
+    ALIASES = {
+      'c'        => %w(close),
+      'claim'    => %w(assign),
+      'e'        => %w(edit),
+      'l'        => %w(list),
+      'L'        => %w(label),
+      'm'        => %w(comment),
+      'o'        => %w(open),
+      'reopen'   => %w(open),
+      'rm'       => %w(close),
+      's'        => %w(show),
+      'st'       => %w(list),
+      'tag'      => %w(label),
+      'unassign' => %w(assign -d)
+    }
 
-    def token?(token)
-      url  = "http://github.com/api/v2/yaml/user/show/#{login}"
-      url += "?login=#{login}&token=#{token}"
-      !YAML.load(Net::HTTP.get(URI.parse(url)))["user"]["plan"].nil?
-    rescue ArgumentError, NoMethodError, URI::InvalidURIError
-      false
+    def fetch_alias command, args
+      return command unless fetched = ALIASES[command]
+      command = fetched.shift
+      args.unshift(*fetched)
+      command
     end
   end
 end

data/lib/ghi/authorization.rb

@@ -0,0 +1,71 @@
+module GHI
+  module Authorization
+    extend Formatting
+
+    class Required < RuntimeError
+    end
+
+    class << self
+      def token
+        return @token if defined? @token
+        @token = config 'ghi.token'
+      end
+
+      def authorize! user = username, pass = password, local = true
+        return false unless user && pass
+
+        res = throb {
+          Client.new(user, pass).post(
+            '/authorizations',
+            :scopes   => %w(public_repo repo),
+            :note     => 'ghi',
+            :note_url => 'https://github.com/stephencelis/ghi'
+          )
+        }
+        @token = res['token']
+        
+        run = []
+        unless username
+          run << "git config#{' --global ' unless local} github.user #{user}"
+        end
+        run << "git config#{' --global ' unless local} ghi.token #{token}"
+
+        system run.join('; ')
+
+        unless local
+          at_exit do
+            warn <<EOF
+Your ~/.gitconfig has been modified by way of:
+
+  #{run.join "\n  "}
+
+#{bright { blink { 'Do not check this change into public source control!' } }}
+Alternatively, set the following env var in a private dotfile:
+
+  export GHI_TOKEN="#{token}"
+EOF
+          end
+        end
+      rescue Client::Error => e
+        abort e.message
+      end
+
+      def username
+        return @username if defined? @username
+        @username = config 'github.user'
+      end
+
+      def password
+        return @password if defined? @password
+        @password = config 'github.password'
+      end
+
+      private
+
+      def config key
+        value = ENV["#{key.upcase.gsub '.', '_'}"] || `git config #{key}`.chomp
+        value unless value.empty?
+      end
+    end
+  end
+end

data/lib/ghi/client.rb

@@ -0,0 +1,126 @@
+require 'cgi'
+require 'net/https'
+
+unless defined? Net::HTTP::Patch
+  Net::HTTP::Patch = Class.new Net::HTTP::Post do
+    METHOD = 'PATCH'
+  end
+end
+
+module GHI
+  class Client
+    autoload :JSON, 'ghi/json'
+
+    class Error < RuntimeError
+      attr_reader :response
+      def initialize response
+        @response, @json = response, JSON.parse(response.body)
+      end
+
+      def body()    @json             end
+      def message() body['message']   end
+      def errors()  [*body['errors']] end
+    end
+
+    class Response
+      def initialize response
+        @response = response
+      end
+
+      def body
+        @body ||= JSON.parse @response.body
+      end
+
+      def next_page() links['next'] end
+      def last_page() links['last'] end
+
+      private
+
+      def links
+        return @links if defined? @links
+        @links = {}
+        if links = @response['Link']
+          links.scan(/<([^>]+)>; rel="([^"]+)"/).each { |l, r| @links[r] = l }
+        end
+        @links
+      end
+    end
+
+    CONTENT_TYPE = 'application/vnd.github+json'
+    METHODS = {
+      :head   => Net::HTTP::Head,
+      :get    => Net::HTTP::Get,
+      :post   => Net::HTTP::Post,
+      :put    => Net::HTTP::Put,
+      :patch  => Net::HTTP::Patch,
+      :delete => Net::HTTP::Delete
+    }
+
+    attr_reader :username, :password
+    def initialize username = nil, password = nil
+      @username, @password = username, password
+    end
+
+    def head path, options = {}
+      request :head, path, options
+    end
+
+    def get path, params = {}, options = {}
+      request :get, path, options.merge(:params => params)
+    end
+
+    def post path, body = nil, options = {}
+      request :post, path, options.merge(:body => body)
+    end
+
+    def put path, body = nil, options = {}
+      request :put, path, options.merge(:body => body)
+    end
+
+    def patch path, body = nil, options = {}
+      request :patch, path, options.merge(:body => body)
+    end
+
+    def delete path, options = {}
+      request :delete, path, options
+    end
+
+    private
+
+    def request method, path, options
+      if params = options[:params] and !params.empty?
+        q = params.map { |k, v| "#{CGI.escape k.to_s}=#{CGI.escape v.to_s}" }
+        path += "?#{q.join '&'}"
+      end
+
+      req = METHODS[method].new path, 'Accept' => CONTENT_TYPE
+      if GHI::Authorization.token
+        req['Authorization'] = "token #{GHI::Authorization.token}"
+      end
+      if options.key? :body
+        req['Content-Type'] = CONTENT_TYPE
+        req.body = options[:body] ? JSON.dump(options[:body]) : ''
+      end
+      req.basic_auth username, password if username && password
+
+      http = Net::HTTP.new 'api.github.com', 443
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE # FIXME 1.8.7
+
+      GHI.v? and puts "===> #{method.to_s.upcase} #{path} #{req.body}"
+      res = http.start { http.request req }
+      GHI.v? and puts "<=== #{res.code}: #{res.body}"
+
+      case res
+      when Net::HTTPSuccess
+        return Response.new(res)
+      when Net::HTTPUnauthorized
+        if password.nil?
+          raise Authorization::Required, 'Authorization required'
+        end
+      end
+
+      raise Error, res
+    end
+  end
+end

data/lib/ghi/commands.rb

@@ -0,0 +1,20 @@
+module GHI
+  module Commands
+    autoload :Command,   'ghi/commands/command'
+
+    autoload :List,      'ghi/commands/list'
+    autoload :Open,      'ghi/commands/open'
+    autoload :Assign,    'ghi/commands/assign'
+    autoload :Close,     'ghi/commands/close'
+    autoload :Comment,   'ghi/commands/comment'
+    autoload :Config,    'ghi/commands/config'
+    autoload :Edit,      'ghi/commands/edit'
+    autoload :Help,      'ghi/commands/help'
+    autoload :Label,     'ghi/commands/label'
+    autoload :Milestone, 'ghi/commands/milestone'
+    autoload :Reopen,    'ghi/commands/reopen'
+    autoload :Show,      'ghi/commands/show'
+    autoload :Unassign,  'ghi/commands/unassign'
+    autoload :Version,   'ghi/commands/version'
+  end
+end

data/lib/ghi/commands/assign.rb

@@ -0,0 +1,53 @@
+module GHI
+  module Commands
+    class Assign < Command
+      def options
+        OptionParser.new do |opts|
+          opts.banner = <<EOF
+usage: ghi assign [options] [<issueno>]
+   or: ghi assign <issueno> <user>
+   or: ghi unassign <issueno>
+EOF
+          opts.separator ''
+          opts.on(
+            '-u', '--assignee <user>', 'assign to specified user'
+          ) do |assignee|
+            assigns[:assignee] = assignee
+          end
+          opts.on '-d', '--no-assignee', 'unassign this issue' do
+            assigns[:assignee] = nil
+          end
+          opts.on '-l', '--list', 'list assigned issues' do
+            self.action = 'list'
+          end
+          opts.separator ''
+        end
+      end
+
+      def execute
+        self.action = 'edit'
+        assigns[:args] = []
+
+        require_repo
+        extract_issue
+        options.parse! args
+
+        unless assigns.key? :assignee
+          assigns[:assignee] = args.pop || Authorization.username
+        end
+        if assigns.key? :assignee
+          assigns[:args].concat(
+            assigns[:assignee] ? %W(-u #{assigns[:assignee]}) : %w(--no-assign)
+          )
+        end
+        assigns[:args] << issue if issue
+        assigns[:args].concat %W(-- #{repo})
+
+        case action
+          when 'list' then List.execute assigns[:args]
+          when 'edit' then Edit.execute assigns[:args]
+        end
+      end
+    end
+  end
+end