restify 0.3.2.1.b59 → 0.3.2.1.b62

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzVkNjRlMjY2MGFjMDEwOTlhMWJjYmIzMTYxMWM4MTJkZWE1NjY1MQ==
+    ZGMzYTA4ODFiZDdhYTBkMTQyZTA4YTIxNmM5NDcwZmQ0Yjk4MjFkYQ==
   data.tar.gz: !binary |-
-    ZDdlYmYwOThhNjNmMTRjMzBkOTE0OGE4ZjFkY2Q0NThiZjI0NDZjYw==
+    ODg4MzU4NWY4ZjRjZGM4N2IyNWM3Nzk3NjY4NjI4ZTVjZjU1MTExOQ==
 SHA512:
   metadata.gz: !binary |-
-    ZGUyMWViNzUyYmU3NGVhMjE3MzhkM2ZhNjUxMGZhNGE2NmU4YjZmODE1MDE1
-    ZThkNGU2MzM1NGFiOWZiNTZmZjFjNjY4YTYyZTI4MDI5MTNkZDY0M2ZiNzg5
-    ZjE0YTFlNTVmMzMyNzg0NDllNGE4OWVlMDlhMjFlOWNlMmQ4MzQ=
+    M2U5M2YyZmQ5MzJmYmE3ODZhY2M2NDRiYTYwMmNiYTc3ZmYzY2VmN2Y0N2Ix
+    NDkxMmIxNDFlOTU3NmRkZmU0ZGRlMmU5NDdjY2UyOWFlN2I1NzgwOGZjZTQw
+    MmIxNzc2M2QzN2Q3ZWNiYmIzNjBhZmUwMjBmYTk4YzljMmRlNmQ=
   data.tar.gz: !binary |-
-    MGNhODg4M2JiNWMyNzAwNjlmZDgwZTJhMzMzZGJlMzA1YjMxYmNiZWM4NDk0
-    ODlhYWQ0ZTM5ZTBjOTI0ZjI3ZmQ3MzhkMTQyOGVhMDA2YzBiOGE5ZTBiNTcy
-    MzdjZTI1ODMyNzU4ZTRkOTFhMGI3NmEzN2MwMTI0MDA5ZjdiNjk=
+    ZWYzZjQ1M2ZiMTRiZDIzOTYyMzgzM2ExMDYzODg2YzVlYjM2Yzk1ZjFlMzZi
+    NTc3YjZlMGJiNzcxYWFhNWE0YjBkMTIzNmQzM2Y5OGQ2NzcwNDY1MmEwMGJh
+    ZGI0NTRiN2RlMDgzNzBiMjIwZGRjNjMyNGNiODAwMzFiNjdkOGY=

data/lib/restify.rb

@@ -2,7 +2,6 @@ require 'restify/version'
 
 require 'hashie'
 require 'obligation'
-require 'multi_json'
 require 'addressable/uri'
 require 'addressable/template'
 
@@ -10,11 +9,8 @@ require 'addressable/template'
 module Restify
   require 'restify/http'
   require 'restify/error'
-  require 'restify/relations'
 
   require 'restify/context'
-  require 'restify/contextual'
-  require 'restify/collection'
   require 'restify/resource'
   require 'restify/relation'
 
@@ -22,9 +18,16 @@ module Restify
   require 'restify/request'
   require 'restify/response'
 
+  module Processors
+    require 'restify/processors/base'
+    require 'restify/processors/json'
+  end
+
+  PROCESSORS = [Processors::Json]
+
   class << self
     def new(uri, opts = {})
-      Context.new(uri, http, nil, opts).request(:GET, uri)
+      Context.new(uri, http).request(:GET, uri)
     end
 
     def http

data/lib/restify/adapter/em.rb

@@ -125,7 +125,7 @@ module Restify
           begin
             EventMachine.run {}
           rescue => e
-            puts "Resitfy::Adapter::EM -> #{e}\n#{e.backtrace.join("\n")}"
+            puts "#{self.class} -> #{e}\n#{e.backtrace.join("\n")}"
             raise e
           end
         end unless EventMachine.reactor_running?

data/lib/restify/context.rb

