restify 0.1.2.1.b38 → 0.1.2.1.b40

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmE0MzA0MGE4NTMyYTQ4YzA1M2IzNjEyMjUzODBmMjlkZjI5ZDM5YQ==
+    MGI1NWFhZGEzMzc5YjJlMmM5NDRjMGY5NzNhMjliZjcwZWI5MjBmZA==
   data.tar.gz: !binary |-
-    ZDZiNjMyNmE1N2M3ODI3ZTE5YzhhN2NiZWIwNGU5NDZiODZkMjhmNQ==
+    YTMxY2I3Mjg2ZjdhNjZiM2E2YWM1ZTgyMjFkODc3YzczZGRhNTg5Ng==
 SHA512:
   metadata.gz: !binary |-
-    NmViYzlmNGVkMjQ4NTRkYTQyNDczOTY0ZmI0ZTdjNWU3YWEzODk2ZjQ3MmU1
-    NmUwZmIzMzBlY2QyMjllNGQzODEwNmJkM2I5MGMzMmM3ODcxYzkxYTk1MWZm
-    ODA4Y2I4ZGY2ODYwZTM2YWY2Zjk3NDlmZjlhMzA5YzA1MzE1YTU=
+    M2IzZGYwOGM5OWRiOTBlYWM0YjNlMDQxYzhkNzhiNGFhZTE2MDBmNDVhZDU2
+    ZmIyY2FjNGY4NGJlN2FmZmU0YmU5MmE0YTM5NjA4ZjMzYzFhODNhZjU2YzVi
+    YTA5MjE4ZGZkYTg1ODM4YWI3NjkwNTQ1ZDQzN2M5Y2E3ZmY4NWY=
   data.tar.gz: !binary |-
-    MmMyNzljYTY3OGEzZjdhM2IyZDQwM2U1ZDg2ZDBkMTQ5M2VjZTBlNDhhNjk2
-    MWVhODFiZDVjOTg4ZmI3YTg1NmYyMjY0OTM2ZjI0ODc5OWJmMDMxMmZhMWY0
-    MjVhOWJiMzBkM2Q0ZjkxZGY1NmYyNWZkYjI4YzM4YWU3ZDJiZTM=
+    MjI4ZmUyNjk5NmVmY2MzMWU4MTE5ZDdhNTY3ZDY0YWI2YjBmMTAzYTQwNjA2
+    YWE1YjkzYThjYjk5Nzk2MWI4ODA3MGMyNDgzY2RmMmU1Y2NkZmIzODVlMGY3
+    MjVlMTgzZjQ3MjNlMzUwNTk2ZDFmMGY3NWZiNTMzMjAyOTY0NzE=

data/lib/restify.rb

@@ -1,40 +1,34 @@
 require 'restify/version'
+
+require 'hashie'
+require 'obligation'
+require 'multi_json'
 require 'addressable/uri'
 require 'addressable/template'
-require 'multi_json'
-require 'obligation'
-require 'hashie'
 
 #
 module Restify
-  require 'restify/adapter'
-  require 'restify/client'
-  require 'restify/result'
+  require 'restify/http'
+  require 'restify/error'
   require 'restify/relations'
+
+  require 'restify/context'
+  require 'restify/contextual'
   require 'restify/collection'
-  require 'restify/link'
+  require 'restify/resource'
   require 'restify/relation'
+
+  require 'restify/link'
   require 'restify/request'
-  require 'restify/resource'
   require 'restify/response'
 
   class << self
-    def new(url)
-      Client.new(url).request(:GET, nil)
-    end
-
-    def adapter
-      @adapter ||= Adapter::EM.new
+    def new(uri, opts = {})
+      Context.new(uri, http, nil, opts).request(:GET, uri)
     end
 
-    def decode(response)
-      decoder = decoders.find { |d| d.accept?(response) }
-      if decoder
-        decoder.decode(response)
-      else
-        UnsupportedFormatError.new \
-          "Cannot decode `#{response.content_type}' response."
-      end
+    def http
+      @http ||= HTTP.new
     end
   end
 end

data/lib/restify/adapter.rb

