gh-akerl 0.15.1

data/lib/gh/remote.rb

@@ -0,0 +1,156 @@
+require 'gh'
+require 'faraday'
+
+module GH
+  # Public: This class deals with HTTP requests to Github. It is the base Wrapper you always want to use.
+  # Note that it is usually used implicitely by other wrapper classes if not specified.
+  class Remote < Wrapper
+    attr_reader :api_host, :connection, :headers, :prefix
+
+    # Public: Generates a new Remote instance.
+    #
+    # api_host - HTTP host to send requests to, has to include schema (https or http)
+    # options  - Hash with configuration options:
+    #            :token    - OAuth token to use (optional).
+    #            :username - Github user used for login (optional).
+    #            :password - Github password used for login (optional).
+    #            :origin   - Value of the origin request header (optional).
+    #            :headers  - HTTP headers to be send on every request (optional).
+    #
+    # It is highly recommended to set origin, but not to set headers.
+    # If you set the username, you should also set the password.
+    def setup(api_host, options)
+      token, username, password = options.values_at :token, :username, :password
+
+      api_host  = api_host.api_host if api_host.respond_to? :api_host
+      @api_host = Addressable::URI.parse(api_host)
+      @headers  = {
+        "User-Agent"      => options[:user_agent] || "GH/#{GH::VERSION}",
+        "Accept"          => options[:accept] || "application/vnd.github.v3+json",
+        "Accept-Charset"  => "utf-8",
+      }
+
+      @headers.merge! options[:headers] if options[:headers]
+      @headers['Origin'] = options[:origin] if options[:origin]
+
+      @prefix = ""
+      @prefix << "#{token}@" if token
+      @prefix << "#{username}:#{password}@" if username and password
+      @prefix << @api_host.host
+
+      faraday_options = {:url => api_host}
+      faraday_options[:ssl] = options[:ssl] if options[:ssl]
+      faraday_options.merge! options[:faraday_options] if options[:faraday_options]
+
+      @connection = Faraday.new(faraday_options) do |builder|
+        builder.request(:authorization, :token, token) if token
+        builder.request(:basic_auth, username, password)  if username and password
+        builder.request(:retry)
+        builder.response(:raise_error)
+        if defined? FaradayMiddleware::Instrumentation
+          builder.use :instrumentation
+        end
+        builder.adapter(:net_http)
+      end
+    end
+
+    # Public: ...
+    def inspect
+      "#<#{self.class}: #{api_host}>"
+    end
+
+    # Internal: ...
+    def fetch_resource(key)
+      frontend.http(:get, frontend.path_for(key), headers)
+    end
+
+    # Internal: ...
+    def generate_response(key, response)
+      body, headers = response.body, response.headers
+      url = response.env[:url]     if response.respond_to? :env and response.env
+      url = response.url           if response.respond_to?(:url)
+      url = frontend.full_url(key) if url.to_s.empty?
+      modify(body, headers, url)
+    end
+
+    # Internal: ...
+    def http(verb, url, headers = {}, &block)
+      connection.run_request(verb, url, nil, headers, &block)
+    rescue Exception => error
+      raise Error.new(error, nil, :verb => verb, :url => url, :headers => headers)
+    end
+
+    # Internal: ...
+    def request(verb, key, body = nil)
+      response = frontend.http(verb, path_for(key), headers) do |req|
+        req.body = Response.new(body).to_s if body
+      end
+      frontend.generate_response(key, response)
+    rescue GH::Error => error
+      error.info[:payload] = Response.new(body).to_s if body
+      raise error
+    end
+
+    # Public: ...
+    def post(key, body)
+      frontend.request(:post, key, body)
+    end
+
+    # Public: ...
+    def delete(key, body = nil)
+      frontend.request(:delete, key, body)
+    end
+
+    # Public: ...
+    def head(key)
+      frontend.request(:head, key)
+    end
+
+    # Public: ...
+    def patch(key, body)
+      frontend.request(:patch, key, body)
+    end
+
+    # Public: ...
+    def put(key, body)
+      frontend.request(:put, key, body)
+    end
+
+    # Public: ...
+    def reset
+    end
+
+    # Public: ...
+    def load(data)
+      modify(data)
+    end
+
+    # Public: ...
+    def in_parallel
+      raise RuntimeError, "use GH::Parallel middleware for #in_parallel support"
+    end
+
+    def full_url(key)
+      uri      = Addressable::URI.parse(key)
+      uri.path = File.join(api_host.path, uri.path) unless uri.absolute? or uri.path.start_with?(api_host.path)
+      uri      = api_host + uri
+      raise ArgumentError, "URI out of scope: #{key}" if uri.host != api_host.host
+      uri
+    end
+
+    def path_for(key)
+      frontend.full_url(key).request_uri
+    end
+
+    private
+
+    def identifier(key)
+      path_for(key)
+    end
+
+    def modify(body, headers = {}, url = nil)
+      return body if body.is_a? Response
+      Response.new(body, headers, url)
+    end
+  end
+end