@@ -6,110 +6,40 @@ module Restify
   # 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)
+    def initialize(uri, http)
+      @uri  = uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri.to_s)
       @http = http
-      @response = response
     end
 
-    def relations
-      @relations ||= load_relations
+    def join(uri)
+      self.uri.join uri
     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 process(response)
+      context   = Context.new response.uri, @http
+      processor = Restify::PROCESSORS.find { |p| p.accept? response }
+      processor ||= Restify::Processors::Base
 
-    def follow
-      if follow_location
-        new_relation follow_location
-      else
-        raise RuntimeError.new 'Nothing to follow'
-      end
+      processor.new(context, response).resource
     end
 
     def request(method, uri, data = nil, opts = {})
-      request = @http.request(method, expand(uri), data, opts)
+      request = @http.request(method, join(uri), data, opts)
       request.then do |response|
         if response.success?
-          inherit(uri: response.uri, response: response)
-            .new_value(response.decoded_body)
+          process response
         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
-      return unless @response
-
-      @response.headers['LOCATION'] || @response.headers['CONTENT-LOCATION']
-    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

data/lib/restify/error.rb

@@ -36,7 +36,7 @@ module Restify
     #
     def errors
       if response.decoded_body
-        response.decoded_body['errors'] || response.decoded_body[:errors]
+        response.decoded_body['errors'] || response.decoded_body[:errors] || response.decoded_body
       else
         response.body
       end

data/lib/restify/processors/base.rb

@@ -0,0 +1,70 @@
+module Restify
+  #
+  module Processors
+    #
+    class Base
+      extend Forwardable
+
+      #
+      attr_reader :context
+
+      #
+      attr_reader :response
+
+      def initialize(context, response)
+        @context  = context
+        @response = response
+      end
+
+      def resource
+        @resource ||= begin
+          resource = load
+
+          unless resource.is_a? Restify::Resource
+            resource = Resource.new context, response: response, data: resource
+          end
+
+          resource._restify_response = response
+          merge_relations! resource._restify_relations
+
+          resource
+        end
+      end
+
+      # Return resource or data.
+      #
+      # Should be overridden in subclass.
+      #
+      def load
+
+      end
+
+      # @!method body
+      #
+      delegate body: :@response
+
+      private
+
+      def merge_relations!(relations)
+        response.links.each do |link|
+          name  = link.metadata['rel']
+          value = link.uri
+
+          if !name.empty? && !relations.key?(name)
+            relations[name] = value
+          end
+        end
+
+        if (location = @response.follow_location)
+          relations[:_restify_follow] = location
+        end
+      end
+
+      class << self
+        def accept?(response)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/restify/processors/json.rb

@@ -0,0 +1,83 @@
+module Restify
+  #
+  module Processors
+    #
+    # Decode plain JSON responses.
+    #
+    # JSON fields matching *_url will be parsed as relations.
+    #
+    class Json < Base
+
+      def load
+        parse JSON.load(body), root: true
+      end
+
+      private
+
+      def parse(object, root: false)
+        case object
+          when Hash
+            data      = object.each_with_object({}, &method(:parse_data))
+            relations = object.each_with_object({}, &method(:parse_rels))
+
+            if self.class.indifferent_access?
+              data = with_indifferent_access(data)
+            end
+
+            if root
+              Resource.new context, response: response, data: data, relations: relations
+            else
+              Resource.new context, data: data, relations: relations
+            end
+          when Array
+            object.map(&method(:parse))
+          else
+            object
+        end
+      end
+
+      def parse_data(pair, data)
+        data[pair[0].to_s] = parse pair[1]
+      end
+
+      def parse_rels(pair, relations)
+        name = case pair[0].to_s.downcase
+          when /\A(\w+)_url\z/
+            Regexp.last_match[1]
+          when 'url'
+            'self'
+          else
+            return
+        end
+
+        return if relations.key?(name) || pair[1].nil? || pair[1].to_s =~ /\A\w*\z/
+
+        relations[name] = pair[1].to_s
+      end
+
+      def json
+        @json ||= JSON.load response.body
+      end
+
+      def with_indifferent_access(data)
+        Hashie::Mash.new data
+      end
+
+      class << self
+        def accept?(response)
+          response.content_type =~ /\Aapplication\/json($|;)/
+        end
+
+        def indifferent_access?
+          @@indifferent_access
+        end
+
+        def indifferent_access=(value)
+          @@indifferent_access = value
+        end
+
+        @@indifferent_access = true
+      end
+    end
+  end
+end

