hub 1.8.4 → 1.9.0

data/lib/hub/github_api.rb

@@ -0,0 +1,359 @@
+require 'uri'
+require 'yaml'
+require 'forwardable'
+require 'fileutils'
+
+module Hub
+  # Client for the GitHub v3 API.
+  #
+  # First time around, user gets prompted for username/password in the shell.
+  # Then this information is exchanged for an OAuth token which is saved in a file.
+  #
+  # Examples
+  #
+  #   @api_client ||= begin
+  #     config_file = ENV['HUB_CONFIG'] || '~/.config/hub'
+  #     file_store = GitHubAPI::FileStore.new File.expand_path(config_file)
+  #     file_config = GitHubAPI::Configuration.new file_store
+  #     GitHubAPI.new file_config, :app_url => 'http://defunkt.io/hub/'
+  #   end
+  class GitHubAPI
+    attr_reader :config, :oauth_app_url
+
+    # Public: Create a new API client instance
+    #
+    # Options:
+    # - config: an object that implements:
+    #   - username(host)
+    #   - api_token(host, user)
+    #   - password(host, user)
+    #   - oauth_token(host, user)
+    def initialize config, options
+      @config = config
+      @oauth_app_url = options.fetch(:app_url)
+    end
+
+    # Fake exception type for net/http exception handling.
+    # Necessary because net/http may or may not be loaded at the time.
+    module Exceptions
+      def self.===(exception)
+        exception.class.ancestors.map {|a| a.to_s }.include? 'Net::HTTPExceptions'
+      end
+    end
+
+    def api_host host
+      host = host.downcase
+      'github.com' == host ? 'api.github.com' : host
+    end
+
+    # Public: Determine whether a specific repo already exists.
+    def repo_exists? project
+      res = get "https://%s/repos/%s/%s" %
+        [api_host(project.host), project.owner, project.name]
+      res.success?
+    end
+
+    # Public: Fork the specified repo.
+    def fork_repo project
+      res = post "https://%s/repos/%s/%s/forks" %
+        [api_host(project.host), project.owner, project.name]
+      res.error! unless res.success?
+    end
+
+    # Public: Create a new project.
+    def create_repo project, options = {}
+      is_org = project.owner != config.username(api_host(project.host))
+      params = { :name => project.name, :private => !!options[:private] }
+      params[:description] = options[:description] if options[:description]
+      params[:homepage]    = options[:homepage]    if options[:homepage]
+
+      if is_org
+        res = post "https://%s/orgs/%s/repos" % [api_host(project.host), project.owner], params
+      else
+        res = post "https://%s/user/repos" % api_host(project.host), params
+      end
+      res.error! unless res.success?
+    end
+
+    # Public: Fetch info about a pull request.
+    def pullrequest_info project, pull_id
+      res = get "https://%s/repos/%s/%s/pulls/%d" %
+        [api_host(project.host), project.owner, project.name, pull_id]
+      res.error! unless res.success?
+      res.data
+    end
+
+    # Returns parsed data from the new pull request.
+    def create_pullrequest options
+      project = options.fetch(:project)
+      params = {
+        :base => options.fetch(:base),
+        :head => options.fetch(:head)
+      }
+
+      if options[:issue]
+        params[:issue] = options[:issue]
+      else
+        params[:title] = options[:title] if options[:title]
+        params[:body]  = options[:body]  if options[:body]
+      end
+
+      res = post "https://%s/repos/%s/%s/pulls" %
+        [api_host(project.host), project.owner, project.name], params
+
+      res.error! unless res.success?
+      res.data
+    end
+
+    # Methods for performing HTTP requests
+    #
+    # Requires access to a `config` object that implements `proxy_uri(with_ssl)`
+    module HttpMethods
+      # Decorator for Net::HTTPResponse
+      module ResponseMethods
+        def status() code.to_i end
+        def data?() content_type =~ /\bjson\b/ end
+        def data() @data ||= JSON.parse(body) end
+        def error_message?() data? and data['errors'] || data['message'] end
+        def error_message() error_sentences || data['message'] end
+        def success?() Net::HTTPSuccess === self end
+        def error_sentences
+          data['errors'].map do |err|
+            case err['code']
+            when 'custom'        then err['message']
+            when 'missing_field' then "field '%s' is missing" % err['field']
+            end
+          end.compact if data['errors']
+        end
+      end
+
+      def get url, &block
+        perform_request url, :Get, &block
+      end
+
+      def post url, params = nil
+        perform_request url, :Post do |req|
+          if params
+            req.body = JSON.dump params
+            req['Content-Type'] = 'application/json'
+          end
+          yield req if block_given?
+          req['Content-Length'] = req.body ? req.body.length : 0
+        end
+      end
+
+      def post_form url, params
+        post(url) {|req| req.set_form_data params }
+      end
+
+      def perform_request url, type
+        url = URI.parse url unless url.respond_to? :hostname
+
+        require 'net/https'
+        req = Net::HTTP.const_get(type).new(url.request_uri)
+        http = create_connection(url)
+
+        apply_authentication(req, url)
+        yield req if block_given?
+        res = http.start { http.request(req) }
+        res.extend ResponseMethods
+        res
+      rescue SocketError => err
+        raise Context::FatalError, "error with #{type.to_s.upcase} #{url} (#{err.message})"
+      end
+
+      def apply_authentication req, url
+        user = url.user || config.username(url.host)
+        pass = config.password(url.host, user)
+        req.basic_auth user, pass
+      end
+
+      def create_connection url
+        use_ssl = 'https' == url.scheme
+
+        proxy_args = []
+        if proxy = config.proxy_uri(use_ssl)
+          proxy_args << proxy.host << proxy.port
+          if proxy.userinfo
+            require 'cgi'
+            # proxy user + password
+            proxy_args.concat proxy.userinfo.split(':', 2).map {|a| CGI.unescape a }
+          end
+        end
+
+        http = Net::HTTP.new(url.host, url.port, *proxy_args)
+
+        if http.use_ssl = use_ssl
+          # FIXME: enable SSL peer verification!
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        return http
+      end
+    end
+
+    module OAuth
+      def apply_authentication req, url
+        if req.path.index('/authorizations') == 0
+          super
+        else
+          user = url.user || config.username(url.host)
+          token = config.oauth_token(url.host, user) {
+            obtain_oauth_token url.host, user
+          }
+          req['Authorization'] = "token #{token}"
+        end
+      end
+
+      def obtain_oauth_token host, user
+        # first try to fetch existing authorization
+        res = get "https://#{user}@#{host}/authorizations"
+        res.error! unless res.success?
+
+        if found = res.data.find {|auth| auth['app']['url'] == oauth_app_url }
+          found['token']
+        else
+          # create a new authorization
+          res = post "https://#{user}@#{host}/authorizations",
+            :scopes => %w[repo], :note => 'hub', :note_url => oauth_app_url
+          res.error! unless res.success?
+          res.data['token']
+        end
+      end
+    end
+
+    include HttpMethods
+    include OAuth
+
+    # Filesystem store suitable for Configuration
+    class FileStore
+      extend Forwardable
+      def_delegator :@data, :[], :get
+      def_delegator :@data, :[]=, :set
+
+      def initialize filename
+        @filename = filename
+        @data = Hash.new {|d, host| d[host] = [] }
+        load if File.exist? filename
+      end
+
+      def fetch_user host
+        unless entry = get(host).first
+          user = yield
+          # FIXME: more elegant handling of empty strings
+          return nil if user.nil? or user.empty?
+          entry = entry_for_user(host, user)
+        end
+        entry['user']
+      end
+
+      def fetch_value host, user, key
+        entry = entry_for_user host, user
+        entry[key.to_s] || begin
+          value = yield
+          if value and !value.empty?
+            entry[key.to_s] = value
+            save
+            value
+          else
+            raise "no value"
+          end
+        end
+      end
+
+      def entry_for_user host, username
+        entries = get(host)
+        entries.find {|e| e['user'] == username } or
+          (entries << {'user' => username}).last
+      end
+
+      def load
+        @data.update YAML.load(File.read(@filename))
+      end
+
+      def save
+        FileUtils.mkdir_p File.dirname(@filename)
+        File.open(@filename, 'w') {|f| f << YAML.dump(@data) }
+      end
+    end
+
+    # Provides authentication info per GitHub host such as username, password,
+    # and API/OAuth tokens.
+    class Configuration
+      def initialize store
+        @data = store
+        # passwords are cached in memory instead of persistent store
+        @password_cache = {}
+      end
+
+      def normalize_host host
+        host = host.downcase
+        'api.github.com' == host ? 'github.com' : host
+      end
+
+      def username host
+        host = normalize_host host
+        @data.fetch_user host do
+          if block_given? then yield
+          else prompt "#{host} username"
+          end
+        end
+      end
+
+      def api_token host, user
+        host = normalize_host host
+        @data.fetch_value host, user, :api_token do
+          if block_given? then yield
+          else prompt "#{host} API token for #{user}"
+          end
+        end
+      end
+
+      def password host, user
+        host = normalize_host host
+        @password_cache["#{user}@#{host}"] ||= prompt_password host, user
+      end
+
+      def oauth_token host, user, &block
+        @data.fetch_value normalize_host(host), user, :oauth_token, &block
+      end
+
+      def prompt what
+        print "#{what}: "
+        $stdin.gets.chomp
+      end
+
+      # special prompt that has hidden input
+      def prompt_password host, user
+        print "#{host} password for #{user} (never stored): "
+        password = askpass
+        puts ''
+        password
+      end
+
+      # FIXME: probably not cross-platform
+      def askpass
+        tty_state = `stty -g`
+        system 'stty raw -echo -icanon isig' if $?.success?
+        pass = ''
+        while char = $stdin.getbyte and not (char == 13 or char == 10)
+          if char == 127 or char == 8
+            pass[-1,1] = '' unless pass.empty?
+          else
+            pass << char.chr
+          end
+        end
+        pass
+      ensure
+        system "stty #{tty_state}" unless tty_state.empty?
+      end
+
+      def proxy_uri(with_ssl)
+        env_name = "HTTP#{with_ssl ? 'S' : ''}_PROXY"
+        if proxy = ENV[env_name] || ENV[env_name.downcase]
+          proxy = "http://#{proxy}" unless proxy.include? '://'
+          URI.parse proxy
+        end
+      end
+    end
+  end
+end