data/lib/gh/response.rb

@@ -0,0 +1,93 @@
+require 'gh'
+require 'multi_json'
+
+module GH
+  # Public: Class wrapping low level Github responses.
+  #
+  # Delegates safe methods to the parsed body (expected to be an Array or Hash).
+  class Response
+    include GH::Case, Enumerable
+    attr_accessor :headers, :data, :body, :url
+
+    # subset of safe methods that both Array and Hash implement
+    extend Forwardable
+    def_delegators(:@data, :[], :assoc, :each, :empty?, :flatten, :include?, :index, :inspect, :length,
+      :pretty_print, :pretty_print_cycle, :rassoc, :select, :size, :to_a, :values_at)
+
+    # Internal: Initializes a new instance.
+    #
+    # headers - HTTP headers as a Hash
+    # body    - HTTP body as a String
+    def initialize(body = "{}", headers = {}, url = nil)
+      @url     = url
+      @headers = Hash[headers.map { |k,v| [k.downcase, v] }]
+
+      case body
+      when nil, ''              then @data = {}
+      when respond_to(:to_str)  then @body = body.to_str
+      when respond_to(:to_hash) then @data = body.to_hash
+      when respond_to(:to_ary)  then @data = body.to_ary
+      else raise ArgumentError, "cannot parse #{body.inspect}"
+      end
+
+      @body.force_encoding("utf-8") if @body.respond_to? :force_encoding
+      @body ||= MultiJson.encode(@data)
+      @data ||= MultiJson.decode(@body)
+    rescue EncodingError => error
+      fail "Invalid encoding in #{url.to_s}, please contact github."
+    end
+
+    # Public: Duplicates the instance. Will also duplicate some instance variables to behave as expected.
+    #
+    # Returns new Response instance.
+    def dup
+      super.dup_ivars
+    end
+
+    # Public: Returns the response body as a String.
+    def to_s
+      @body.dup
+    end
+
+    # Public: Returns true or false indicating whether it supports method.
+    def respond_to?(method, *)
+      return super unless method.to_s == "to_hash" or method.to_s == "to_ary"
+      data.respond_to? method
+    end
+
+    # Public: Implements to_hash conventions, please check respond_to?(:to_hash).
+    def to_hash
+      return method_missing(__method__) unless respond_to? __method__
+      @data.dup.to_hash
+    end
+
+    # Public: Implements to_ary conventions, please check respond_to?(:to_hash).
+    def to_ary
+      return method_missing(__method__) unless respond_to? __method__
+      @data.dup.to_ary
+    end
+
+    # Public: ...
+    def to_gh
+      self
+    end
+
+    # Public: ...
+    def ==(other)
+      super or @data == other
+    end
+
+    protected
+
+    def dup_ivars
+      @headers, @data, @body = @headers.dup, @data.dup, @body.dup
+      self
+    end
+
+    private
+
+    def content_type
+      headers['content-type']
+    end
+  end
+end

