restful_resource 0.0.11 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb0baa3d62df8c2cf76abb026cf3f3d66f9cdd01
-  data.tar.gz: 0e623b12bc7f5ea6add379f80ece6eb88f91c2a0
+  metadata.gz: 5e4f4e6af3b1bee81026d51b88de88305d854791
+  data.tar.gz: ccc94c88defe5f2867214778ba49b27af23ea42f
 SHA512:
-  metadata.gz: e98a1b3a5b2d105c6cd520bd3c456b7cdeeef58c0993be275bfa6d90d9bad41ed701d17099268f0eb2a0787948bb1d32ff8bcf23658bd925ca5ffc91171546f8
-  data.tar.gz: cce5a8ea9f6a743e4e0c2f65954426d744ab03584fb26274dcb4c814124a0f518aa8c9f5005222769191683f35f60b669d8d2fb6273f6b384ce2e379fb39cbcc
+  metadata.gz: b276550299aa86e9574211dd018dd3e86a79c357d79ed05a6bdd1d9830b47e340e904a51ff80caa4c9dd8d32256217200146b183b367cc428e4edd5796f6ef88
+  data.tar.gz: 9c4eb7a4326eac86a7cc23e0c25fe1881ad9e6a968cd4da65f693d80efbc216abbb4c1284a0edccf6e1369f42672f6730fae25a7719ad770754d4b31d0c785d6

data/README.md

@@ -27,3 +27,14 @@ TODO: Write usage instructions here
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## Planned Features
+
+### Core
+  - Test that has_many and has_one pick correct class for children (if defined)
+  - Make base_url resilient when missing trailing slash
+  - Implement http authentication
+
+### Active record style validation
+
+### Constraints(mandatory fields)

data/lib/restful_resource/associations.rb

@@ -0,0 +1,23 @@
+module RestfulResource
+  module Associations
+    def has_many(nested_resource_type)
+      klass = nested_resource_type.to_s.singularize.camelize.safe_constantize
+      klass = OpenStruct if (klass.nil? || (klass.superclass != RestfulResource))
+
+      self.send(:define_method, nested_resource_type) do
+        @inner_object.send(nested_resource_type).map { |obj| klass.new(obj) }
+      end
+    end
+
+    def has_one(nested_resource_type)
+      klass = nested_resource_type.to_s.camelize.safe_constantize
+      klass = OpenStruct if (klass.nil? || klass.superclass != RestfulResource)
+
+      self.send(:define_method, nested_resource_type) do
+        nested_resource = @inner_object.send(nested_resource_type)
+        return nil if nested_resource.nil?
+        klass.new(@inner_object.send(nested_resource_type))
+      end
+    end
+  end
+end

data/lib/restful_resource/base.rb

@@ -1,158 +1,107 @@
 module RestfulResource
-  class Base
-    def self.url=(url)
-      @url = url
-    end
-
-    def self.processed_url_and_params(params={})
-      uri = URI(@url)
-      path = uri.path
-      other_params = params.clone
-      missing_params = []
+  class Base < OpenObject
+    extend RestfulResource::Associations
 
-      path_params = path.scan(/:([A-Za-z][^\/]*)/).flatten
-      path_params.each do |key|
-        value = other_params.delete(key.to_sym)
-        if value.nil?
-          missing_params << key
-        else
-          path = path.gsub(':'+key.to_s, value.to_s)
-        end
-      end
-
-      if missing_params.any?
-        raise ParameterMissingError.new(missing_params)
-      end
-      
-      uri.path = path
-      [uri.to_s, other_params]
-    end
-
-    def self.url(params={})
-      processed_url_and_params(params).first
-    end
-
-
-    def self.has_one(nested_resource_type)
-      klass = nested_resource_type.to_s.camelize.safe_constantize
-      klass = OpenStruct if (klass.nil? || klass.superclass != RestfulResource)
-
-      self.send(:define_method, nested_resource_type) do
-        nested_resource = @inner_object.send(nested_resource_type)
-        return nil if nested_resource.nil?
-        klass.new(@inner_object.send(nested_resource_type))
-      end
+    def self.http=(http)
+      @@http = http
     end
 
-    def self.has_many(nested_resource_type)
-      klass = nested_resource_type.to_s.singularize.camelize.safe_constantize
-      klass = OpenStruct if (klass.nil? || (klass.superclass != RestfulResource))
-
-      self.send(:define_method, nested_resource_type) do
-        @inner_object.send(nested_resource_type).map { |obj| klass.new(obj) }
-      end
+    def self.http
+      @@http ||= RestfulResource::HttpClient.new()
     end
 