data/lib/hub/json.rb

@@ -94,4 +94,40 @@ class Hub::JSON
       error unless s.pos > pos
     end
   end
+
+  module Generator
+    def generate(obj)
+      raise ArgumentError unless obj.is_a? Array or obj.is_a? Hash
+      generate_type(obj)
+    end
+    alias dump generate
+
+    private
+
+    def generate_type(obj)
+      type = obj.is_a?(Numeric) ? :Numeric : obj.class.name
+      begin send(:"generate_#{type}", obj)
+      rescue NoMethodError; raise ArgumentError, "can't serialize #{type}"
+      end
+    end
+
+    def generate_String(str) str.inspect end
+    alias generate_Numeric generate_String
+    alias generate_TrueClass generate_String
+    alias generate_FalseClass generate_String
+
+    def generate_Symbol(sym) generate_String(sym.to_s) end
+
+    def generate_NilClass(*) 'null' end
+
+    def generate_Array(ary) '[%s]' % ary.map {|o| generate_type(o) }.join(', ') end
+
+    def generate_Hash(hash)
+      '{%s}' % hash.map { |key, value|
+        "#{generate_String(key.to_s)}: #{generate_type(value)}"
+      }.join(', ')
+    end
+  end
+
+  extend Generator
 end

data/lib/hub/ssh_config.rb

