gh 0.3.0 → 0.4.0

data/README.md

@@ -13,13 +13,11 @@ This will by default use all the middleware that ships with GH, in the following
 
 * `GH::Remote` - sends HTTP requests to GitHub and parses the response
 * `GH::Normalizer` - renames fields consistenly, adds hypermedia links if possible
+* `GH::Cache` - caches the responses (will use Rails cache if in Rails, in-memory cache otherwise)
 * `GH::LazyLoader` - will load missing fields when accessed (handy for dealing with incomplete data without sending to many requests)
-* `GH::LinkFollower` - will add content of hypermedia links as fields (lazyly), allows you to traverse relations
 * `GH::MergeCommit` - adds infos about merge commits to pull request payloads
-
-This middleware ships with the `gh` library but is not added by default:
-
-* `GH::Cache` - caches the responses (will use Rails cache if in Rails, in-memory cache otherwise)
+* `GH::LinkFollower` - will add content of hypermedia links as fields (lazyly), allows you to traverse relations
+* `GH::Instrumentation` - let's you instrument `gh`
 
 ## Main Entry Points
 

data/gh.gemspec

@@ -19,7 +19,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'webmock'
 
-  s.add_runtime_dependency 'faraday',     '~> 0.7'
+  s.add_runtime_dependency 'faraday',     '~> 0.8'
   s.add_runtime_dependency 'backports',   '~> 2.3'
   s.add_runtime_dependency 'multi_json',  '~> 1.0'
+  s.add_runtime_dependency 'addressable'
 end

data/lib/gh.rb

@@ -5,10 +5,13 @@ require 'forwardable'
 module GH
   autoload :Cache,            'gh/cache'
   autoload :Case,             'gh/case'
+  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 :Remote,           'gh/remote'
   autoload :Response,         'gh/response'
   autoload :ResponseWrapper,  'gh/response_wrapper'
@@ -32,13 +35,15 @@ module GH
   end
 
   extend SingleForwardable
-  def_delegators :current, :api_host, :[], :reset, :load, :post
+  def_delegators :current, :api_host, :[], :reset, :load, :post, :delete, :patch, :put
 
   DefaultStack = Stack.new do
+    use Instrumentation
+    use Pagination
     use LinkFollower
     use MergeCommit
     use LazyLoader
-    #use Cache
+    use Cache
     use Normalizer
     use Remote
   end

data/lib/gh/error.rb

@@ -0,0 +1,17 @@
+require 'gh'
+
+module GH
+  class Error < Exception
+    attr_reader :error, :payload
+
+    def initialize(error = nil, payload = nil)
+      error = error.error while error.respond_to? :error
+      @error, @payload = error, payload
+      set_backtrace error.backtrace if error
+    end
+
+    def message
+      "GH request failed (#{error.message}) with payload: #{payload.inspect}"
+    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

@@ -11,12 +11,16 @@ module GH
       link = hash['_links'].try(:[], 'self') unless loaded
       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)
       result = modify_hash(backend[link].data, true)
+    rescue Exception => error
+      raise Error.new(error, hash)
     end
   end
 end

data/lib/gh/link_follower.rb

@@ -7,6 +7,8 @@ module GH
       hash = super
       setup_lazy_loading(hash) if hash['_links']
       hash
+    rescue Exception => error
+      raise Error.new(error, hash)
     end
 
     private
@@ -14,6 +16,8 @@ module GH
     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

@@ -1,4 +1,5 @@
 require 'gh'
+require 'timeout'
 
 module GH
   # Public: ...
@@ -13,24 +14,34 @@ module GH
 
     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)_commit$/ and hash.include? 'mergeable'
-
-      # FIXME: Rick said "this will become part of the API"
-      # until then, please look the other way
-      while hash['mergable'].nil?
-        url = hash['_links']['html']['href'] + '/mergeable'
-        case http(:get, url).body
-        when "true"  then hash['mergable'] = true
-        when "false" then hash['mergable'] = false
-        end
-      end
+      return unless key =~ /^(merge|head|base)_commit$/ and hash.include? 'mergeable'
+      return unless force_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
 
-      link     = hash['_links']['self']['href'].gsub(%r{/pulls/(\d+)$}, '/git/refs/pull/\1')
+    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"
@@ -39,5 +50,20 @@ module GH
       end
       Hash[commits]
     end
+
+    def force_merge_commit(hash)
+      Timeout.timeout(10) do # MAGIC NUMBERS FTW
+        # FIXME: Rick said "this will become part of the API"
+        # until then, please look the other way
+        while hash['mergeable'].nil?
+          url = hash['_links']['html']['href'] + '/mergeable'
+          case frontend.http(:get, url).body
+          when "true"  then hash['mergeable'] = true
+          when "false" then hash['mergeable'] = false
+          end
+        end
+      end
+      hash['mergeable']
+    end
   end
 end

data/lib/gh/normalizer.rb

@@ -86,6 +86,8 @@ module GH
         set_link(hash, type, value)
       when /^(.+)_url$/
         set_link(hash, $1, value)
+      when "config"
+        hash[key] = value
       end
     end
 

data/lib/gh/pagination.rb

@@ -1,4 +1,35 @@
 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