-    def initialize(attributes = {}, hack_for_activeresource = false)
-      @inner_object = OpenStruct.new(attributes)
+    def self.base_url=(url)
+      @base_url = URI.parse(url)
     end
 
-    def method_missing(method)
-      if @inner_object.respond_to?(method)
-        @inner_object.send(method)
-      else
-        super(method)
-      end
+    def self.base_url
+      @base_url
     end
 
-    def respond_to?(method, include_private = false)
-      super || @inner_object.respond_to?(method, include_private)
+    def self.resource_path(url)
+      @resource_path = url
     end
 
-    def valid?
-      errors.nil? || errors.count == g
+    def self.find(id, params={})
+      response = http.get(member_url(id, params))
+      self.new(parse_json(response.body))
     end
 
-    def self.find(id, url_params={})
-      response = RestClient.get("#{url(url_params)}/#{id}", params: {})
-      self.new(ActiveSupport::JSON.decode(response))
+    def self.where(params={})
+      response = http.get(collection_url(params))
+      self.paginate_response(response)
     end
 
-    def self.get_one(url_params={})
-      resource = create_new_resource(url_params)
-      response = resource.get
-      self.new(ActiveSupport::JSON.decode(response))      
+    def self.get(params={})
+      response = http.get(collection_url(params))
+      RestfulResource::OpenObject.new(parse_json(response.body))
     end
 
-    def self.update_attributes(id, attributes)
-      begin
-        result = parse(RestClient.put("#{url}/#{id}", attributes))
-      rescue RestClient::UnprocessableEntity => e
-        errors = parse(e.response)
-        result = attributes.merge(errors: errors)
-      end
-      self.new(result)
+    def self.all
+      self.where
     end
 
-    def self.create(attributes)
-      begin
-        result = parse(RestClient.post("#{url}", attributes))
-      rescue RestClient::UnprocessableEntity => e
-        errors = parse(e.response)
-        result = attributes.merge(errors: errors)
-      end
-      self.new(result)
+    def self.action(action_name)
+      clone = self.clone
+      clone.action_prefix = action_name
+      clone
     end
 
-    def self.search(params = {})
-      response = RestClient.get("#{url}/search", params: params)
-      paginate_response(response)
+    def self.action_prefix=(action_prefix)
+      @action_prefix = action_prefix.to_s
     end
 
-    def self.all(params = {})
-      resource = create_new_resource(params)
-      response = resource.get
-      paginate_response(response)
+    def as_json(options=nil)
+      @inner_object.send(:table).as_json(options)
     end
 
-    def self.get(postfix_url = "", params = {})
-      response = RestClient.get("#{url}#{postfix_url}", params: params)
-      paginate_response(response)
+    private
+    def self.merge_url_paths(uri, *paths)
+      uri.merge(paths.compact.join('/')).to_s 
     end
 
-    def self.put(postfix_url = "", params = {})
-      response = RestClient.put("#{url}#{postfix_url}", params)
+    def self.member_url(id, params)
+      url = merge_url_paths(superclass.base_url, @resource_path, id, @action_prefix)
+      replace_parameters(url, params)
     end
 
-    def self.post(postfix_url = "", params = {})
-      response = RestClient.post("#{url}#{postfix_url}", params)
+    def self.collection_url(params)
+      url = merge_url_paths(superclass.base_url, @resource_path, @action_prefix)  
+      replace_parameters(url, params)
     end
 
-    def self.all_not_paginated
-      page = 1
-      results = []
-      while page
-        page_data = self.all(page: page);
-        results += page_data
-        page = page_data.next_page
+    def self.new_collection(json)
+      json.map do |element|
+        self.new(element)
       end
-
-      results
     end
 
-    def self.parse(json)
+    def self.parse_json(json)
       ActiveSupport::JSON.decode(json)
     end
 
-    def to_json(*args)
-      @inner_object.send(:table).to_json(*args)
-    end
+    def self.replace_parameters(url, params)
+      missing_params = []
+      params = params.with_indifferent_access
 
-    def as_json(*)
-      @inner_object.send(:table).as_json
+      url_params = url.scan(/:([A-Za-z][^\/]*)/).flatten
+      url_params.each do |key|
+        value = params.delete(key)
+        if value.nil?
+          missing_params << key
+        else
+          url = url.gsub(':'+key, value.to_s)
+        end
+      end
+
+      if missing_params.any?
+        raise ParameterMissingError.new(missing_params)
+      end
+
+      url = url + "?#{params.to_query}" unless params.empty?
+      url
     end
 