@@ -0,0 +1,91 @@
+module Hub
+  # Reads ssh configuration files and records each setting under its host
+  # pattern so it can be looked up by hostname.
+  class SshConfig
+    CONFIG_FILES = %w(~/.ssh/config /etc/ssh_config /etc/ssh/ssh_config)
+
+    def initialize files = nil
+      @settings = Hash.new {|h,k| h[k] = {} }
+      Array(files || CONFIG_FILES).each do |path|
+        file = File.expand_path path
+        parse_file file if File.exist? file
+      end
+    end
+
+    # Public: Get a setting as it would apply to a specific hostname.
+    #
+    # Yields if not found.
+    def get_value hostname, key
+      key = key.to_s.downcase
+      @settings.each do |pattern, settings|
+        if pattern.match? hostname and found = settings[key]
+          return found
+        end
+      end
+      yield
+    end
+
+    class HostPattern
+      def initialize pattern
+        @pattern = pattern.to_s.downcase
+      end
+
+      def to_s() @pattern end
+      def ==(other) other.to_s == self.to_s end
+
+      def matcher
+        @matcher ||=
+          if '*' == @pattern
+            Proc.new { true }
+          elsif @pattern !~ /[?*]/
+            lambda { |hostname| hostname.to_s.downcase == @pattern }
+          else
+            re = self.class.pattern_to_regexp @pattern
+            lambda { |hostname| re =~ hostname }
+          end
+      end
+
+      def match? hostname
+        matcher.call hostname
+      end
+
+      def self.pattern_to_regexp pattern
+        escaped = Regexp.escape(pattern)
+        escaped.gsub!('\*', '.*')
+        escaped.gsub!('\?', '.')
+        /^#{escaped}$/i
+      end
+    end
+
+    def parse_file file
+      host_patterns = [HostPattern.new('*')]
+
+      IO.foreach(file) do |line|
+        case line
+        when /^\s*(#|$)/ then next
+        when /^\s*(\S+)\s*=/
+          key, value = $1, $'
+        else
+          key, value = line.strip.split(/\s+/, 2)
+        end
+
+        next if value.nil?
+        key.downcase!
+        value = $1 if value =~ /^"(.*)"$/
+        value.chomp!
+
+        if 'host' == key
+          host_patterns = value.split(/\s+/).map {|p| HostPattern.new p }
+        else
+          record_setting key, value, host_patterns
+        end
+      end
+    end
+
+    def record_setting key, value, patterns
+      patterns.each do |pattern|
+        @settings[pattern][key] ||= value
+      end
+    end
+  end
+end