travis-gh 0.21.0

data/lib/gh/parallel.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'gh'
+require 'backports/basic_object' unless defined? BasicObject
+
+module GH
+  # Public: ...
+  class Parallel < Wrapper
+    attr_accessor :parallelize
+
+    class Dummy < BasicObject
+      attr_accessor :__delegate__
+
+      def method_missing(*args)
+        ::Kernel.raise ::RuntimeError, 'response not yet loaded' if __delegate__.nil?
+        __delegate__.__send__(*args)
+      end
+
+      def respond_to_missing?(method, *)
+        super
+      end
+    end
+
+    def setup(*)
+      @parallelize = true if @parallelize.nil?
+      @in_parallel = false
+      @mutex = Mutex.new
+      @queue = []
+      super
+    end
+
+    def generate_response(key, response)
+      return super unless in_parallel?
+
+      dummy = Dummy.new
+      @mutex.synchronize { @queue << [dummy, key, response] }
+      dummy
+    end
+
+    def in_parallel
+      return yield if in_parallel? || !@parallelize
+
+      was = @in_parallel
+      @in_parallel = true
+      result = nil
+      connection.in_parallel { result = yield }
+      @mutex.synchronize do
+        @queue.each { |dummy, key, response| dummy.__delegate__ = backend.generate_response(key, response) }
+        @queue.clear
+      end
+      result
+    ensure
+      @in_parallel = was unless was.nil?
+    end
+
+    def in_parallel?
+      @in_parallel
+    end
+
+    def connection
+      @connection ||= begin
+        layer = backend
+        layer = layer.backend until layer.respond_to? :connection
+        layer.connection
+      end
+    end
+  end
+end

data/lib/gh/remote.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: false
+
+require 'gh'
+require 'faraday'
+require 'faraday/retry'
+require 'faraday/typhoeus'
+require 'active_support/core_ext/string'
+
+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 && 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 && password
+        builder.request(:retry)
+        builder.adapter(:typhoeus)
+        builder.response(:raise_error)
+        builder.use :instrumentation if defined? FaradayMiddleware::Instrumentation
+        builder.response(:logger, nil, formatter: GH.const_get(options[:formatter].camelize)) if options[:formatter]
+      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 = response.body
+      headers = response.headers
+      url = response.env[:url] if response.respond_to?(:env) && 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)
+      body = headers.delete :body
+      connection.run_request(verb, url, body, headers, &block)
+    rescue StandardError => e
+      raise Error.new(e, nil, verb:, url:, 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 => e
+      e.info[:payload] = Response.new(body).to_s if body
+      raise e
+    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 '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? || 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,101 @@
+# frozen_string_literal: false
+
+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 Enumerable
+    include GH::Case
+    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 = headers.transform_keys { |k| k.downcase }
+
+      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
+      raise "Invalid encoding in #{url}, 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') || (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 = @headers.dup
+      @data = @data.dup
+      @body = @body.dup
+      self
+    end
+
+    private
+
+    def content_type
+      headers['content-type']
+    end
+  end
+end

data/lib/gh/response_wrapper.rb

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

data/lib/gh/response_x_header_formatter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'faraday/logging/formatter'
+
+module GH
+  class ResponseXHeaderFormatter < Faraday::Logging::Formatter
+    def request(env); end
+
+    def response(env)
+      info('Response') { env.response_headers.select { |k, _v| k =~ /^x-/ }.sort.to_h }
+    end
+  end
+end

data/lib/gh/stack.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+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 new build
+  end
+end

data/lib/gh/token_check.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+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 && client_id && client_secret && token
+
+      @check_token = false
+
+      auth_header = 'Basic %s' % Base64.strict_encode64("#{client_id}:#{client_secret}")
+      http :post, path_for("/applications/#{client_id}/token"), body: "{\"access_token\": \"#{token}\"}",
+                                                                'Authorization' => auth_header
+    rescue GH::Error(response_status: 404) => e
+      raise GH::TokenInvalid, e
+    end
+
+    def http(*)
+      check_token
+      super
+    end
+  end
+end

data/lib/gh/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module GH
+  # Public: Library version.
+  VERSION = '0.21.0'
+end

data/lib/gh/wrapper.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+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
+
+    def self.double_dispatch
+      define_method(:modify) { |data| double_dispatch(data) }
+    end
+
+    # 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: ...
+    attr_writer :frontend
+
+    # 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
+    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 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 StandardError => e
+      raise Error.new(e, 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 StandardError => e
+      raise Error.new(e, data)
+    end
+
+    def modify_array(array)
+      array.map { |e| modify(e) }
+    end
+
+    def modify_hash(hash)
+      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 = backend.is_a?(Wrapper) ? backend : self.class.wraps.new(backend, options)
+    end
+
+    def normalize_options(backend, options)
+      if backend.is_a?(Hash)
+        options = backend
+        backend = nil
+      end
+      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 |h, key|
+        value = old_proc.call(h, key) if old_proc
+        value = block[h, key] if value.nil?
+        value
+      end
+    end
+
+    def setup_lazy_loading(hash, *args)
+      loaded = false
+      setup_default_proc(hash) do |h, key|
+        next if loaded
+
+        fields = lazy_load(h, key, *args)
+        if fields
+          modify_hash(fields)
+          h.merge!(fields)
+          loaded = true
+          fields[key]
+        end
+      end
+      hash
+    end
+  end
+end