gh-akerl 0.15.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66c0fe8b3672ab41b6013da9e62d1a04ae026d90402bcaf2843ed08ed3ad1807
+  data.tar.gz: b7514eaaff845c0683a109d4a496221b2f7ca1d2c3125794ef66909334f45779
+SHA512:
+  metadata.gz: bdac11fcf07dedc0e5ab0212a23d11928ce86bbba6fb639cd0d44d0f31d47fcf5b9d15c55228c5e73c8c9a23fb8bfd00613518a55ba2fdbefde40983cd596c8b
+  data.tar.gz: bae91bdbfbc140dbeee491fe040765d6fca71fe9d7739f4f2b03fbd45ff001a8c7416d6aa458dfc5d4947f13ce2af9d740dcc21270ce66c97029360817c83e1d

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,65 @@
+require 'gh'
+require 'thread'
+
+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, @mutex = {}, {}, size/2, 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)
+        @mutex.synchronize { @old, @new = @new, {} if @new.size > @size } if @new.size > @size
+        @new[key] ||= @old[key] || yield
+      end
+
+      # Internal: ...
+      def clear
+        @mutex.synchronize { @old, @new = {}, {} }
+      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,8 @@
+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,27 @@
+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,64 @@
+require 'gh'
+
+module GH
+  class Error < StandardError
+    attr_reader :info
+
+    def initialize(error = nil, payload = nil, info = {})
+      info   = info.merge(error.info) if error.respond_to? :info and Hash === error.info
+      error  = error.error while error.respond_to? :error
+      @info  = info.merge(:error => error, :payload => payload)
+
+      if error
+        set_backtrace error.backtrace if error.respond_to? :backtrace
+        if error.respond_to? :response and 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
+      end
+    end
+
+    def payload
+      info[:payload]
+    end
+
+    def error
+      info[:error]
+    end
+
+    def message
+      "GH request failed\n" + info.map { |k,v| entry(k,v) }.join("\n")
+    end
+
+    private
+
+    def entry(key, value)
+      value = "#{value.class}: #{value.message}" if Exception === value
+      value = value.inspect unless String === value
+      value.gsub!(/"Basic .+"|(client_(?:id|secret)=)[^&\s]+/, '\1[removed]')
+      (key.to_s + ": ").ljust(20) + value
+    end
+  end
+
+  class TokenInvalid < Error
+  end
+
+  def self.Error(conditions)
+    Module.new do
+      define_singleton_method(:===) do |exception|
+        return false unless Error === exception and not exception.info.nil?
+        conditions.all? { |k,v| v === exception.info[k]}
+      end
+    end
+  end
+end

data/lib/gh/instrumentation.rb

@@ -0,0 +1,36 @@
+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 => verb, :url => url) { super }
+    end
+
+    def load(data)
+      instrument(:load, :data => data) { super }
+    end
+
+    def [](key)
+      instrument(:access, :key => key) { super }
+    end
+
+    private
+
+    def instrument(type, payload = {})
+      return yield unless instrumenter
+      result = nil
+      instrumenter.call("#{type}.gh", payload.merge(:gh => frontend)) { result = yield }
+      return result
+    end
+  end
+end

data/lib/gh/lazy_loader.rb

@@ -0,0 +1,26 @@
+require 'gh'
+
+module GH
+  # Public: ...
+  class LazyLoader < Wrapper
+    wraps GH::Normalizer
+    double_dispatch
+
+    def modify_hash(hash, loaded = false)
+      hash = super(hash)
+      link = hash['_links']['self'] unless loaded or hash['_links'].nil?
+      setup_lazy_loading(hash, link['href']) if link
+      hash
+    rescue Exception => error
+      raise Error.new(error, hash)
+    end
+
+    private
+
+    def lazy_load(hash, key, link)
+      modify_hash(backend[link].data, true)
+    rescue Exception => error
+      raise Error.new(error, hash)
+    end
+  end
+end

data/lib/gh/link_follower.rb

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

data/lib/gh/merge_commit.rb

@@ -0,0 +1,86 @@
+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 Exception => error
+      raise Error.new(error, hash)
+    end
+
+    private
+
+    def lazy_load(hash, key)
+      return unless key =~ /^(merge|head|base)_commit$/ and hash.include? 'mergeable'
+      return unless has_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 Exception => error
+      raise Error.new(error, 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
+      Hash[commits]
+    end
+
+    def has_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' then true
+      else fail "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,49 @@
+require 'gh'
+
+module GH
+  # Public: ...
+  class NestedResources < Wrapper
+    wraps GH::Normalizer
+    double_dispatch
+
+    def modify_hash(hash, loaded = false)
+      hash = super(hash)
+      link = hash['_links']['self'] unless loaded or 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,111 @@
+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]
+    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 or TIME_PATTERN === value
+      should_be = key == 'timestamp' ? 'date' : key
+      raise ArgumentError if RUBY_VERSION < "1.9" and value == "" # TODO: remove this line. duh.
+      time = Time.at(value) rescue Time.parse(value.to_s)
+      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']   and hash['user']
+      hash['author'] ||= hash.delete('user') if hash['committed_at'] and 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 === 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, $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_#{$1}"
+      when /^(.*)_repo$/                then "#{$1}_repository"
+      when /^(.*)_repos$/               then "#{$1}_repositories"
+      when 'commit', 'commit_id', 'id'  then value =~ /^\w{40}$/ ? 'sha' : key
+      when 'comments'                   then Numeric === value ? 'comment_count'    : key
+      when 'forks'                      then Numeric === value ? 'fork_count'       : key
+      when 'repositories'               then Numeric === value ? 'repository_count' : key
+      when /^(.*)s_count$/              then "#{$1}_count"
+      else key
+      end
+    end
+  end
+end

data/lib/gh/pagination.rb

@@ -0,0 +1,57 @@
+module GH
+  class Pagination < Wrapper
+    class Paginated
+      include Enumerable
+
+      def initialize(page, url, gh)
+        @page, @next_url, @gh = page, url, 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 and response.headers['link'] =~ /<([^>]+)>;\s*rel=\"next\"/
+      Paginated.new(response, $1, self)
+    end
+  end
+end

data/lib/gh/parallel.rb

@@ -0,0 +1,59 @@
+require 'gh'
+require 'thread'
+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
+    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? or not @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