data/lib/restify/relation.rb

@@ -1,10 +1,9 @@
 module Restify
   #
   class Relation
-    def initialize(context, source, pattern)
+    def initialize(context, template)
       @context  = context
-      @source   = source
-      @template = to_template(pattern)
+      @template = Addressable::Template.new template
     end
 
     def get(params = {})
@@ -28,9 +27,7 @@ module Restify
     end
 
     def ==(other)
-      super ||
-        (other.is_a?(String) && @template.pattern == other) ||
-        (other.is_a?(String) && @source == other)
+      super || (other.is_a?(String) && @template.pattern == other)
     end
 
     def expand(params)
@@ -39,7 +36,8 @@ module Restify
 
       uri = @template.expand variables
       uri.query_values = (uri.query_values || {}).merge params if params.any?
-      uri
+
+      @context.join uri
     end
 
     private

data/lib/restify/request.rb

@@ -19,14 +19,14 @@ module Restify
     attr_reader :data
 
     def initialize(opts = {})
-      @method = opts.fetch(:method, :get)
+      @method = opts.fetch(:method, :get).downcase
       @uri    = opts.fetch(:uri) { raise ArgumentError.new ':uri required.' }
       @data   = opts.fetch(:data, nil)
     end
 
     def body
       @body ||= begin
-        MultiJson.dump(data) unless data.nil?
+        JSON.dump(data) unless data.nil?
       end
     end
 

data/lib/restify/resource.rb

@@ -1,56 +1,93 @@
+require 'delegate'
+
 module Restify
   #
-  class Resource < Hashie::Hash
-    include Contextual
-    include Relations
-    include Hashie::Extensions::IndifferentAccess
-    include Hashie::Extensions::MethodReader
-
-    #
-    def initialize(context, data = {})
-      @context = context
-
-      data.each_pair do |key, value|
-        self[key.to_s] = convert_value(value)
-
-        name = case key.to_s.downcase
-          when /\A(\w+)_url\z/
-            Regexp.last_match[1]
-          when 'url'
-            'self'
-          else
-            next
-        end
-
-        unless @context.relation?(name) || value.nil? || value.to_s.empty?
-          @context.add_relation name, value.to_s
-        end
-      end
+  class Resource < Delegator
+    extend Forwardable
+
+    # @api private
+    #
+    def initialize(context, response: nil, data: nil, relations: {})
+      @data      = data
+      @context   = context
+      @response  = response
+      @relations = relations
     end
 
-    # Compare with other {Resource}s or hashes.
+    # @api private
     #
-    def ==(other)
-      case other
-        when Resource
-          super && relations == other.relations
-        when Hash
-          super Hash[other.map {|k, v| [convert_key(k), v] }]
-        else
-          super
-      end
+    def __getobj__
+      @data
     end
 
-    # @private
+    # Check if resource has a relation with given name.
+    #
+    # @param name [String, Symbol] Relation name.
+    # @return [Boolean] True if resource has relation, false otherwise.
     #
-    def convert_key(key)
-      key.to_s
+    def relation?(name)
+      @relations.key?(name) || @relations.key?(name.to_s)
     end
 
-    # @private
+    alias_method :rel?, :relation?
+    alias_method :has_rel?, :relation?
+    alias_method :has_relation?, :relation?
+
+    # Return relation with given name.
+    #
+    # @param name [String, Symbol] Relation name.
+    # @return [Relation] Relation.
+    #
+    def relation(name)
+      if @relations.key? name
+        Relation.new @context, @relations.fetch(name)
+      else
+        Relation.new @context, @relations.fetch(name.to_s)
+      end
+    end
+
+    alias_method :rel, :relation
+
+    # @!method response
     #
