ghi 0.2.0 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf60dfd0d186793f1f58e67aaf6e02c15099eb6a
+  data.tar.gz: f159c9cb960dc248c8dcdfef7efe827089257275
+SHA512:
+  metadata.gz: 0b0b760af55aec8b781b40932dd08d65122d2c2db8b5a73aabf83dbe82273c80a8c3a8fed1fdcbe24458f682dfa6d67ed55f08024de060d0176902117cf12c0b
+  data.tar.gz: 62776a3dfc2adbac46b59eff82181027e57355dd38ff9d79c6a7a732334855a415d61bc9898ebfec187b68f320f7f5525108e1e01ea770204c601439b9624864

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)
+autoload :GHI, 'ghi'
+GHI.execute ARGV

data/lib/ghi/authorization.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+require 'socket'
+
+module GHI
+  module Authorization
+    extend Formatting
+
+    class Required < RuntimeError
+      def message() 'Authorization required.' end
+    end
+
+    class << self
+      def token
+        return @token if defined? @token
+        @token = GHI.config 'ghi.token'
+      end
+
+      def authorize! user = username, pass = password, local = true
+        return false unless user && pass
+        code ||= nil # 2fa
+        args = code ? [] : [54, "✔\r"]
+        note = %w[ghi]
+        note << "(#{GHI.repo})" if local
+        note << "on #{Socket.gethostname}"
+        res = throb(*args) {
+          headers = {}
+          headers['X-GitHub-OTP'] = code if code
+          body = {
+            :scopes   => %w(public_repo repo),
+            :note     => note.join(' '),
+            :note_url => 'https://github.com/stephencelis/ghi'
+          }
+          Client.new(user, pass).post(
+            '/authorizations', body, :headers => headers
+          )
+        }
+        @token = res.body['token']
+
+        unless username
+          system "git config#{' --global' unless local} github.user #{user}"
+        end
+
+        store_token! user, token, local
+      rescue Client::Error => e
+        if e.response['X-GitHub-OTP'] =~ /required/
+          puts "Bad code." if code
+          print "Two-factor authentication code: "
+          trap('INT') { abort }
+          code = gets
+          code = '' and puts "\n" unless code
+          retry
+        end
+
+        if e.errors.any? { |err| err['code'] == 'already_exists' }
+          host = GHI.config('github.host') || 'github.com'
+          message = <<EOF.chomp
+A ghi token already exists!
+
+Please revoke all previously-generated ghi personal access tokens here:
+
+  https://#{host}/settings/tokens
+EOF
+        else
+          message = e.message
+        end
+        abort "#{message}#{CURSOR[:column][0]}"
+      end
+
+      def username
+        return @username if defined? @username
+        @username = GHI.config 'github.user'
+      end
+
+      def password
+        return @password if defined? @password
+        @password = GHI.config 'github.password'
+      end
+
+      private
+
+      def store_token! username, token, local
+        if security
+          run  = []
+
+          run << security('delete', username)
+          run << security('add', username, token)
+
+          find = security 'find', username, false
+          run << %(git config#{' --global' unless local} ghi.token "!#{find}")
+
+          system run.join ' ; '
+
+          puts "✔︎ Token saved to keychain."
+          return
+        end
+
+        command = "git config#{' --global' unless local} ghi.token #{token}"
+        system command
+
+        unless local
+          at_exit do
+            warn <<EOF
+Your ~/.gitconfig has been modified by way of:
+
+  #{command}
+
+#{bright { blink { 'Do not check this change into public source control!' } }}
+
+You can increase security by storing the token in a secure place that can be
+fetched from the command line. E.g., on OS X:
+
+  git config --global ghi.token \\
+    "!security -a #{username} -s github.com -l 'ghi token' -w"
+
+Alternatively, set the following env var in a private dotfile:
+
+  export GHI_TOKEN="#{token}"
+EOF
+          end
+        end
+      end
+
+      def security command = nil, username = nil, password = nil
+        if command.nil? && username.nil? && password.nil?
+          return system 'which security >/dev/null'
+        end
+
+        run = [
+          'security',
+          "#{command}-internet-password",
+          "-a #{username}",
+          '-s github.com',
+          "-l 'ghi token'"
+        ]
+        run << %(-w#{" #{password}" if password}) unless password.nil?
+        run << '>/dev/null 2>&1' unless command == 'find'
+
+        run.join ' '
+      end
+    end
+  end
+end

data/lib/ghi/client.rb

@@ -0,0 +1,148 @@
+require 'cgi'
+require 'net/https'
+require 'json'
+
+unless defined? Net::HTTP::Patch
+  # PATCH support for 1.8.7.
+  Net::HTTP::Patch = Class.new(Net::HTTP::Post) { METHOD = 'PATCH' }
+end
+
+module GHI
+  class Client
+
+    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.beta+json'
+    USER_AGENT = 'ghi/%s (%s; +%s)' % [
+      GHI::Commands::Version::VERSION,
+      RUBY_DESCRIPTION,
+      'https://github.com/stephencelis/ghi'
+    ]
+    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
+    }
+    DEFAULT_HOST = 'api.github.com'
+    HOST = GHI.config('github.host') || DEFAULT_HOST
+    PORT = 443
+
+    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
+      path = "/api/v3#{path}" if HOST != DEFAULT_HOST
+
+      path = URI.escape path
+      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
+
+      headers = options.fetch :headers, {}
+      headers.update 'Accept' => CONTENT_TYPE, 'User-Agent' => USER_AGENT
+      req = METHODS[method].new path, headers
+      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
+
+      proxy   = GHI.config 'https.proxy', :upcase => false
+      proxy ||= GHI.config 'http.proxy',  :upcase => false
+      if proxy
+        proxy = URI.parse proxy
+        http = Net::HTTP::Proxy(proxy.host, proxy.port).new HOST, PORT
+      else
+        http = Net::HTTP.new HOST, PORT
+      end
+
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE # FIXME 1.8.7
+
+      GHI.v? and puts "\r===> #{method.to_s.upcase} #{path} #{req.body}"
+      res = http.start { http.request req }
+      GHI.v? and puts "\r<=== #{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
+      when Net::HTTPMovedPermanently
+        return Response.new(http.get(res['location']))
+      end
+
+      raise Error, res
+    end
+  end
+end

data/lib/ghi/commands/assign.rb

@@ -0,0 +1,54 @@
+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[:assignee].sub! /^@/, '' if assigns[: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

data/lib/ghi/commands/close.rb

@@ -0,0 +1,51 @@
+module GHI
+  module Commands
+    class Close < Command
+      attr_accessor :web
+
+      def options
+        OptionParser.new do |opts|
+          opts.banner = <<EOF
+usage: ghi close [options] <issueno>
+EOF
+          opts.separator ''
+          opts.on '-l', '--list', 'list closed issues' do
+            assigns[:command] = List
+          end
+          opts.on('-w', '--web') { self.web = true }
+          opts.separator ''
+          opts.separator 'Issue modification options'
+          opts.on '-m', '--message [<text>]', 'close with message' do |text|
+            assigns[:comment] = text
+          end
+          opts.separator ''
+        end
+      end
+
+      def execute
+        options.parse! args
+        require_repo
+
+        if list?
+          args.unshift(*%W(-sc -- #{repo}))
+          args.unshift '-w' if web
+          List.execute args
+        else
+          require_issue
+          if assigns.key? :comment
+            Comment.execute [
+              issue, '-m', assigns[:comment], '--', repo
+            ].compact
+          end
+          Edit.execute %W(-sc #{issue} -- #{repo})
+        end
+      end
+
+      private
+
+      def list?
+        assigns[:command] == List
+      end
+    end
+  end
+end

data/lib/ghi/commands/command.rb

@@ -0,0 +1,133 @@
+module GHI
+  module Commands
+    class MissingArgument < RuntimeError
+    end
+
+    class Command
+      include Formatting
+
+      class << self
+        attr_accessor :detected_repo
+
+        def execute args
+          command = new args
+          if i = args.index('--')
+            command.repo = args.slice!(i, args.length)[1] # Raise if too many?
+          end
+          command.execute
+        end
+      end
+
+      attr_reader :args
+      attr_writer :issue
+      attr_accessor :action
+      attr_accessor :verbose
+
+      def initialize args
+        @args = args.map! { |a| a.dup }
+      end
+
+      def assigns
+        @assigns ||= {}
+      end
+
+      def api
+        @api ||= Client.new
+      end
+
+      def repo
+        return @repo if defined? @repo
+        @repo = GHI.config('ghi.repo', :flags => '--local') || detect_repo
+        if @repo && !@repo.include?('/')
+          @repo = [Authorization.username, @repo].join '/'
+        end
+        @repo
+      end
+      alias extract_repo repo
+
+      def repo= repo
+        @repo = repo.dup
+        unless @repo.include? '/'
+          @repo.insert 0, "#{Authorization.username}/"
+        end
+        @repo
+      end
+
+      private
+
+      def require_repo
+        return true if repo
+        warn 'Not a GitHub repo.'
+        warn ''
+        abort options.to_s
+      end
+
+      def require_repo_name
+        require_repo
+        repo_array = repo.partition "/"
+        if repo_array.length >= 2
+          repo_name = repo_array[2]
+        else
+          repo_name = nil
+        end
+        return repo_name
+      end
+        
+      def detect_repo
+        remote   = remotes.find { |r| r[:remote] == 'upstream' }
+        remote ||= remotes.find { |r| r[:remote] == 'origin' }
+        remote ||= remotes.find { |r| r[:user]   == Authorization.username }
+        Command.detected_repo = true and remote[:repo] if remote
+      end
+
+      def remotes
+        return @remotes if defined? @remotes
+        @remotes = `git config --get-regexp remote\..+\.url`.split "\n"
+        github_host = GHI.config('github.host') || 'github.com'
+        @remotes.reject! { |r| !r.include? github_host}
+        @remotes.map! { |r|
+          remote, user, repo = r.scan(
+            %r{remote\.([^\.]+)\.url .*?([^:/]+)/([^/\s]+?)(?:\.git)?$}
+          ).flatten
+          { :remote => remote, :user => user, :repo => "#{user}/#{repo}" }
+        }
+        @remotes
+      end
+
+      def issue
+        return @issue if defined? @issue
+        if index = args.index { |arg| /^\d+$/ === arg }
+          @issue = args.delete_at index
+        else
+          infer_issue_from_branch_prefix
+        end
+        @issue
+      end
+      alias extract_issue     issue
+      alias milestone         issue
+      alias extract_milestone issue
+
+      def infer_issue_from_branch_prefix
+        @issue = `git symbolic-ref --short HEAD 2>/dev/null`[/^\d+/];
+        warn "(Inferring issue from branch prefix: ##@issue)" if @issue
+      end
+
+      def require_issue
+        raise MissingArgument, 'Issue required.' unless issue
+      end
+
+      def require_milestone
+        raise MissingArgument, 'Milestone required.' unless milestone
+      end
+
+      # Handles, e.g. `--[no-]milestone [<n>]`.
+      def any_or_none_or input
+        input ? input : { nil => '*', false => 'none' }[input]
+      end
+
+      def sort_by_creation(arr)
+        arr.sort_by { |el| el['created_at'] }
+      end
+    end
+  end
+end