-    private
     def self.paginate_response(response)
       links_header =  response.headers[:links]
       links = LinkHeader.parse(links_header)
@@ -160,15 +109,8 @@ module RestfulResource
       prev_url = links.find_link(['rel', 'prev']).try(:href)
       next_url = links.find_link(['rel', 'next']).try(:href)
 
-      array = ActiveSupport::JSON.decode(response).map { |attributes| self.new(attributes) }
+      array = parse_json(response.body).map { |attributes| self.new(attributes) }
       PaginatedArray.new(array, previous_page_url: prev_url, next_page_url: next_url)
     end
-
-    def self.create_new_resource(params={})
-      url, other_params = processed_url_and_params(params)
-      url += "?#{other_params.to_query}" if not other_params.empty?
-      resource = RestClient::Resource.new("#{url}")
-    end
-
   end
 end

data/lib/restful_resource/http_client.rb

@@ -0,0 +1,8 @@
+module RestfulResource
+  class HttpClient
+    def get(url)
+      response = RestClient.get(url, :accept => :json)
+      Response.new(body: response.body, headers: response.headers)
+    end
+  end
+end

data/lib/restful_resource/old_base.rb

@@ -0,0 +1,172 @@
+module RestfulResource
+  class OldBase
+    def self.url=(url)
+      @url = url
+    end
+
+    def self.processed_url_and_params(params={})
+      url = @url
+      other_params = params.clone
+      missing_params = []
+
+      url_params = url.scan(/:([A-Za-z][^\/]*)/).flatten
+      url_params.each do |key|
+        value = other_params.delete(key.to_sym)
+        if value.nil?
+          missing_params << key
+        else
+          url = url.gsub(':'+key.to_s, value.to_s)
+        end
+      end
+
+      if missing_params.any?
+        raise ParameterMissingError.new(missing_params)
+      end
+
+      [url, other_params]
+    end
+
+    def self.url(params={})
+      processed_url_and_params(params).first
+    end
+
+
+    def self.has_one(nested_resource_type)
+      klass = nested_resource_type.to_s.camelize.safe_constantize
+      klass = OpenStruct if (klass.nil? || klass.superclass != RestfulResource)
+
+      self.send(:define_method, nested_resource_type) do
+        nested_resource = @inner_object.send(nested_resource_type)
+        return nil if nested_resource.nil?
+        klass.new(@inner_object.send(nested_resource_type))
+      end
+    end
+
+    def self.has_many(nested_resource_type)
+      klass = nested_resource_type.to_s.singularize.camelize.safe_constantize
+      klass = OpenStruct if (klass.nil? || (klass.superclass != RestfulResource))
+
+      self.send(:define_method, nested_resource_type) do
+        @inner_object.send(nested_resource_type).map { |obj| klass.new(obj) }
+      end
+    end
+
+    def initialize(attributes = {}, hack_for_activeresource = false)
+      @inner_object = OpenStruct.new(attributes)
+    end
+
+    def method_missing(method)
+      if @inner_object.respond_to?(method)
+        @inner_object.send(method)
+      else
+        super(method)
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || @inner_object.respond_to?(method, include_private)
+    end
+
+    def valid?
+      errors.nil? || errors.count == g
+    end
+
+    def self.find(id, url_params={})
+      response = RestClient.get("#{url(url_params)}/#{id}", params: {})
+      self.new(ActiveSupport::JSON.decode(response))
+    end
+
+    def self.get_one(url_params={})
+      resource = create_new_resource(url_params)
+      response = resource.get
+      self.new(ActiveSupport::JSON.decode(response))
+    end
+
+    def self.update_attributes(id, attributes)
+      begin
+        result = parse(RestClient.put("#{url}/#{id}", attributes))
+      rescue RestClient::UnprocessableEntity => e
+        errors = parse(e.response)
+        result = attributes.merge(errors: errors)
+      end
+      self.new(result)
+    end
+
+    def self.create(attributes)
+      begin
+        result = parse(RestClient.post("#{url}", attributes))
+      rescue RestClient::UnprocessableEntity => e
+        errors = parse(e.response)
+        result = attributes.merge(errors: errors)
+      end
+      self.new(result)
+    end
+
+    def self.search(params = {})
+      response = RestClient.get("#{url}/search", params: params)
+      paginate_response(response)
+    end
+
+    def self.all(params = {})
+      resource = create_new_resource(params)
+      response = resource.get
+      paginate_response(response)
+    end
+
+    def self.get(postfix_url = "", params = {})
+      response = RestClient.get("#{url}#{postfix_url}", params: params)
+      paginate_response(response)
+    end
+
+    def self.put(postfix_url = "", params = {})
+      response = RestClient.put("#{url}#{postfix_url}", params)
+    end
+
+    def self.post(postfix_url = "", params = {})
+      response = RestClient.post("#{url}#{postfix_url}", params)
+    end
+
+    def self.all_not_paginated
+      page = 1
+      results = []
+      while page
+        page_data = self.all(page: page);
+        results += page_data
+        page = page_data.next_page
+      end
+
+      results
+    end
+
+    def self.parse(json)
+      ActiveSupport::JSON.decode(json)
+    end
+
+    def to_json(*args)
+      @inner_object.send(:table).to_json(*args)
+    end
+
+    def as_json(*)
+      @inner_object.send(:table).as_json
+    end
+
+    private
+    def self.paginate_response(response)
+      links_header =  response.headers[:links]
+      links = LinkHeader.parse(links_header)
+
+      prev_url = links.find_link(['rel', 'prev']).try(:href)
+      next_url = links.find_link(['rel', 'next']).try(:href)
+
+      array = ActiveSupport::JSON.decode(response).map { |attributes| self.new(attributes) }
+      PaginatedArray.new(array, previous_page_url: prev_url, next_page_url: next_url)
+    end
+
+    def self.create_new_resource(params={})
+      url, other_params = processed_url_and_params(params)
+      url += "?#{other_params.to_query}" if not other_params.empty?
+      resource = RestClient::Resource.new("#{url}")
+    end
+
+  end
+end

