travis-gh 0.21.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 194688122c14fd85510b9a099c5857c7e6638a5525a6414e1303d4422606b050
+  data.tar.gz: 43c35e35441b76db6c188f348ef4a522b67b0db766401d1231256c48f9a8abb4
+SHA512:
+  metadata.gz: c036a243cd1c7b6dad6f66e9b47d5a2e0bbfbb206ff52fe3b66e3131255e54a576d91afb47c977def57c3d15edac5fc1800779168fd3d177b4e503bbe614eae2
+  data.tar.gz: b58de545c86a16fc389d221049d757c23c0aa39d76c0b2e9faf645a276824c5a13fd25c2d3d175be58b9e607740adfd337342206238e85a2e161ef469e7ff8c0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Konstantin Haase
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/lib/gh/cache.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'gh'
+
+module GH
+  # Public: This class caches responses.
+  class Cache < Wrapper
+    # Public: Get/set cache to use. Compatible with Rails/ActiveSupport cache.
+    attr_accessor :cache
+
+    # Internal: Simple in-memory cache basically implementing a copying GC.
+    class SimpleCache
+      # Internal: Initializes a new SimpleCache.
+      #
+      # size - Number of objects to hold in cache.
+      def initialize(size = 2048)
+        @old = {}
+        @new = {}
+        @size = size / 2
+        @mutex = Mutex.new
+      end
+
+      # Internal: Tries to fetch a value from the cache and if it doesn't exist, generates it from the
+      # block given.
+      def fetch(key)
+        if @new.size > @size
+          @mutex.synchronize do
+            if @new.size > @size
+              @old = @new
+              @new = {}
+            end
+          end
+        end
+        @new[key] ||= @old[key] || yield
+      end
+
+      # Internal: ...
+      def clear
+        @mutex.synchronize do
+          @old = {}
+          @new = {}
+        end
+      end
+    end
+
+    # Internal: Initializes a new Cache instance.
+    def setup(*)
+      # self.cache ||= Rails.cache if defined? Rails.cache and defined? RAILS_CACHE
+      # self.cache ||= ActiveSupport::Cache.lookup_store if defined? ActiveSupport::Cache.lookup_store
+      self.cache ||= SimpleCache.new
+      super
+    end
+
+    # Public: ...
+    def reset
+      super
+      clear_partial or clear_all
+    end
+
+    private
+
+    def fetch_resource(key)
+      cache.fetch(prefixed(key)) { super }
+    end
+
+    def clear_partial
+      return false unless cache.respond_to? :delete_matched
+
+      pattern = '^' << Regexp.escape(prefixed(''))
+      cache.delete_matched Regexp.new(pattern)
+      true
+    rescue NotImplementedError
+      false
+    end
+
+    def clear_all
+      cache.clear
+    end
+  end
+end

data/lib/gh/case.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'gh'
+
+module GH
+  module Case
+    def respond_to(method)
+      proc { |o| o.respond_to? method }
+    end
+
+    private :respond_to
+  end
+end

data/lib/gh/custom_limit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GH
+  # Adds Client info so even unauthenticated requests can use a custom request limit
+  class CustomLimit < Wrapper
+    attr_accessor :client_id, :client_secret
+
+    def setup(backend, options)
+      @client_id = options[:client_id]
+      @client_secret = options[:client_secret]
+      super
+    end
+
+    def full_url(key)
+      return super unless client_id
+
+      url = super
+      params = url.query_values || {}
+
+      unless params.include? 'client_id'
+        params['client_id'] = client_id
+        params['client_secret'] = client_secret
+      end
+
+      url.query_values = params
+      url
+    end
+  end
+end