@@ -68,6 +68,7 @@ module Restify
 
             writer.fulfill Response.new(
               request,
+              req.last_effective_url,
               req.response_header.status,
               req.response_header,
               req.response

data/lib/restify/collection.rb

@@ -1,23 +1,15 @@
 module Restify
   #
   class Collection < Array
-    include Result
+    include Contextual
     include Relations
 
-    def initialize(client, data = [], response = nil)
-      super data
+    def initialize(context, data = [])
+      @context = context
 
-      map! do |item|
-        case item
-          when Hash
-            Resource.new client, item
-          else
-            item
-        end
-      end
+      super data
 
-      @client    = client
-      @relations = response ? response.relations(client) : nil
+      map! {|item| @context.inherit_value(item) }
     end
   end
 end

data/lib/restify/context.rb

@@ -0,0 +1,126 @@
+module Restify
+  # A resource context.
+  #
+  # The resource context contains relations and the effective
+  # response URI. The context is used to resolve relative URI
+  # and follow links.
+  #
+  class Context
+    include Addressable
+    include Relations
+
+    # The response object.
+    #
+    # @return [Response] The response or nil.
+    #
+    attr_reader :response
+
+    # Effective context URI.
+    #
+    # @return [Addressable::URI] Effective context URI.
+    #
+    attr_reader :uri
+
+    def initialize(uri, http, response = nil, opts = {})
+      @uri = uri.is_a?(URI) ? uri : URI.parse(uri.to_s)
+      @http = http
+      @response = response
+    end
+
+    def relations
+      @relations ||= load_relations
+    end
+
+    def expand(uri)
+      case uri
+        when Addressable::Template
+          Addressable::Template.new self.uri.join(uri.pattern).to_s
+        else
+          self.uri.join uri
+      end
+    end
+
+    def follow
+      if follow_location
+        new_relation follow_location
+      else
+        raise RuntimeError.new 'Nothing to follow'
+      end
+    end
+
+    def request(method, uri, data = nil, opts = {})
+      request = @http.request(method, expand(uri), data, opts)
+      request.then do |response|
+        if response.success?
+          inherit(uri: response.uri, response: response)
+            .new_value(response.decoded_body)
+        else
+          Context.raise_response_error(response)
+        end
+      end
+    end
+
+    def inherit_value(value)
+      inherit.new_value value
+    end
+
+    def new_relation(uri)
+      Relation.new(self, uri.to_s, expand(uri))
+    end
+
+    def add_relation(name, uri)
+      @relations[name] = new_relation(uri)
+    end
+
+    def inherit(opts = {})
+      Context.new \
+        opts.fetch(:uri) { @uri },
+        opts.fetch(:http) { @http },
+        opts.fetch(:response) { nil }
+    end
+
+    def new_value(value)
+      case value
+        when Hash
+          Resource.new(self, value)
+        when Array
+          Collection.new(self, value)
+        else
+          value
+      end
+    end
+
+    private
+
+    def follow_location
+      if @response
+        @response.headers['LOCATION'] || @response.headers['CONTENT-LOCATION']
+      end
+    end
+
+    def load_relations
+      response_links.each_with_object(Hashie::Mash.new) do |link, relations|
+        if (rel = link.metadata['rel'])
+          relations[rel] = new_relation link.uri
+        end
+      end
+    end
+
+    def response_links
+      @response ? @response.links : []
+    end
+
+    class << self
+      def raise_response_error(response)
+        case response.code
+          when 400...500
+            raise ClientError.new(response)
+          when 500...600
+            raise ServerError.new(response)
+          else
+            raise RuntimeError.new "Unknown response code: #{response.code}"
+        end
+      end
+    end
+  end
+end

data/lib/restify/contextual.rb

@@ -0,0 +1,32 @@
+module Restify
+  module Contextual
+    extend Forwardable
+
+    # @!method relations
+    #
+    #   Return hash of all relations.
+    #
+    #   @return [Hashie::Mash] Relations.
+    #   @see Context#relations
+    #
+    delegate :relations => :@context
+
+    # @!method response
+    #
+    #   Return response if available.
+    #
+    #   @return [Response] Response object.
+    #   @see Context#response
+    #
+    delegate :response => :@context
+
+    # @!method follow
+    #
+    #   Follow a LOCATION or CONTEXT-LOCATION header.
+    #
+    #   @return [Relation] Relation to follow resource.
+    #   @see Context#follow
+    #
+    delegate :follow => :@context
+  end
+end

data/lib/restify/error.rb

@@ -0,0 +1,53 @@
+module Restify
+  #
+  # A {ResponseError} is returned on a non-successful
+  # response from server. Usually it will either be a
+  # {ClientError} or a {ServerError}.
+  #
+  class ResponseError < StandardError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super "#{response.message} (#{response.code}) for `#{response.uri}':\n" \
+            "  #{errors.inspect}"
+    end
+
+    # Return response status.
+    #
+    # @return [Symbol] Response status.
+    # @see Response#status
+    #
+    def status
+      response.status
+    end
+
+    # Return response status code.
+    #
+    # @return [Fixnum] Response status code.
+    # @see Response#code
+    #
+    def code
+      response.code
+    end
+
+    # Return hash or array of errors if response included
+    # such a thing otherwise it returns nil.
+    #
+    def errors
+      if response.decoded_body
+        response.decoded_body['errors'] || response.decoded_body[:errors]
+      else
+        response.body
+      end
+    end
+  end
+
+  # A {ClientError} will be raised when a response has a
+  # 4XX status code.
+  class ClientError < ResponseError; end
+
+  # A {ServerError} will be raised when a response has a
+  # 5XX status code.
+  class ServerError < ResponseError; end
+end

data/lib/restify/http.rb

@@ -0,0 +1,34 @@
+require 'restify/adapter'
+
+module Restify
+
+  # @api private
+  #
+  class HTTP
+    # @api private
+    #
+    def initialize
+      @adapter = self.class.adapter
+    end
+
+    # @api private
+    #
+    # Request given path with given method.
+    #
+    # Returns an obligation that will return a collection or
+    # resource or fail with a response error depending on
+    # response from server.
+    #
+    def request(method, uri, data = nil, opts = {})
+      request = Request.new method: method, uri: uri, data: data
+
+      @adapter.call(request)
+    end
+
+    class << self
+      def adapter
+        @adapter ||= Restify::Adapter::EM.new
+      end
+    end
+  end
+end

data/lib/restify/link.rb

@@ -5,9 +5,9 @@ module Restify
   #
   class Link
     #
-    # URI of the link interpreted as a RFC6570 template.
+    # Extract URI string.
     #
-    # @return [Addressable::Template] URI template.
+    # @return [String] URI string.
     #
     attr_reader :uri
 
@@ -56,7 +56,7 @@ module Restify
 
       def parse_link(scanner)
         if (m = scanner.scan(REGEXP_URI))
-          uri    = Addressable::Template.new(m.strip[1..-2])
+          uri    = m.strip[1..-2]
           params = parse_params(scanner)
           new uri, params
         else

data/lib/restify/relation.rb

@@ -1,62 +1,54 @@
 module Restify
   #
   class Relation
-    def initialize(client, uri_template)
-      @client   = client
-      @template = if uri_template.is_a?(Addressable::Template)
-                    uri_template
-                  else
-                    Addressable::Template.new(uri_template)
-                  end
+    def initialize(context, source, pattern)
+      @context  = context
+      @source   = source
+      @template = to_template(pattern)
     end
 
     def get(params = {})
-      request :get, params
+      request :get, nil, params
     end
 
     def delete(params = {})
-      request :delete, params
+      request :delete, nil, params
     end
 
     def post(data = {}, params = {})
-      request :post, params.merge(data: data)
+      request :post, data, params
     end
 
     def put(data = {}, params = {})
-      request :put, params.merge(data: data)
+      request :put, data, params
     end
 
     def patch(data = {}, params = {})
-      request :patch, params.merge(data: data)
+      request :patch, data, params
     end
 
     def ==(other)
-      super || (other.is_a?(String) && @template.pattern == other)
+      super ||
+        (other.is_a?(String) && @template.pattern == other) ||
+        (other.is_a?(String) && @source == other)
     end
 
     private
 
     attr_reader :client, :template
 
-    def request(method, opts = {})
-      keys   = template.variables - Client::RESERVED_KEYS
-      params = extract_params(opts, keys)
-      uri    = template.expand(params)
+    def request(method, data, params)
+      uri = template.expand params
 
-      client.request method, uri, opts
+      @context.request method, uri, data
     end
 
-    def extract_params(opts, keys)
-      params = {}
-      keys.each do |key|
-        if opts.key?(key)
-          params[key] = opts.delete(key)
-        elsif opts.key?(key.to_sym)
-          params[key] = opts.delete(key.to_sym)
-        end
+    def to_template(pattern)
+      if pattern.is_a?(Addressable::Template)
+        pattern
+      else
+        Addressable::Template.new pattern
       end
-
-      params
     end
   end
 end

data/lib/restify/relations.rb

@@ -23,13 +23,5 @@ module Restify
       relations.fetch name
     end
     alias_method :relation, :rel
-
-    # Hash of all known relations.
-    #
-    # @return [Hash<String, Relation>] Relations.
-    #
-    def relations
-      @relations ||= Hashie::Mash.new
-    end
   end
 end

data/lib/restify/request.rb

@@ -25,7 +25,9 @@ module Restify
     end
 
     def body
-      @body ||= MultiJson.dump(data)
+      @body ||= begin
+        MultiJson.dump(data) unless data.nil?
+      end
     end
 
     def headers

data/lib/restify/resource.rb

@@ -1,17 +1,14 @@
 module Restify
   #
   class Resource < Hashie::Hash
-    include Result
+    include Contextual
     include Relations
     include Hashie::Extensions::IndifferentAccess
     include Hashie::Extensions::MethodReader
 
     #
-    def initialize(client, data = {}, response = nil)
-      @client   = client
-      @response = response
-
-      relations.merge! @response.relations(client) if @response
+    def initialize(context, data = {})
+      @context = context
 
       data.each_pair do |key, value|
         self[key.to_s] = convert_value(value)
@@ -25,8 +22,8 @@ module Restify
             next
         end
 
-        unless relations.key?(name) || value.nil? || value.to_s.empty?
-          relations[name] = Relation.new(client, value.to_s)
+        unless @context.relation?(name) || value.nil? || value.to_s.empty?
+          @context.add_relation name, value.to_s
         end
       end
     end
@@ -53,12 +50,7 @@ module Restify
     # @private
     #
     def convert_value(value)
-      case value
-        when Hash
-          self.new client, value
-        else
-          value
-      end
+      @context.inherit_value(value)
     end
   end
 end

data/lib/restify/response.rb

@@ -64,10 +64,17 @@ module Restify
     #
     attr_reader :request
 
+    # Last effective URI.
+    #
+    # @return [Addressable::URI] Last effective URI.
+    #
+    attr_reader :uri
+
     # @api private
     #
-    def initialize(request, code, headers, body)
+    def initialize(request, uri, code, headers, body)
       @request = request
+      @uri     = uri
       @code    = code
       @status  = STATUS_CODE_TO_SYMBOL[code]
       @headers = headers
@@ -75,12 +82,6 @@ module Restify
       @message = Rack::Utils::HTTP_STATUS_CODES[code]
     end
 
-    # Return URL of this response.
-    #
-    def url
-      request.uri
-    end
-
     # Return list of links from the Link header.
     #
     # @return [Array<Link>] Links.
@@ -100,20 +101,6 @@ module Restify
       end
     end
 
-    # Return list of relations extracted from links.
-    #
-    # @return [Array<Relation>] Relations.
-    #
-    def relations(client)
-      relations = {}
-      links.each do |link|
-        if (rel = link.metadata['rel'])
-          relations[rel] = Relation.new(client, link.uri)
-        end
-      end
-      relations
-    end
-
     # Return decoded body according to content type.
     # Will return `nil` if content cannot be decoded.
     #

data/spec/restify/link_spec.rb

@@ -8,7 +8,7 @@ describe Restify::Link do
           .parse('<http://example.org/search{?query}>; rel="search"')
 
         expect(links).to have(1).item
-        expect(links[0].uri.pattern).to eq 'http://example.org/search{?query}'
+        expect(links[0].uri).to eq 'http://example.org/search{?query}'
         expect(links[0].metadata).to eq 'rel' => 'search'
       end
 
@@ -17,7 +17,7 @@ describe Restify::Link do
           .parse('<http://example.org/search{?query}>; rel=search')
 
         expect(links).to have(1).item
-        expect(links[0].uri.pattern).to eq 'http://example.org/search{?query}'
+        expect(links[0].uri).to eq 'http://example.org/search{?query}'
         expect(links[0].metadata).to eq 'rel' => 'search'
       end
 
@@ -26,22 +26,22 @@ describe Restify::Link do
           .parse('<p://h.tld/p>; rel=abc, <p://h.tld/b>; a=b; c="d"')
 
         expect(links).to have(2).item
-        expect(links[0].uri.pattern).to eq 'p://h.tld/p'
+        expect(links[0].uri).to eq 'p://h.tld/p'
         expect(links[0].metadata).to eq 'rel' => 'abc'
-        expect(links[1].uri.pattern).to eq 'p://h.tld/b'
+        expect(links[1].uri).to eq 'p://h.tld/b'
         expect(links[1].metadata).to eq 'a' => 'b', 'c' => 'd'
       end
 
       it 'should parse link w/o meta' do
         links = described_class.parse('<p://h.tld/b>')
 
-        expect(links[0].uri.pattern).to eq 'p://h.tld/b'
+        expect(links[0].uri).to eq 'p://h.tld/b'
       end
 
       it 'should parse on invalid URI' do
         links = described_class.parse('<hp://:&*^/fwbhg3>')
 
-        expect(links[0].uri.pattern).to eq 'hp://:&*^/fwbhg3'
+        expect(links[0].uri).to eq 'hp://:&*^/fwbhg3'
       end
 
       it 'should error on invalid header' do

data/spec/restify/relation_spec.rb

@@ -1,12 +1,17 @@
 require 'spec_helper'
 
 describe Restify::Relation do
-  let(:client) { double 'client' }
-  let(:pattern) { 'http://test.host/resource/{id}' }
-  let(:relation) { described_class.new client, pattern }
+  let(:context) { double 'context' }
+  let(:source) { '/resource/{id}' }
+  let(:pattern) { "http://test.host/#{source}" }
+  let(:relation) { described_class.new context, source, pattern }
   subject { relation }
 
   describe '#==' do
+    it 'should equal source' do
+      expect(subject).to eq source
+    end
+
     it 'should equal pattern' do
       expect(subject).to eq pattern
     end

data/spec/restify/resource_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe Restify::Resource do
-  let(:client) { double 'client' }
   let(:data) { {} }
-  let(:res)    { described_class.new(client, data) }
+  let(:http) { double 'http' }
+  let(:context) { Restify::Context.new 'http://example.org', http }
+  let(:res) { described_class.new(context, data) }
 
   describe '#rel?' do
     let(:data) do

data/spec/restify_spec.rb

@@ -144,17 +144,17 @@ describe Restify do
 
         # The server returns a 201 Created response with the created
         # resource.
-        expect(created_user.status).to eq :created
-        expect(created_user.code).to eq 201
+        expect(created_user.response.status).to eq :created
+        expect(created_user.response.code).to eq 201
 
         expect(created_user).to have_key :name
         expect(created_user.name).to eq 'John Smith'
 
         # Let's follow the "Location" header.
-        followed_resource = created_user.follow.value
+        followed_resource = created_user.follow.get.value
 
-        expect(followed_resource.status).to eq :ok
-        expect(followed_resource.code).to eq 200
+        expect(followed_resource.response.status).to eq :ok
+        expect(followed_resource.response.code).to eq 200
 
         expect(followed_resource).to have_key :name
         expect(followed_resource.name).to eq 'John Smith'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restify
 version: !ruby/object:Gem::Version
-  version: 0.1.2.1.b38
+  version: 0.1.2.1.b40
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-13 00:00:00.000000000 Z
+date: 2014-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: obligation
@@ -120,8 +120,11 @@ files:
 - README.md
 - lib/restify.rb
 - lib/restify/adapter.rb
-- lib/restify/client.rb
 - lib/restify/collection.rb
+- lib/restify/context.rb
+- lib/restify/contextual.rb
+- lib/restify/error.rb
+- lib/restify/http.rb
 - lib/restify/link.rb
 - lib/restify/parser/json.rb
 - lib/restify/relation.rb
@@ -129,7 +132,6 @@ files:
 - lib/restify/request.rb
 - lib/restify/resource.rb
 - lib/restify/response.rb
-- lib/restify/result.rb
 - lib/restify/version.rb
 - restify.gemspec
 - spec/restify/collection_spec.rb

data/lib/restify/client.rb

@@ -1,110 +0,0 @@
-module Restify
-  #
-  # A {ResponseError} is returned on a non-successful
-  # response from server. Usually it will either be a
-  # {ClientError} or a {ServerError}.
-  #
-  class ResponseError < StandardError
-    attr_reader :response
-
-    def initialize(response)
-      @response = response
-      super "#{response.message} (#{response.code}) for `#{response.url}':\n" \
-            "  #{errors.inspect}"
-    end
-
-    # Return response status.
-    #
-    # @return [Symbol] Response status.
-    # @see Response#status
-    #
-    def status
-      response.status
-    end
-
-    # Return response status code.
-    #
-    # @return [Fixnum] Response status code.
-    # @see Response#code
-    #
-    def code
-      response.code
-    end
-
-    # Return hash or array of errors if response included
-    # such a thing otherwise it returns nil.
-    #
-    def errors
-      if response.decoded_body
-        response.decoded_body['errors'] || response.decoded_body[:errors]
-      else
-        response.body
-      end
-    end
-  end
-
-  # A {ClientError} will be raised when a response has a
-  # 4XX status code.
-  class ClientError < ResponseError; end
-
-  # A {ServerError} will be raised when a response has a
-  # 5XX status code.
-  class ServerError < ResponseError; end
-
-  # @api private
-  #
-  class Client
-    #
-    # Keys that should not be extracted from options
-    # to expand URI templates.
-    RESERVED_KEYS = %w(data)
-
-    # @api private
-    #
-    # Request given path with given method.
-    #
-    # Returns an obligation that will return a collection or
-    # resource or fail with a response error depending on
-    # response from server.
-    #
-    def request(method, path, opts = {})
-      data    = opts.fetch(:data, opts)
-      request = Request.new method: method, uri: base.join(path.to_s), data: data
-
-      ::Restify.adapter.call(request).then do |response|
-        if response.success?
-          handle_success response
-        else
-          handle_error response
-        end
-      end
-    end
-
-    private
-
-    attr_reader :base
-
-    def initialize(uri)
-      @base = ::Addressable::URI.parse(uri)
-    end
-
-    def handle_success(response)
-      if response.decoded_body.is_a?(Array)
-        Collection.new(self, response.decoded_body, response)
-      else
-        Resource.new(self, response.decoded_body, response)
-      end
-    end
-
-    def handle_error(response)
-      case response.code
-      when 400...500
-        raise ClientError.new(response)
-      when 500...600
-        raise ServerError.new(response)
-      else
-        raise RuntimeError.new "Unknown response code: #{response.code}"
-      end
-    end
-  end
-end

data/lib/restify/result.rb

@@ -1,34 +0,0 @@
-module Restify
-  module Result
-    # Return response status if available.
-    #
-    # @return [Symbol] Response status.
-    # @see Response#status
-    #
-    def status
-      @response ? @response.status : nil
-    end
-
-    # Return response status code if available.
-    #
-    # @return [Fixnum] Response status code.
-    # @see Response#code
-    #
-    def code
-      @response ? @response.code : nil
-    end
-
-    # Follow the Location header from the response of
-    # this resource if available.
-    #
-    # @return [Obligation<Resource>] Followed resource.
-    #
-    def follow
-      if @response && @response.headers['LOCATION']
-        @client.request :get, @response.headers['LOCATION']
-      else
-        raise RuntimeError.new 'Nothing to follow.'
-      end
-    end
-  end
-end