data/lib/restful_resource/open_object.rb

@@ -0,0 +1,19 @@
+module RestfulResource
+  class OpenObject
+    def initialize(attributes = {}, hack_for_activeresource = false)
+      @inner_object = OpenStruct.new(attributes)
+    end
+
+    def method_missing(method)
+      if @inner_object.respond_to?(method)
+        @inner_object.send(method)
+      else
+        super(method)
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || @inner_object.respond_to?(method, include_private)
+    end
+  end
+end

data/lib/restful_resource/response.rb

@@ -0,0 +1,9 @@
+module RestfulResource
+  class Response
+    attr_reader :body, :headers
+
+    def initialize(body: "{}", headers: {})
+      @body, @headers = body, headers
+    end
+  end
+end

data/lib/restful_resource/version.rb

@@ -1,3 +1,3 @@
 module RestfulResource
-  VERSION = "0.0.11"
+  VERSION = "0.8.0"
 end

data/lib/restful_resource.rb

@@ -1,10 +1,16 @@
 require 'rack'
+require 'uri'
 require 'link_header'
 require 'restclient'
 require 'active_support'
 require 'active_support/all'
-require "restful_resource/version"
-require "restful_resource/paginated_array"
-require "restful_resource/parameter_missing_error"
-require "restful_resource/base"
+require_relative "restful_resource/version"
+require_relative "restful_resource/paginated_array"
+require_relative "restful_resource/parameter_missing_error"
+require_relative "restful_resource/open_object"
+require_relative 'restful_resource/response'
+require_relative 'restful_resource/http_client'
+require_relative "restful_resource/associations"
+require_relative "restful_resource/base"
+require_relative "restful_resource/old_base"
 

data/spec/fixtures.rb

@@ -0,0 +1,23 @@
+class Make < RestfulResource::Base
+  resource_path "makes"
+  has_many :models
+end
+
+class Model < RestfulResource::Base
+  has_one :make
+  resource_path "groups/:group_id/makes/:make_slug/models"
+end
+
+class BaseA < RestfulResource::Base
+end
+
+class BaseB < RestfulResource::Base
+end
+
+class TestA < BaseA
+  self.resource_path "testa"
+end
+
+class TestB < BaseB
+  self.resource_path "testb"
+end