-    def convert_value(value)
-      @context.inherit_value(value)
+    #   Return response if available.
+    #
+    #   @return [Response] Response object.
+    #   @see Context#response
+    #
+    attr_reader :response
+
+    # Follow a LOCATION or CONTEXT-LOCATION header.
+    #
+    # @return [Relation] Relation to follow resource.
+    # @raise RuntimeError If nothing to follow.
+    #
+    def follow
+      if relation? :_restify_follow
+        relation :_restify_follow
+      else
+        raise RuntimeError.new 'Nothing to follow'
+      end
+    end
+
+    # @api private
+    def _restify_relations
+      @relations
+    end
+
+    # @api private
+    def _restify_response=(response)
+      @response = response
+    end
+
+    # @api private
+    def inspect
+      text = {
+        "@data" => @data,
+        "@relations" => @relations
+      }.map {|k,v | k + '=' + v.inspect }.join(' ')
+
+      "#<#{self.class} #{text}>"
     end
   end
 end

data/lib/restify/response.rb

@@ -77,7 +77,7 @@ module Restify
       @uri     = uri
       @code    = code
       @status  = STATUS_CODE_TO_SYMBOL[code]
-      @headers = headers
+      @headers = convert_headers(headers)
       @body    = body
       @message = Rack::Utils::HTTP_STATUS_CODES[code]
     end
@@ -88,9 +88,9 @@ module Restify
     #
     def links
       @links ||= begin
-        if headers['Link']
+        if headers['LINK']
           begin
-            Link.parse(headers['Link'])
+            Link.parse(headers['LINK'])
           rescue ArgumentError => e
             warn e
             []
@@ -101,18 +101,12 @@ module Restify
       end
     end
 
-    # Return decoded body according to content type.
-    # Will return `nil` if content cannot be decoded.
+    # Return content type header from response headers.
     #
-    # @return [Array, Hash, NilClass] Decoded response body.
+    # @return [String] Content type header.
     #
-    def decoded_body
-      @decoded_body ||= begin
-        case headers['Content-Type']
-          when /\Aapplication\/json($|;)/
-            MultiJson.load body
-        end
-      end
+    def content_type
+      headers['CONTENT_TYPE']
     end
 
     # Check if response is successful e.g. the status code
@@ -123,5 +117,28 @@ module Restify
     def success?
       (200...300).include? code
     end
+
+    # @api private
+    def decoded_body
+      @decoded_body ||= begin
+        case content_type
+          when /\Aapplication\/json($|;)/
+            JSON.load body
+        end
+      end
+    end
+
+    # @api private
+    def follow_location
+      headers['LOCATION'] || headers['CONENT_LOCATION']
+    end
+
+    private
+
+    def convert_headers(headers)
+      headers.each_with_object({}) do |pair, hash|
+        hash[pair[0].upcase] = pair[1]
+      end
+    end
   end
 end

data/restify.gemspec

@@ -20,11 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'obligation', '~> 0.1'
   spec.add_runtime_dependency 'addressable', '~> 2.3'
-  spec.add_runtime_dependency 'http', '~> 0.8.12'
-  spec.add_runtime_dependency 'celluloid-io', '~> 0.16.2'
   spec.add_runtime_dependency 'em-http-request'
   spec.add_runtime_dependency 'hashie', '~> 3.3'
-  spec.add_runtime_dependency 'multi_json'
   spec.add_runtime_dependency 'rack'
 
   spec.add_development_dependency 'bundler', '~> 1.5'