data/lib/gh/error.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'gh'
+
+module GH
+  class Error < StandardError
+    attr_reader :info
+
+    def initialize(error = nil, payload = nil, info = {})
+      super(error)
+
+      info = info.merge(error.info) if error.respond_to?(:info) && error.info.is_a?(Hash)
+      error = error.error while error.respond_to? :error
+      @info = info.merge(error:, payload:)
+
+      return unless error
+
+      set_backtrace error.backtrace if error.respond_to? :backtrace
+      return unless error.respond_to?(:response) && error.response
+
+      case response = error.response
+      when Hash
+        @info[:response_status] = response[:status]
+        @info[:response_headers] = response[:headers]
+        @info[:response_body] = response[:body]
+      when Faraday::Response
+        @info[:response_status] = response.status
+        @info[:response_headers] = response.headers
+        @info[:response_body] = response.body
+      else
+        @info[:response] = response
+      end
+    end
+
+    def payload
+      info[:payload]
+    end
+
+    def error
+      info[:error]
+    end
+
+    def message
+      (['GH request failed'] + info.map { |k, v| entry(k, v) }).join("\n")
+    end
+
+    private
+
+    def entry(key, value)
+      value = "#{value.class}: #{value.message}" if value.is_a?(Exception)
+      value = value.inspect unless value.is_a?(String)
+      value.gsub!(/"Basic .+"|(client_(?:id|secret)=)[^&\s]+/, '\1[removed]')
+      "#{key}: ".ljust(20) + value
+    end
+  end
+
+  class TokenInvalid < Error
+  end
+
+  def self.Error(conditions)
+    Module.new do
+      define_singleton_method(:===) do |exception|
+        return false unless exception.is_a?(Error) && !exception.info.nil?
+
+        # rubocop:disable Style/CaseEquality
+        conditions.all? { |k, v| v === exception.info[k] }
+        # rubocop:enable Style/CaseEquality
+      end
+    end
+  end
+end

data/lib/gh/instrumentation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'gh'
+
+module GH
+  # Public: This class caches responses.
+  class Instrumentation < Wrapper
+    # Public: Get/set instrumenter to use. Compatible with ActiveSupport::Notification and Travis::EventLogger.
+    attr_accessor :instrumenter
+
+    def setup(backend, options)
+      self.instrumenter ||= Travis::EventLogger.method(:notify) if defined? Travis::EventLogger
+      self.instrumenter ||= ActiveSupport::Notifications.method(:instrument) if defined? ActiveSupport::Notifications
+      super
+    end
+
+    def http(verb, url, *)
+      instrument(:http, verb:, url:) { super }
+    end
+
+    def load(data)
+      instrument(:load, data:) { super }
+    end
+
+    def [](key)
+      instrument(:access, key:) { super }
+    end
+
+    private
+
+    def instrument(type, payload = {})
+      return yield unless instrumenter
+
+      result = nil
+      instrumenter.call("#{type}.gh", payload.merge(gh: frontend)) { result = yield }
+      result
+    end
+  end
+end

data/lib/gh/lazy_loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'gh'
+
+module GH
+  # Public: ...
+  class LazyLoader < Wrapper
+    wraps GH::Normalizer
+    double_dispatch
+
+    def modify_hash(hash, loaded = false) # rubocop:disable Style/OptionalBooleanParameter
+      hash = super(hash)
+      link = hash['_links']['self'] unless loaded || hash['_links'].nil?
+      setup_lazy_loading(hash, link['href']) if link
+      hash
+    rescue StandardError => e
+      raise Error.new(e, hash)
+    end
+
+    private
+
+    def lazy_load(hash, _key, link)
+      modify_hash(backend[link].data, true)
+    rescue StandardError => e
+      raise Error.new(e, hash)
+    end
+  end
+end

data/lib/gh/link_follower.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GH
+  class LinkFollower < Wrapper
+    wraps GH::Normalizer
+    double_dispatch
+
+    def modify_hash(hash)
+      hash = super(hash)
+      setup_lazy_loading(hash) if hash['_links']
+      hash
+    rescue StandardError => e
+      raise Error.new(e, hash)
+    end
+
+    private
+
+    def lazy_load(hash, key)
+      link = hash['_links'][key]
+      { key => self[link['href']] } if link
+    rescue StandardError => e
+      raise Error.new(e, hash)
+    end
+  end
+end