data/spec/restful_resource/associations_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../spec_helper'
+
+describe RestfulResource::Associations do
+  describe "#has_many" do
+    it "should add a method to access nested resource" do
+      make = Make.new({
+        name: 'Volkswagen',
+        models:
+          [
+            {name: 'Golf', rrp: 1000},
+            {name: 'Passat', rrp: 3000}
+          ]
+      })
+
+      expect(make.models.first.name).to eq 'Golf'
+      expect(make.models.last.name).to eq 'Passat'
+      expect(make.models.first.rrp).to eq 1000
+      expect(make.models.last.rrp).to eq 3000
+    end
+  end
+
+  describe "#has_one" do
+    it "should add a method to access nested resource" do
+      model = Model.new({
+        name: 'Golf',
+        make: {name: 'Volkswagen'}
+      })
+
+      expect(model.make.name).to eq 'Volkswagen'
+    end
+  end
+end

data/spec/restful_resource/base_spec.rb

@@ -1,125 +1,148 @@
 require_relative '../spec_helper'
 
 describe RestfulResource::Base do
-  context "#find" do
-    it "should retrieve a resource with a simple url" do
-      response = { id: 15, name: 'Arsenal' }.to_json 
-      stub_get('http://api.carwow.co.uk/teams/15', response)
-      
-      team = Team.find(15)
-
-      expect(team.id).to eq 15
-      expect(team.name).to eq 'Arsenal'
-    end
+  before :each do
+    @mock_http = double("mock_http")
+    RestfulResource::Base.http = @mock_http
+    RestfulResource::Base.base_url = "http://api.carwow.co.uk/"
+  end
 
-    it "should retrieve a nested resource" do
-      response = { id: 1, team_id: 15, name: 'David', santoro: 'Santoro' }.to_json 
-      stub_get('http://api.carwow.co.uk/teams/15/players/1', response)
+  it "should act as an openobject" do
+    object = RestfulResource::Base.new(name: 'David', surname: 'Santoro')
 
-      player = Player.find(1, team_id: 15)
-      
-      expect(player.id).to eq 1
-      expect(player.team_id).to eq 15
-      expect(player.name).to eq 'David'
-    end
+    expect(object.name).to eq 'David'
+    expect(object.surname).to eq 'Santoro'
+    expect { object.age }.to raise_error(NoMethodError)
   end
 
-  context "#url" do
-    it "should return the url set if no extra parameters are necessary" do
-      Player.url = 'http://api.carwow.co.uk/players'
+  describe "#find" do
+    it "should return an object instance for the correct id" do
+      expected_response = RestfulResource::Response.new(body: {id: 12}.to_json)
+      expect_get("http://api.carwow.co.uk/makes/12", expected_response)
+
+      object = Make.find(12)
 
-      expect(Player.url).to eq 'http://api.carwow.co.uk/players'
+      expect(object).not_to be_nil
+      expect(object.id).to be 12
     end
 
-    it "should return the url with the right parameters replaced" do
-      Player.url = 'http://api.carwow.co.uk/teams/:team_id/players'
+    it "should return an object instance for nested routes" do
+      expected_response = RestfulResource::Response.new(body: {name: 'Golf', price: 15000}.to_json)
+      expect_get("http://api.carwow.co.uk/groups/15/makes/Volkswagen/models/Golf", expected_response)
 
-      expect(Player.url(team_id: 13)).to eq 'http://api.carwow.co.uk/teams/13/players'
+      object = Model.find('Golf', make_slug: 'Volkswagen', group_id: 15)
+
+      expect(object).not_to be_nil
+      expect(object.name).to eq 'Golf'
+      expect(object.price).to eq 15000
     end
+  end
 
-    it "should raise a parameter required exception if parameter needed and not provided" do
-      Player.url = 'http://api.carwow.co.uk/countries/:country_slug/teams/:team_id/players'
+  describe "#where" do
+    it "should return an array of objects" do
+      expected_response = RestfulResource::Response.new(body: [{name: 'Golf', price: 15000}, {name: 'Polo', price: 11000}].to_json)
+      expect_get("http://api.carwow.co.uk/groups/15/makes/Volkswagen/models?on_sale=true", expected_response)
+      object = Model.where(make_slug: 'Volkswagen', on_sale: true, group_id: 15)
 
-      expected_error_message = 'You must pass values for the following parameters: [country_slug, team_id]'
-      expect { Player.url }.to raise_error(RestfulResource::ParameterMissingError, expected_error_message)
+      expect(object).not_to be_nil
+      expect(object.length).to eq 2
+      expect(object.first.name).to eq 'Golf'
+      expect(object.first.price).to eq 15000
     end
 