data/spec/restify/processors/json_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe Restify::Processors::Json do
+  let(:context)  { Restify::Context.new('http://test.host/', nil) }
+  let(:response) { double 'response' }
+
+  before do
+    allow(response).to receive(:links).and_return []
+    allow(response).to receive(:follow_location).and_return nil
+  end
+
+  describe 'class' do
+    describe '#accept?' do
+      subject { described_class.accept? response }
+
+      it 'accepts JSON mime type (I)' do
+        expect(response).to receive(:content_type).and_return('application/json')
+        expect(subject).to be_truthy
+      end
+
+      it 'accepts JSON mime type (II)' do
+        expect(response).to receive(:content_type).and_return('application/json; abc')
+        expect(subject).to be_truthy
+      end
+    end
+  end
+
+  describe '#resource' do
+    subject { described_class.new(context, response).resource }
+    before { allow(response).to receive(:body).and_return(body) }
+
+    context 'parsing' do
+      context 'single object' do
+        let(:body) do <<-JSON
+            {"key": "value"}
+          JSON
+        end
+
+        it { is_expected.to be_a Restify::Resource }
+        it { expect(subject.response).to be response }
+        it { is_expected.to eq 'key' => 'value' }
+      end
+
+      context 'object with relation fields' do
+        let(:body) do <<-JSON
+            {"key": "value", "search_url": "https://google.com{?q}"}
+          JSON
+        end
+
+        it do
+          is_expected.to eq \
+            'key' => 'value', 'search_url' => 'https://google.com{?q}'
+        end
+
+        it { is_expected.to have_relation :search }
+        it { expect(subject.relation(:search)).to eq 'https://google.com{?q}' }
+      end
+
+      context 'object with implicit self relation' do
+        let(:body) do <<-JSON
+            {"key": "value", "url": "/self"}
+          JSON
+        end
+
+        it { expect(subject.relation(:self)).to eq '/self' }
+      end
+
+      context 'single array' do
+        let(:body) do <<-JSON
+            [1, 2, null, "STR"]
+          JSON
+        end
+
+        it { is_expected.to be_a Restify::Resource }
+        it { expect(subject.response).to be response }
+        it { is_expected.to eq [1, 2, nil, "STR"] }
+      end
+
+      context 'array with objects' do
+        let(:body) do <<-JSON
+            [{"a":0}, {"b":1}]
+          JSON
+        end
+
+        it { is_expected.to eq [{'a' => 0}, {'b' => 1}] }
+      end
+
+      context 'array with resources' do
+        let(:body) do <<-JSON
+            [{"name": "John", "self_url": "/users/john"},
+             {"name": "Jane", "self_url": "/users/jane"}]
+          JSON
+        end
+
+        it 'parses objects as resources' do
+          expect(subject.map(&:class)).to eq \
+            [Restify::Resource, Restify::Resource]
+        end
+
+        it 'parses relations of resources' do
+          expect(subject.map {|r| r.relation :self }).to eq \
+            ['/users/john', '/users/jane']
+        end
+      end
+
+      context 'nested objects' do
+        let(:body) do <<-JSON
+            {"john": {"name": "John"},
+             "jane": {"name": "Jane"}}
+          JSON
+        end
+
+        it { is_expected.to be_a Restify::Resource }
+        it { expect(subject.response).to be response }
+
+        it 'parses objects as resources' do
+          expect(subject['john']).to be_a Restify::Resource
+          expect(subject['jane']).to be_a Restify::Resource
+
+          expect(subject['john']['name']).to eq 'John'
+          expect(subject['jane']['name']).to eq 'Jane'
+        end
+      end
+
+      context 'single value' do
+        let(:body) do <<-JSON
+            "BLUB"
+          JSON
+        end
+
+        it { is_expected.to be_a Restify::Resource }
+        it { expect(subject.response).to be response }
+        it { is_expected.to eq "BLUB" }
+      end
+
+      context 'with indifferent access' do
+        let(:body) do <<-JSON
+            {"name": "John", "age": 24}
+          JSON
+        end
+
+        it '#key?' do
+          expect(subject).to have_key 'name'
+          expect(subject).to have_key 'age'
+
+          expect(subject).to have_key :name
+          expect(subject).to have_key :age
+        end
+
+        it '#[]' do
+          expect(subject['name']).to eq 'John'
+          expect(subject['age']).to eq 24
+
+          expect(subject[:name]).to eq 'John'
+          expect(subject[:age]).to eq 24
+        end
+      end
+
+      context 'with method getter access' do
+        let(:body) do <<-JSON
+            {"name": "John", "age": 24}
+          JSON
+        end
+
+        it '#<method getter>' do
+          expect(subject).to respond_to :name
+          expect(subject).to respond_to :age
+
+          expect(subject.name).to eq 'John'
+          expect(subject.age).to eq 24
+        end
+      end
+    end
+  end
+end

data/spec/restify/relation_spec.rb

@@ -1,17 +1,12 @@
 require 'spec_helper'
 
 describe Restify::Relation do