data/lib/gh/response_wrapper.rb

@@ -0,0 +1,11 @@
+require 'gh'
+require 'delegate'
+
+module GH
+  ResponseWrapper = DelegateClass(Response) unless const_defined?
+  class ResponseWrapper
+    def to_gh
+      self
+    end
+  end
+end

data/lib/gh/stack.rb

@@ -0,0 +1,61 @@
+require 'gh'
+
+module GH
+  # Public: Exposes DSL for stacking wrappers.
+  #
+  # Examples
+  #
+  #   api = GH::Stack.build do
+  #     use GH::Cache, cache: Rails.cache
+  #     use GH::Normalizer
+  #     use GH::Remote, username: "admin", password: "admin"
+  #   end
+  class Stack
+    attr_reader :options
+
+    # Public: Generates a new wrapper stack from the given block.
+    #
+    # options - Hash of options that will be passed to all layers upon initialization.
+    #
+    # Returns top most Wrapper instance.
+    def self.build(options = {}, &block)
+      new(&block).build(options)
+    end
+
+    # Public: Generates a new Stack instance.
+    #
+    # options - Hash of options that will be passed to all layers upon initialization.
+    #
+    # Can be used for easly stacking layers.
+    def initialize(options = {}, &block)
+      @options, @stack = {}, []
+      instance_eval(&block) if block
+    end
+
+    # Public: Adds a new layer to the stack.
+    #
+    # Layer will be wrapped by layers already on the stack.
+    def use(klass, options = {})
+      @stack << [klass, options]
+      self
+    end
+
+    # Public: Generates wrapper instances for stack configuration.
+    #
+    # options - Hash of options that will be passed to all layers upon initialization.
+    #
+    # Returns top most Wrapper instance.
+    def build(options = {})
+      @stack.reverse.inject(nil) do |backend, (klass, opts)|
+        klass.new backend, @options.merge(opts).merge(options)
+      end
+    end
+
+    # Public: ...
+    def replace(old_class, new_class)
+      @stack.map! { |klass, options| [old_class == klass ? new_class : klass, options] }
+    end
+
+    alias_method :new, :build
+  end
+end

data/lib/gh/token_check.rb

@@ -0,0 +1,31 @@
+require 'gh/error'
+require 'base64'
+
+module GH
+  class TokenCheck < Wrapper
+    attr_accessor :client_id, :client_secret, :token
+
+    def setup(backend, options)
+      @client_secret = options[:client_secret]
+      @client_id     = options[:client_id]
+      @token         = options[:token]
+      @check_token   = true
+      super
+    end
+
+    def check_token
+      return unless @check_token and client_id and client_secret and token
+      @check_token = false
+
+      auth_header = "Basic %s" % Base64.encode64("#{client_id}:#{client_secret}").gsub("\n", "")
+      http :head, path_for("/applications/#{client_id}/tokens/#{token}?client_id=#{client_id}&client_secret=#{client_secret}"), "Authorization" => auth_header
+    rescue GH::Error(:response_status => 404) => error
+      raise GH::TokenInvalid, error
+    end
+
+    def http(*)
+      check_token
+      super
+    end
+  end
+end

data/lib/gh/version.rb

@@ -0,0 +1,4 @@
+module GH
+  # Public: Library version.
+  VERSION = '0.15.1'
+end

data/lib/gh/wrapper.rb