-    it "should not confuse port number as a parameter" do
-      Player.url = 'http://api.carwow.co.uk:7000/teams/:team_id/players'
+    it "should provide a paginated result if response contains rest pagination headers" do
+      expected_response = response_with_page_information()
+      expect_get("http://api.carwow.co.uk/groups/15/makes/Volkswagen/models", expected_response)
+
+      models = Model.where(group_id: 15, make_slug: 'Volkswagen')
 
-      expect { Player.url(team_id: 13) }.not_to raise_error
+      expect(models.first.name).to eq 'Golf'
+      expect(models.last.name).to eq 'Polo'
+      expect(models.previous_page).to be_nil
+      expect(models.next_page).to eq 2
     end
+  end
 
-    it "should not substitue parameters in the http auth part of the url" do
-      Player.url = 'http://admin:secret@api.carwow.co.uk:7000/teams/:team_id/players'
+  describe "#all" do
+    it "should return all items" do
+      expected_response = RestfulResource::Response.new(body: [{name: 'Volkswagen'}, {name: 'Audi'}].to_json)
+      expect_get("http://api.carwow.co.uk/makes", expected_response)
+      makes = Make.all
 
-      expect { Player.url(team_id: 13) }.not_to raise_error
+      expect(makes).not_to be_nil
+      expect(makes.length).to eq 2
+      expect(makes.first.name).to eq 'Volkswagen'
     end
   end
 
-  context "#all" do
-    it "should provide a paginated result if response contains rest pagination headers" do
-      response = response_with_page_information()
-      stub_new_resource('http://api.carwow.co.uk/teams', response)
+  describe "#base_url" do
+    it "should be different for each subclass of Base" do
+      BaseA.base_url = "http://a.carwow.co.uk"
+      BaseB.base_url = "http://b.carwow.co.uk"
 
-      teams = Team.all
+      expect_get('http://a.carwow.co.uk/testa/1', RestfulResource::Response.new())
+      expect_get('http://b.carwow.co.uk/testb/2', RestfulResource::Response.new())
 
-      expect(teams.previous_page).to be_nil
-      expect(teams.next_page).to eq 2
-      expect(teams.first.name).to eq 'Arsenal'
-      expect(teams.last.name).to eq 'Chelsea'
+      TestA.find(1)
+      TestB.find(2)
     end
   end
 
-  it "should act as an openstruct" do
-    example = Player.new(name: 'David', surname: 'Santoro')
+  describe "#action" do
+    it "should retrieve a resource using a custom action" do
+      expect_get('http://api.carwow.co.uk/makes/15/lazy', RestfulResource::Response.new(body: {name: 'Volk.'}.to_json))
 
-    expect(example.name).to eq 'David'
-    expect(example.surname).to eq 'Santoro'
-  end
+      make = Make.action(:lazy).find(15)
 
-  it "should use some params for the url and other for the query string" do
-    stub_new_resource('http://api.carwow.co.uk/teams/15/players?name_like=Ars', response_with_page_information)
+      expect(make.name).to eq 'Volk.'
+    end
 
-    players = Player.all(team_id: 15, name_like: 'Ars')
-  end
+    it 'should retrieve many resources using a custom action' do
+      expect_get('http://api.carwow.co.uk/makes/available', RestfulResource::Response.new(body: [{name: 'Audi'}, {name: 'Fiat'}].to_json))
 
-  it "should raise an error when accessing a field that doesn't exist" do
-    player = Player.new({name: 'David', surname: 'Santoro'})
-    
-    expect { player.age }.to raise_error(NoMethodError)
-  end
+      make = Make.action(:available).all
 
-  private
-  def stub_new_resource(url, fake_response)
-    resource = instance_double('RestClient::Resource', get: fake_response)
-    allow(RestClient::Resource).to receive(:new).with(url).and_return resource
+      expect(make.first.name).to eq 'Audi'
+      expect(make.last.name).to eq 'Fiat'
+    end
   end
 
-  def stub_get(url, fake_response, params = {})
-    expect(RestClient).to receive(:get).
-                          with(url, params: params).
-                          and_return(fake_response)
-  end
+  describe "#get" do 
+    it "should return an open_object" do
+      expected_response = RestfulResource::Response.new(body: {average_score: 4.3}.to_json)
+      expect_get('http://api.carwow.co.uk/makes/average_score?make_slug%5B%5D=Volkswagen&make_slug%5B%5D=Audi', expected_response)
 