-  let(:context) { double 'context' }
-  let(:source) { '/resource/{id}' }
-  let(:pattern) { "http://test.host#{source}" }
-  let(:relation) { described_class.new context, source, pattern }
+  let(:context)  { Restify::Context.new('http://test.host/', nil) }
+  let(:pattern)  { '/resource/{id}' }
+  let(:relation) { described_class.new context, 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
@@ -38,7 +33,7 @@ describe Restify::Relation do
     end
 
     context 'with unknown additional query parameter' do
-      let(:source) { '/resource{?a,b}' }
+      let(:pattern) { '/resource{?a,b}' }
       let(:params) { {a: 1, b: 2, c: 3} }
 
       it { expect(subject.to_s).to eq 'http://test.host/resource?a=1&b=2&c=3' }

data/spec/restify/resource_spec.rb

@@ -1,158 +1,91 @@
 require 'spec_helper'
 
 describe Restify::Resource do
-  let(: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
-      {
-        'users_url' => 'http://example.org/users',
-        'projects_url' => 'http://example.org/projects'
-      }
-    end
-
-    it 'should match relations' do
-      expect(res.rel?(:users)).to eq true
-      expect(res.rel?('users')).to eq true
-      expect(res.rel?(:projects)).to eq true
-      expect(res.rel?('projects')).to eq true
-      expect(res.rel?('fuu')).to eq false
-
-      expect(res).to have_rel :users
-      expect(res).to have_rel :projects
-
-      expect(res.relation?(:users)).to eq true
-      expect(res.relation?('users')).to eq true
-      expect(res.relation?(:projects)).to eq true
-      expect(res.relation?('projects')).to eq true
-      expect(res.relation?('fuu')).to eq false
-
-      expect(res).to have_relation :users
-      expect(res).to have_relation :projects
-    end
+  let(:data)      { {} }
+  let(:relations) { {} }
+  let(:context)   { double 'context' }
+  let(:response)  { double 'response' }
+  let(:resource)  { described_class.new(context, response: response, data: data, relations: relations) }
+  subject { resource }
+
+  before do
+    allow(context).to receive(:relation?).and_return(false)
+    allow(context).to receive(:relation).and_raise(KeyError)
   end
 
-  describe '#rel' do
-    let(:data) do
+  context 'relations' do
+    let(:relations) do
       {
-        'users_url' => 'http://example.org/users',
-        'projects_url' => 'http://example.org/projects'
+        'users' => 'http://example.org/users',
+        'projects' => 'http://example.org/projects'
       }
     end
 
-    it 'should return relation' do
-      expect(res.rel(:users)).to eq 'http://example.org/users'
-      expect(res.rel('users')).to eq 'http://example.org/users'
-      expect(res.rel(:projects)).to eq 'http://example.org/projects'
-      expect(res.rel('projects')).to eq 'http://example.org/projects'
-      expect { res.rel(:fuu) }.to raise_error KeyError
-
-      expect(res.relation(:users)).to eq 'http://example.org/users'
-      expect(res.relation('users')).to eq 'http://example.org/users'
-      expect(res.relation(:projects)).to eq 'http://example.org/projects'
-      expect(res.relation('projects')).to eq 'http://example.org/projects'
-      expect { res.relation(:fuu) }.to raise_error KeyError
+    describe '#relation?' do
+      it 'should match relations' do
+        expect(subject.relation?(:users)).to eq true
+        expect(subject.relation?('users')).to eq true
+        expect(subject.relation?(:projects)).to eq true
+        expect(subject.relation?('projects')).to eq true
+        expect(subject.relation?('fuu')).to eq false
+
+        expect(subject).to have_relation :users
+        expect(subject).to have_relation :projects
+
+        expect(subject.rel?(:users)).to eq true
+        expect(subject.rel?('users')).to eq true
+        expect(subject.rel?(:projects)).to eq true
+        expect(subject.rel?('projects')).to eq true
+        expect(subject.rel?('fuu')).to eq false
+
+        expect(subject).to have_rel :users
+        expect(subject).to have_rel :projects
+      end
     end
-  end
-
-  describe '#key?' do
-    let(:data) { {a: 0, 'b' => 1, 0 => 2} }
-
-    it 'should test for key inclusion' do
-      expect(res.key?(:a)).to eq true
-      expect(res.key?(:b)).to eq true
-      expect(res.key?('a')).to eq true
-      expect(res.key?('b')).to eq true
-      expect(res.key?(0)).to eq true
-
-      expect(res.key?(:c)).to eq false
-      expect(res.key?('d')).to eq false
 
-      expect(res).to have_key :a
-      expect(res).to have_key :b
-      expect(res).to have_key 'a'
-      expect(res).to have_key 'b'
-      expect(res).to have_key 0
-
-      expect(res).to_not have_key :c
-      expect(res).to_not have_key 'd'
+    describe '#relation' do
+      it 'should return relation' do
+        expect(subject.rel(:users)).to be_a Restify::Relation
+
+        expect(subject.rel(:users)).to eq 'http://example.org/users'
+        expect(subject.rel('users')).to eq 'http://example.org/users'
+        expect(subject.rel(:projects)).to eq 'http://example.org/projects'
+        expect(subject.rel('projects')).to eq 'http://example.org/projects'
+        expect { subject.rel(:fuu) }.to raise_error KeyError
+
+        expect(subject.relation(:users)).to eq 'http://example.org/users'
+        expect(subject.relation('users')).to eq 'http://example.org/users'
+        expect(subject.relation(:projects)).to eq 'http://example.org/projects'
+        expect(subject.relation('projects')).to eq 'http://example.org/projects'
+        expect { subject.relation(:fuu) }.to raise_error KeyError
+      end
     end
-  end
 
-  describe '#each' do
-    let(:data) { {a: 0, b: 1} }
-
-    it 'should yield' do
-      expect {|cb| res.each(&cb) }.to yield_control.twice
-      expect {|cb| res.each(&cb) }.to yield_successive_args ['a', 0], ['b', 1]
-    end
+    context '#follow' do
+      let(:relations) { {_restify_follow: 'http://localhost/10'} }
 
-    it 'should return enumerator' do
-      expect(res.each).to be_a Enumerator
-      expect(res.each.to_a).to eq [['a', 0], ['b', 1]]
+      it 'returns follow relation' do
+        expect(subject.follow).to be_a Restify::Relation
+        expect(subject.follow).to eq 'http://localhost/10'
+      end
     end
   end
 
-  describe '#[]' do
-    let(:data) { {a: 0, b: 1} }
+  context 'data' do
+    let(:data) { double 'data' }
 
-    it 'should return data' do
-      expect(res[:a]).to eq 0
-      expect(res[:b]).to eq 1
-    end
-  end
-
-  describe '<getter>' do
-    let(:data) { {a: 0, b: 1} }
-
-    it 'should return data' do
-      expect(res).to respond_to :a
-      expect(res).to respond_to :b
-
-      expect(res.a).to eq 0
-      expect(res.b).to eq 1
-    end
-  end
-
-  describe '#==' do
-    let(:data) { {a: 0, b: 1} }
+    it 'should delegate methods (I)' do
+      expect(data).to receive(:some_method).and_return(42)
 
-    it 'should eq hash' do
-      expect(res).to eq a: 0, b: 1
-      expect(res).to eq 'a' => 0, 'b' => 1
+      expect(subject).to respond_to :some_method
+      expect(subject.some_method).to eq 42
     end
-  end
-
-  describe '#include?' do
-    let(:data) { {a: 0, b: 1} }
-
-    it 'should include partial hash' do
-      expect(res).to include a: 0
-      expect(res).to include b: 1
-
-      expect(res).to include 'a' => 0
-      expect(res).to include 'b' => 1
-
-      expect(res).to_not include a: 1
-      expect(res).to_not include c: 0
-      expect(res).to_not include 'a' => 1
-      expect(res).to_not include 'c' => 0
-    end
-  end
-
-  describe '#[]=' do
-    let(:data) { {a: 0, b: 1} }
 
-    it 'should return data' do
-      res[:a] = 5
-      res[:c] = 15
+    it 'should delegate methods (II)' do
+      expect(data).to receive(:[]).with(1).and_return(2)
 
-      expect(res[:a]).to eq 5
-      expect(res[:b]).to eq 1
-      expect(res[:c]).to eq 15
+      expect(subject).to respond_to :[]
+      expect(subject[1]).to eq 2
     end
   end
 end

data/spec/support/hack_causes.rb

@@ -0,0 +1,14 @@
+
+class Obligation::RejectedError
+  def backtrace
+    if cause
+      if (sup = super).nil?
+        sup
+      else
+        super + ["==== caused by #{cause.class}: #{cause}"] + cause.backtrace
+      end
+    else
+      super
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restify
 version: !ruby/object:Gem::Version
-  version: 0.3.2.1.b59
+  version: 0.3.2.1.b62
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-01 00:00:00.000000000 Z
+date: 2015-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: obligation
@@ -38,34 +38,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.3'
-- !ruby/object:Gem::Dependency
-  name: http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.8.12
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.8.12
-- !ruby/object:Gem::Dependency
-  name: celluloid-io
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.16.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.16.2
 - !ruby/object:Gem::Dependency
   name: em-http-request
   requirement: !ruby/object:Gem::Requirement
@@ -94,20 +66,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.3'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -149,26 +107,25 @@ files:
 - lib/restify.rb
 - lib/restify/adapter/celluloid.rb
 - lib/restify/adapter/em.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/processors/base.rb
+- lib/restify/processors/json.rb
 - lib/restify/relation.rb
-- lib/restify/relations.rb
 - lib/restify/request.rb
 - lib/restify/resource.rb
 - lib/restify/response.rb
 - lib/restify/version.rb
 - restify.gemspec
-- spec/restify/collection_spec.rb
 - spec/restify/link_spec.rb
+- spec/restify/processors/json_spec.rb
 - spec/restify/relation_spec.rb
 - spec/restify/resource_spec.rb
 - spec/restify_spec.rb
 - spec/spec_helper.rb
+- spec/support/hack_causes.rb
 homepage: https://github.com/jgraichen/restify
 licenses:
 - LGPLv3
@@ -194,9 +151,10 @@ signing_key:
 specification_version: 4
 summary: An experimental hypermedia REST client.
 test_files:
-- spec/restify/collection_spec.rb
 - spec/restify/link_spec.rb
+- spec/restify/processors/json_spec.rb
 - spec/restify/relation_spec.rb
 - spec/restify/resource_spec.rb
 - spec/restify_spec.rb
 - spec/spec_helper.rb
+- spec/support/hack_causes.rb

data/lib/restify/collection.rb

@@ -1,15 +0,0 @@
-module Restify
-  #
-  class Collection < Array
-    include Contextual
-    include Relations
-
-    def initialize(context, data = [])
-      @context = context
-
-      super data
-
-      map! {|item| @context.inherit_value(item) }
-    end
-  end
-end

data/lib/restify/contextual.rb

@@ -1,34 +0,0 @@
-require 'forwardable'
-
-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/parser/json.rb

@@ -1,16 +0,0 @@
-module Restify
-  #
-  module Processors
-    #
-    # Decode JSON responses.
-    class JSON
-      def parse(str)
-        MultiJSON.load(str)
-      end
-
-      def format
-        :json
-      end
-    end
-  end
-end

data/lib/restify/relations.rb

@@ -1,27 +0,0 @@
-module Restify
-  #
-  module Relations
-    #
-    # Check if resource has a relation with given name.
-    #
-    # @param name [String, Symbol] Relation name.
-    # @return [Boolean] True if resource has relation, false otherwise.
-    #
-    def rel?(name)
-      relations.key? name
-    end
-    alias_method :relation?, :rel?
-    alias_method :has_rel?, :rel?
-    alias_method :has_relation?, :rel?
-
-    # Return relation with given name.
-    #
-    # @param name [String, Symbol] Relation name.
-    # @return [Relation] Relation.
-    #
-    def rel(name)
-      relations.fetch name
-    end
-    alias_method :relation, :rel
-  end
-end

data/spec/restify/collection_spec.rb

@@ -1,4 +0,0 @@
-require 'spec_helper'
-
-describe Restify::Collection do
-end