data/lib/gh/merge_commit.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'gh'
+require 'timeout'
+
+module GH
+  # Public: ...
+  class MergeCommit < Wrapper
+    wraps GH::Normalizer
+    double_dispatch
+
+    def setup(backend, options)
+      @ssl = options[:ssl]
+      super
+    end
+
+    def modify_hash(hash)
+      setup_lazy_loading(super)
+    rescue StandardError => e
+      raise Error.new(e, hash)
+    end
+
+    private
+
+    def lazy_load(hash, key)
+      return unless key =~ (/^(merge|head|base)_commit$/) && hash.include?('mergeable')
+      return unless merge_commit?(hash)
+
+      fields = pull_request_refs(hash)
+      fields['base_commit'] ||= commit_for hash, hash['base']
+      fields['head_commit'] ||= commit_for hash, hash['head']
+      fields
+    rescue StandardError => e
+      raise Error.new(e, hash)
+    end
+
+    def commit_for(from, hash)
+      { 'sha' => hash['sha'], 'ref' => hash['ref'],
+        '_links' => { 'self' => { 'href' => git_url_for(from, hash['sha']) } } }
+    end
+
+    def git_url_for(hash, commitish)
+      hash['_links']['self']['href'].gsub(%r{/pulls/(\d+)$}, "/git/#{commitish}")
+    end
+
+    def pull_request_refs(hash)
+      link = git_url_for(hash, 'refs/pull/\1')
+      commits = self[link].map do |data|
+        ref = data['ref']
+        name = "#{ref.split('/').last}_commit"
+        object = data['object'].merge 'ref' => ref
+        [name, object]
+      end
+      commits.to_h
+    end
+
+    def merge_commit?(hash)
+      force_merge_commit(hash)
+      hash['mergeable']
+    end
+
+    def github_done_checking?(hash)
+      case hash['mergeable_state']
+      when 'checking' then false
+      when 'unknown' then hash['merged']
+      when 'clean', 'dirty', 'unstable', 'stable', 'blocked', 'behind', 'has_hooks', 'draft' then true
+      else raise "unknown mergeable_state #{hash['mergeable_state'].inspect} for #{url(hash)}"
+      end
+    end
+
+    def force_merge_commit(hash)
+      Timeout.timeout(180) do
+        update(hash) until github_done_checking? hash
+      end
+    rescue TimeoutError
+      status = hash['mergeable_state'].inspect
+      raise TimeoutError, "gave up waiting for github to check the merge status (current status is #{status})"
+    end
+
+    def update(hash)
+      hash.merge! backend[url(hash)]
+      sleep 0.5
+    end
+
+    def url(hash)
+      hash['_links']['self']['href']
+    end
+  end
+end

data/lib/gh/nested_resources.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'gh'
+
+module GH
+  # Public: ...
+  class NestedResources < Wrapper
+    wraps GH::Normalizer
+    double_dispatch
+
+    def modify_hash(hash, loaded = false) # rubocop:disable Style/OptionalBooleanParameter
+      hash = super(hash)
+      link = hash['_links']['self'] unless loaded || hash['_links'].nil?
+      set_links hash, Addressable::URI.parse(link['href']) if link
+      hash
+    end
+
+    def add(hash, link, name, path = name)
+      hash['_links'][name] ||= { 'href' => nested(link, path) }
+    end
+
+    def nested(link, path)
+      new_link = link.dup
+      if path.start_with? '/'
+        new_link.path = path
+      else
+        new_link.path += path
+      end
+      new_link
+    end
+
+    def set_links(hash, link)
+      case link.path
+      when '/gists'
+        add hash, link, 'public'
+        add hash, link, 'starred'
+      when %r{^/repos/[^/]+/[^/]+$}
+        add hash, link, 'commits', 'git/commits'
+        add hash, link, 'refs', 'git/refs'
+        add hash, link, 'tags', 'git/tags'
+        add hash, link, 'issues'
+      when %r{^/repos/[^/]+/[^/]+/issues/\d+$}
+        add hash, link, 'comments'
+        add hash, link, 'events'
+      when '/user'
+        add hash, link, 'gists', '/gists'
+        add hash, link, 'issues', '/issues'
+      end
+    end
+  end
+end