-  def response_with_page_information
-    response = [{ id: 1, name: 'Arsenal'}, { id: 2, name: 'Chelsea' }].to_json 
-    allow(response).to receive(:headers) { 
-      {:links => '<http://api.carwow.co.uk/teams.json?page=6>;rel="last",<http://api.carwow.co.uk/teams.json?page=2>;rel="next"'}
-    }
-    response
+      object = Make.action(:average_score).get(make_slug: ['Volkswagen', 'Audi'])
+
+      expect(object.average_score).to eq 4.3
+      expect(object.class).to eq RestfulResource::OpenObject
+    end
   end
-end
 
-class Team < RestfulResource::Base
-  self.url = "http://api.carwow.co.uk/teams"
-end
+  describe ".as_json" do
+    before :each do
+      expected_response = RestfulResource::Response.new(body: [{name: 'Audi', slug: 'Audi-Slug'}, {name: 'Fiat', slug: 'Fiat-Slug'}].to_json)
+      expect_get('http://api.carwow.co.uk/makes', expected_response)
 
-class Player < RestfulResource::Base
-  has_one :team
+      @makes = Make.all
+    end
 
-  self.url = "http://api.carwow.co.uk/teams/:team_id/players"
-end
+    it 'should not return inner object table' do
+      expect(@makes.first.as_json).to eq ({'name' => 'Audi', 'slug' => 'Audi-Slug'})
+    end
 
+    it 'should return inner object table on selected fields' do
+      expect(@makes.last.as_json(only: [:name])).to eq ({'name' => 'Fiat'})
+    end
+  end
+
+  def expect_get(url, response)
+    expect(@mock_http).to receive(:get).with(url).and_return(response)
+  end
 
+  def response_with_page_information
+    RestfulResource::Response.new(body: [{ id: 1, name: 'Golf'}, { id: 2, name: 'Polo' }].to_json,
+                                 headers: { links: '<http://api.carwow.co.uk/makes/Volkswagen/models.json?page=6>;rel="last",<http://api.carwow.co.uk/makes/Volkswagen/models.json?page=2>;rel="next"'})
+  end
+end
 

data/spec/restful_resource/old_base_spec.rb

@@ -0,0 +1,119 @@
+require_relative '../spec_helper'
+
+describe RestfulResource::OldBase do
+  context "#find" do
+    it "should retrieve a resource with a simple url" do
+      response = { id: 15, name: 'Arsenal' }.to_json
+      stub_get('http://api.carwow.co.uk/teams/15', response)
+
+      team = Team.find(15)
+
+      expect(team.id).to eq 15
+      expect(team.name).to eq 'Arsenal'
+    end
+
+    it "should retrieve a nested resource" do
+      response = { id: 1, team_id: 15, name: 'David', santoro: 'Santoro' }.to_json
+      stub_get('http://api.carwow.co.uk/teams/15/players/1', response)
+
+      player = Player.find(1, team_id: 15)
+
+      expect(player.id).to eq 1
+      expect(player.team_id).to eq 15
+      expect(player.name).to eq 'David'
+    end
+  end
+
+  context "#url" do
+    it "should return the url set if no extra parameters are necessary" do
+      Player.url = 'http://api.carwow.co.uk/players'
+
+      expect(Player.url).to eq 'http://api.carwow.co.uk/players'
+    end
+
+    it "should return the url with the right parameters replaced" do
+      Player.url = 'http://api.carwow.co.uk/teams/:team_id/players'
+
+      expect(Player.url(team_id: 13)).to eq 'http://api.carwow.co.uk/teams/13/players'
+    end
+
+    it "should raise a parameter required exception if parameter needed and not provided" do
+      Player.url = 'http://api.carwow.co.uk/countries/:country_slug/teams/:team_id/players'
+
+      expected_error_message = 'You must pass values for the following parameters: [country_slug, team_id]'
+      expect { Player.url }.to raise_error(RestfulResource::ParameterMissingError, expected_error_message)
+    end
+
+    it "should not confuse port number as a parameter" do
+      Player.url = 'http://api.carwow.co.uk:7000/teams/:team_id/players'
+
+      expect { Player.url(team_id: 13) }.not_to raise_error
+    end
+  end
+
+  context "#all" do
+    it "should provide a paginated result if response contains rest pagination headers" do
+      response = response_with_page_information()
+      stub_new_resource('http://api.carwow.co.uk/teams', response)
+
+      teams = Team.all
+
+      expect(teams.previous_page).to be_nil
+      expect(teams.next_page).to eq 2
+      expect(teams.first.name).to eq 'Arsenal'
+      expect(teams.last.name).to eq 'Chelsea'
+    end
+  end
+
+  it "should act as an openstruct" do
+    example = Player.new(name: 'David', surname: 'Santoro')
+
+    expect(example.name).to eq 'David'
+    expect(example.surname).to eq 'Santoro'
+  end
+
+  it "should use some params for the url and other for the query string" do
+    stub_new_resource('http://api.carwow.co.uk/teams/15/players?name_like=Ars', response_with_page_information)
+
+    players = Player.all(team_id: 15, name_like: 'Ars')
+  end
+
+  it "should raise an error when accessing a field that doesn't exist" do
+    player = Player.new({name: 'David', surname: 'Santoro'})
+
+    expect { player.age }.to raise_error(NoMethodError)
+  end
+
+  private
+  def stub_new_resource(url, fake_response)
+    resource = instance_double('RestClient::Resource', get: fake_response)
+    allow(RestClient::Resource).to receive(:new).with(url).and_return resource
+  end
+
+  def stub_get(url, fake_response, params = {})
+    expect(RestClient).to receive(:get).
+                          with(url, params: params).
+                          and_return(fake_response)
+  end
+
+  def response_with_page_information
+    response = [{ id: 1, name: 'Arsenal'}, { id: 2, name: 'Chelsea' }].to_json
+    allow(response).to receive(:headers) {
+      {:links => '<http://api.carwow.co.uk/teams.json?page=6>;rel="last",<http://api.carwow.co.uk/teams.json?page=2>;rel="next"'}
+    }
+    response
+  end
+end
+
+class Team < RestfulResource::OldBase
+  self.url = "http://api.carwow.co.uk/teams"
+end
+
+class Player < RestfulResource::OldBase
+  has_one :team
+
+  self.url = "http://api.carwow.co.uk/teams/:team_id/players"
+end
+
+
+