+
+      private
+
+      def next_page
+        @next_page ||= @gh[@next_url]
+      end
+    end
+
+    wraps GH::Normalizer
+    double_dispatch
+
+    def modify_response(response)
+      return response unless response.headers['link'] =~ /<([^>]+)>;\s*rel=\"next\"/
+      Paginated.new(response, $1, self)
+    end
   end
 end

data/lib/gh/remote.rb

@@ -1,5 +1,5 @@
 require 'gh'
-require 'gh/faraday'
+require 'faraday'
 
 module GH
   # Public: This class deals with HTTP requests to Github. It is the base Wrapper you always want to use.
@@ -43,7 +43,7 @@ module GH
       faraday_options.merge! options[:faraday_options] if options[:faraday_options]
 
       @connection = Faraday.new(faraday_options) do |builder|
-        builder.request(:token_auth, token)               if token
+        builder.request(:authorization, :token, token) if token
         builder.request(:basic_auth, username, password)  if username and password
         builder.request(:retry)
         builder.response(:raise_error)
@@ -66,7 +66,7 @@ module GH
     # Raises Faraday::Error::ClientError if the resource returns a status between 400 and 599.
     # Returns the Response.
     def [](key)
-      response = http(:get, path_for(key), headers)
+      response = frontend.http(:get, path_for(key), headers)
       modify(response.body, response.headers)
     end
 
@@ -75,14 +75,34 @@ module GH
       connection.run_request(verb, url, nil, headers, &block)
     end
 
-    # Public: ...
-    def post(key, body)
-      response = http(:post, path_for(key), headers) do |req|
-        req.body = Response.new({}, body).to_s
+    # 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
       modify(response.body, response.headers)
     end
 
+    # Public: ...
+    def post(key, body)
+      request(:post, key, body)
+    end
+
+    # Public: ...
+    def delete(key)
+      request(:delete, key)
+    end
+
+    # Public: ...
+    def patch(key, body)
+      request(:patch, key, body)
+    end
+
+    # Public: ...
+    def put(key, body)
+      request(:put, key, body)
+    end
+
     # Public: ...
     def reset
     end

data/lib/gh/response.rb

@@ -31,6 +31,7 @@ module GH
       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
+      when nil                  then @data = {}
       else raise ArgumentError, "cannot parse #{body.inspect}"
       end
 
@@ -74,6 +75,11 @@ module GH
       self
     end
 
+    # Public: ...
+    def ==(other)
+      super or @data == other
+    end
+
     protected
 
     def dup_ivars

data/lib/gh/version.rb

@@ -1,4 +1,4 @@
 module GH
   # Public: Library version.
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/gh/wrapper.rb

@@ -36,6 +36,15 @@ module GH
     # Public: ...
     def_delegator :backend, :post
 
+    # Public: ...
+    def_delegator :backend, :delete
+
+    # Public: ...
+    def_delegator :backend, :patch
+
+    # Public: ...
+    def_delegator :backendt, :put
+
     # Public: Retrieves resources from Github.
     def self.[](key)
       new[key]
@@ -124,6 +133,8 @@ module GH
       when respond_to(:to_int)  then modify_integer(data)
       else modify_unkown data
       end
+    rescue Exception => error
+      raise Error.new(error, data)
     end
 
     def modify_response(response)
@@ -133,6 +144,8 @@ module GH
 
     def modify(data, *)
       data
+    rescue Exception => error
+      raise Error.new(error, data)
     end
 
     def modify_array(array)
@@ -182,6 +195,7 @@ module GH
         next if loaded
         fields = lazy_load(hash, key, *args)
         if fields
+          modify_hash fields
           hash.merge! fields
           loaded = true
           fields[key]

data/spec/error_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GH::Error do
+  class SomeWrapper < GH::Wrapper
+    double_dispatch
+    def modify_hash(*)
+      raise "foo"
+    end
+  end
+
+  let(:exception) do
+    begin
+      SomeWrapper.new.load('foo' => 'bar')
+      nil
+    rescue Exception => error
+      error
+    end
+  end
+
+  it "wraps connection" do
+    exception.should be_an(GH::Error)
+  end
+
+  it "exposes the original exception" do
+    exception.error.should be_a(RuntimeError)
+  end
+
+  it 'keeps the payload around' do
+    exception.payload.should be == {'foo' => 'bar'}
+  end
+end

data/spec/instrumentation_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe GH::Instrumentation do
+  before do
+    @events = []
+    subject.instrumenter = proc { |*a, &b| @events << a and b[] }
+    stub_request(:get, "https://api.github.com/").to_return :body => "{}"
+  end
+
+  it 'instruments http' do
+    subject.http :get, '/'
+    @events.size.should be == 1
+    @events.first.should be == ['http.gh', {:verb => :get, :url => '/', :gh => subject}]
+  end
+
+  it 'instruments []' do
+    subject['/']
+    @events.size.should be == 2
+    @events.should be == [
+      ['access.gh', {:key => '/', :gh => subject}],
+      ['http.gh', {:verb => :get, :url => '/', :gh => subject}]
+    ]
+  end
+
+  it 'instruments load' do
+    subject.load("[]")
+    @events.size.should be == 1
+    @events.first.should be == ['load.gh', {:data => "[]", :gh => subject}]
+  end
+end