data/lib/gh/normalizer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'gh'
+require 'time'
+
+module GH
+  # Public: A Wrapper class that deals with normalizing Github responses.
+  class Normalizer < Wrapper
+    def generate_response(key, response)
+      result = super
+      links(result)['self'] ||= { 'href' => frontend.full_url(key).to_s } if result.respond_to? :to_hash
+      result
+    end
+
+    private
+
+    double_dispatch
+
+    def links(hash)
+      hash = hash.data if hash.respond_to? :data
+      hash['_links'] ||= {}
+    end
+
+    def set_link(hash, type, href)
+      links(hash)[type] = { 'href' => href }
+    end
+
+    def modify_response(response)
+      response = response.dup
+      response.data = modify response.data
+      response
+    end
+
+    def modify_hash(hash)
+      corrected = {}
+      corrected.default_proc = hash.default_proc if hash.default_proc
+
+      hash.each_pair do |key, value|
+        key = modify_key(key, value)
+        next if modify_url(corrected, key, value)
+        next if modify_time(corrected, key, value)
+
+        corrected[key] = modify(value)
+      end
+
+      modify_user(corrected)
+      corrected
+    end
+
+    TIME_KEYS = %w[date timestamp committed_at created_at merged_at closed_at datetime time].freeze
+    TIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\S*$/
+
+    def modify_time(hash, key, value)
+      return unless TIME_KEYS.include?(key) || (TIME_PATTERN === value)
+
+      should_be = key == 'timestamp' ? 'date' : key
+      raise ArgumentError if (RUBY_VERSION < '1.9') && (value == '') # TODO: remove this line. duh.
+
+      time = begin
+        Time.at(value)
+      rescue StandardError
+        Time.parse(value.to_s)
+      end
+      hash[should_be] = time.utc.xmlschema if time
+    rescue ArgumentError, TypeError
+      hash[should_be] = value
+    end
+
+    def modify_user(hash)
+      hash['owner'] ||= hash.delete('user') if hash['created_at'] && hash['user']
+      hash['author'] ||= hash.delete('user') if hash['committed_at'] && hash['user']
+
+      hash['committer'] ||= hash['author'] if hash['author']
+      hash['author'] ||= hash['committer'] if hash['committer']
+
+      modify_user_fields hash['owner']
+      modify_user_fields hash['user']
+    end
+
+    def modify_user_fields(hash)
+      return unless hash.is_a?(Hash)
+
+      hash['login'] = hash.delete('name') if hash['name']
+      set_link hash, 'self', "users/#{hash['login']}" unless links(hash).include? 'self'
+    end
+
+    def modify_url(hash, key, value)
+      case key
+      when 'blog'
+        set_link(hash, key, value)
+      when 'url'
+        type = value.to_s.start_with?(api_host.to_s) ? 'self' : 'html'
+        set_link(hash, type, value)
+      when /^(.+)_url$/
+        set_link(hash, ::Regexp.last_match(1), value)
+      when 'config'
+        hash[key] = value
+      end
+    end
+
+    def modify_key(key, value = nil)
+      case key
+      when 'gravatar_url' then 'avatar_url'
+      when 'org' then 'organization'
+      when 'orgs' then 'organizations'
+      when 'username' then 'login'
+      when 'repo' then 'repository'
+      when 'repos' then modify_key('repositories', value)
+      when /^repos?_(.*)$/ then "repository_#{::Regexp.last_match(1)}"
+      when /^(.*)_repo$/ then "#{::Regexp.last_match(1)}_repository"
+      when /^(.*)_repos$/ then "#{::Regexp.last_match(1)}_repositories"
+      when 'commit', 'commit_id', 'id' then value.to_s =~ /^\w{40}$/ ? 'sha' : key
+      when 'comments' then value.is_a?(Numeric) ? 'comment_count' : key
+      when 'forks' then value.is_a?(Numeric) ? 'fork_count' : key
+      when 'repositories' then value.is_a?(Numeric) ? 'repository_count' : key
+      when /^(.*)s_count$/ then "#{::Regexp.last_match(1)}_count"
+      else key
+      end
+    end
+  end
+end

data/lib/gh/pagination.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module GH
+  class Pagination < Wrapper
+    class Paginated
+      include Enumerable
+
+      def initialize(page, url, gh)
+        @page = page
+        @next_url = url
+        @gh = gh
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+
+        @page.each(&block)
+        next_page.each(&block)
+      end
+
+      def inspect
+        "[#{first.inspect}, ...]"
+      end
+
+      def [](value)
+        raise TypeError, "index has to be an Integer, got #{value.class}" unless value.is_a? Integer
+        return @page[value] if value < @page.size
+
+        next_page[value - @page.size]
+      end
+
+      def to_ary
+        to_a # replace with better implementation (use in_parallel)
+      end
+
+      def headers
+        @page.headers
+      end
+
+      private
+
+      def next_page
+        @next_page ||= @gh[@next_url]
+      end
+    end
+
+    wraps GH::Normalizer
+    double_dispatch
+
+    def fetch_resource(key)
+      url = frontend.full_url(key)
+      params = url.query_values || {}
+      params['per_page'] ||= 100
+      url.query_values = params
+      super url.request_uri
+    end
+
+    def modify_response(response)
+      return response unless response.respond_to?(:to_ary) && response.headers['link'] =~ (/<([^>]+)>;\s*rel="next"/)
+
+      Paginated.new(response, ::Regexp.last_match(1), self)
+    end
+  end
+end