@@ -0,0 +1,231 @@
+require 'gh'
+require 'addressable/uri'
+
+module GH
+  # Public: Simple base class for low level layers.
+  # Handy if you want to manipulate resources coming in from Github.
+  #
+  # Examples
+  #
+  #   class IndifferentAccess
+  #     def [](key) super.tap { |r| r.data.with_indifferent_access! } end
+  #   end
+  #
+  #   gh = IndifferentAccess.new
+  #   gh['users/rkh'][:name] # => "Konstantin Haase"
+  #
+  #   # easy to use in the low level stack
+  #   gh = Github.build do
+  #     use GH::Cache
+  #     use IndifferentAccess
+  #     use GH::Normalizer
+  #   end
+  class Wrapper
+    extend Forwardable
+    include Case
+
+    # Public: Get wrapped layer.
+    attr_reader :backend
+
+    # Public: ...
+    attr_reader :options
+
+    # Public: Returns the URI used for sending out web request.
+    def_delegator :backend, :api_host
+
+    # Internal: ...
+    def_delegator :backend, :http
+
+    # Internal: ...
+    def_delegator :backend, :request
+
+    # Public: ...
+    def_delegator :backend, :post
+
+    # Public: ...
+    def_delegator :backend, :delete
+
+    # Public: ...
+    def_delegator :backend, :head
+
+    # Public: ...
+    def_delegator :backend, :patch
+
+    # Public: ...
+    def_delegator :backend, :put
+
+    # Public: ...
+    def_delegator :backend, :fetch_resource
+
+    # Public: ...
+    def_delegator :backend, :in_parallel
+
+    # Public: ...
+    def_delegator :backend, :in_parallel?
+
+    # Public: ...
+    def_delegator :backend, :full_url
+
+    # Public: ...
+    def_delegator :backend, :path_for
+
+    # Public: Retrieves resources from Github.
+    def self.[](key)
+      new[key]
+    end
+
+    # Public: Retrieves resources from Github.
+    #
+    # By default, this method is delegated to the next layer on the stack
+    # and modify is called.
+    def [](key)
+      generate_response key, fetch_resource(key)
+    end
+
+    # Internal: ...
+    def generate_response(key, resource)
+      modify backend.generate_response(key, resource)
+    end
+
+    # Internal: Get/set default layer to wrap when creating a new instance.
+    def self.wraps(klass = nil)
+      @wraps = klass if klass
+      @wraps ||= Remote
+    end
+
+    # Public: Initialize a new Wrapper.
+    #
+    # backend - layer to be wrapped
+    # options - config options
+    def initialize(backend = nil, options = {})
+      backend, @options = normalize_options(backend, options)
+      @options.each_pair { |key, value| public_send("#{key}=", value) if respond_to? "#{key}=" }
+      setup(backend, @options)
+    end
+
+    # Public: Set wrapped layer.
+    def backend=(layer)
+      reset if backend
+      layer.frontend = self
+      @backend = layer
+    end
+
+    # Internal: ...
+    def frontend=(value)
+      @frontend = value
+    end
+
+    # Internal: ...
+    def frontend
+      @frontend ? @frontend.frontend : self
+    end
+
+    # Public: ...
+    def inspect
+      "#<#{self.class}: #{backend.inspect}>"
+    end
+
+    # Internal: ...
+    def prefixed(key)
+      prefix + "#" + identifier(key)
+    end
+
+    # Public: ...
+    def reset
+      backend.reset if backend
+    end
+
+    # Public: ...
+    def load(data)
+      modify backend.load(data)
+    end
+
+    private
+
+    def identifier(key)
+      backend.prefixed(key)
+    end
+
+    def prefix
+      self.class.name
+    end
+
+    def self.double_dispatch
+      define_method(:modify) { |data| double_dispatch(data) }
+    end
+
+    def double_dispatch(data)
+      case data
+      when respond_to(:to_gh)   then modify_response(data)
+      when respond_to(:to_hash) then modify_hash(data)
+      when respond_to(:to_ary)  then modify_array(data)
+      when respond_to(:to_str)  then modify_string(data)
+      when respond_to(:to_int)  then modify_integer(data)
+      else modify_unknown data
+      end
+    rescue Exception => error
+      raise Error.new(error, data)
+    end
+
+    def modify_response(response)
+      result = double_dispatch response.data
+      result.respond_to?(:to_gh) ? result.to_gh : Response.new(result, response.headers, response.url)
+    end
+
+    def modify(data, *)
+      data
+    rescue Exception => error
+      raise Error.new(error, data)
+    end
+
+    def modify_array(array)
+      array.map { |e| modify(e) }
+    end
+
+    def modify_hash(hash, &block)
+      corrected = {}
+      hash.each_pair { |k,v| corrected[k] = modify(v) }
+      corrected.default_proc = hash.default_proc if hash.default_proc
+      corrected
+    end
+
+    alias modify_string   modify
+    alias modify_integer  modify
+    alias modify_unknown  modify
+
+    def setup(backend, options)
+      self.backend = Wrapper === backend ? backend : self.class.wraps.new(backend, options)
+    end
+
+    def normalize_options(backend, options)
+      backend, options = nil, backend if Hash === backend
+      options ||= {}
+      backend ||= options[:backend] || options[:api_url] || 'https://api.github.com'
+      [backend, options]
+    end
+
+    def setup_default_proc(hash, &block)
+      old_proc = hash.default_proc
+      hash.default_proc = proc do |hash, key|
+        value = old_proc.call(hash, key) if old_proc
+        value = block[hash, key] if value.nil?
+        value
+      end
+    end
+
+    def setup_lazy_loading(hash, *args)
+      loaded = false
+      setup_default_proc hash do |hash, key|
+        next if loaded
+        fields = lazy_load(hash, key, *args)
+        if fields
+          modify_hash fields
+          hash.merge! fields
+          loaded = true
+          fields[key]
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/gh.rb