data/spec/restful_resource/open_object_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../spec_helper'
+
+describe RestfulResource::OpenObject do
+  it "should act as an openstruct" do
+    object = RestfulResource::OpenObject.new(name: 'David', surname: 'Santoro')
+
+    expect(object.name).to eq 'David'
+    expect(object.surname).to eq 'Santoro'
+  end
+
+  it "should raise an error when accessing a field that doesn't exist" do
+    object = RestfulResource::OpenObject.new({name: 'David', surname: 'Santoro'})
+
+    expect { object.age }.to raise_error(NoMethodError)
+  end
+end

data/spec/restful_resource/rest_client_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../spec_helper'
+
+describe RestfulResource::Base do
+  context "#get" do
+    it "should throw an exception with wrong url" do
+      expect{RestClient.get("http://www.example.com/djksafjadl", params: {})}.to raise_error
+    end
+
+    it "should throw an exception with wrong url" do
+      r = RestClient::Resource.new("http://www.example.com/djksafjadl")
+      expect{r.get}.to raise_error
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rspec'
 require_relative '../lib/restful_resource'
+require_relative 'fixtures'
 
 RSpec.configure do |config|
   config.color = true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restful_resource
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.8.0
 platform: ruby
 authors:
 - David Santoro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-16 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,12 +122,22 @@ files:
 - README.md
 - Rakefile
 - lib/restful_resource.rb
+- lib/restful_resource/associations.rb
 - lib/restful_resource/base.rb
+- lib/restful_resource/http_client.rb
+- lib/restful_resource/old_base.rb
+- lib/restful_resource/open_object.rb
 - lib/restful_resource/paginated_array.rb
 - lib/restful_resource/parameter_missing_error.rb
+- lib/restful_resource/response.rb
 - lib/restful_resource/version.rb
 - restful_resource.gemspec
+- spec/fixtures.rb
+- spec/restful_resource/associations_spec.rb
 - spec/restful_resource/base_spec.rb
+- spec/restful_resource/old_base_spec.rb
+- spec/restful_resource/open_object_spec.rb
+- spec/restful_resource/rest_client_spec.rb
 - spec/spec_helper.rb
 homepage: http://www.github.com/carwow/restful_resource
 licenses:
@@ -155,5 +165,10 @@ specification_version: 4
 summary: A simple activerecord inspired rest resource base class implemented using
   rest-client
 test_files:
+- spec/fixtures.rb
+- spec/restful_resource/associations_spec.rb
 - spec/restful_resource/base_spec.rb
+- spec/restful_resource/old_base_spec.rb
+- spec/restful_resource/open_object_spec.rb
+- spec/restful_resource/rest_client_spec.rb
 - spec/spec_helper.rb