@@ -0,0 +1,74 @@
+require 'gh/version'
+require 'backports' if RUBY_VERSION < '2.1'
+require 'forwardable'
+
+module GH
+  autoload :Cache,            'gh/cache'
+  autoload :Case,             'gh/case'
+  autoload :CustomLimit,      'gh/custom_limit'
+  autoload :Error,            'gh/error'
+  autoload :Instrumentation,  'gh/instrumentation'
+  autoload :LazyLoader,       'gh/lazy_loader'
+  autoload :LinkFollower,     'gh/link_follower'
+  autoload :MergeCommit,      'gh/merge_commit'
+  autoload :Normalizer,       'gh/normalizer'
+  autoload :Pagination,       'gh/pagination'
+  autoload :Parallel,         'gh/parallel'
+  autoload :Remote,           'gh/remote'
+  autoload :Response,         'gh/response'
+  autoload :ResponseWrapper,  'gh/response_wrapper'
+  autoload :Stack,            'gh/stack'
+  autoload :TokenCheck,       'gh/token_check'
+  autoload :Wrapper,          'gh/wrapper'
+
+  def self.with(backend)
+    if Hash === backend
+      @options ||= {}
+      @options, options = @options.merge(backend), @options
+      backend = DefaultStack.build(@options)
+    end
+
+    if block_given?
+      was, self.current = current, backend
+      yield
+    else
+      backend
+    end
+  ensure
+    @options = options if options
+    self.current = was if was
+  end
+
+  def self.set(options)
+    Thread.current[:GH] = nil
+    DefaultStack.options.merge! options
+  end
+
+  def self.current
+    Thread.current[:GH] ||= DefaultStack.new
+  end
+
+  def self.current=(backend)
+    Thread.current[:GH] = backend
+  end
+
+  extend SingleForwardable
+  def_delegators :current, :api_host, :[], :reset, :load, :post, :delete, :patch, :put, :in_parallel, :in_parallel?, :options, :head
+
+  def self.method_missing(*args, &block)
+    current.public_send(*args, &block)
+  end
+
+  DefaultStack = Stack.new do
+    use Instrumentation
+    use Parallel
+    use TokenCheck
+    use Pagination
+    use LinkFollower
+    use MergeCommit
+    use LazyLoader
+    use Normalizer
+    use CustomLimit
+    use Remote
+  end
+end