her 0.6 → 0.6.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWYxMjI2MTQ0YjdhOTYyNDA1YTkwZjU4MTNhMDFjZDQ1OTM0OTczMQ==
+    N2RhYjBkODQ3ZjE1NmNlM2VmZTExNWJkNDU3NTI4YjI3OGNhN2RiZQ==
   data.tar.gz: !binary |-
-    ZDk0YzAxYjUzYTlmMGU4Y2FkMGQ0NGQ2MDM0YjM2MjBlZmRmMGVhZg==
+    OTBmNmRjM2I2NDE3ZmQ4MjZmZDJjMzI5NjQ2ODJjODUwMDczNWRiNw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZDE1MWExN2JkZDY5OGYwNWFkMGZhYTVhZDE1MzEzYjMxYjc3YTU3NDc0MDQ4
-    OWMyOTEwMzY3ZTE4OGIxMTNiODlhZDExZGNjMzVlMjYzMWY1ZWNmZGVlM2Qz
-    Yjk2ZWRkZDkxMGU0MmJlMmU2ZjU0ZGI3ODA3ZWU2NDUzNTcxZWQ=
+    YzZhZjExMWI1MmYwYTUwODU4OGM0OWM2OWI2NDgyOGU5OTM0ZWViY2UzYjdh
+    NTZmNTI1YmFhMDlmMzQ5YTBmZWQzMWZhZjRlOWUwMzcxZTY0NWQ5YWQ2ODk3
+    ZjA0M2ExMmMyM2UxNjMwYzJjOWNjNmVjYzY4MDJkZmM3NjM2NzY=
   data.tar.gz: !binary |-
-    OTcxYzViZjM1MDVkMDJjODhlZTlkN2M3MTliYzRmZDE1NzQ4NDMzMDgzYzhk
-    NjNhMGIwMjUxNzFiMzA4Mjg2NmE3OTQzNWRhNWNiMDIyM2Q4MzVlMDk3OWM3
-    OTAwNTBlNWYxMmY1MWUwMTlkOWFlYTZkY2E1NDA3NGFkNDdjZjk=
+    ZDM4NWJjMzllNDdhZTc1NGI2NWVmMjlhYTAyYzgzYTIxOTkzNDgwNGEzZDVi
+    ZmI0OWRmYjdhNjVkNWMwNzVhYjIyYjg2YTM0ZjczMGY5OTBkNDU3Nzg4ZWVk
+    OWYwY2Y0NDk0Zjc1MDlkM2M1ZDJlNzkzZTA4NGMxNTI2M2FlODI=

data/README.md

@@ -624,7 +624,12 @@ user.save # PUT /users/4fd89a42ff204b03a905c535
 
 ### Inheritance
 
-If all your models share the same settings, you might want to make them children of a class and only include `Her::Model` in that class.
+If all your models share the same settings, you might want to make them children of a class and only include `Her::Model` in that class. However, there are a few settings that don’t get passed to the children classes:
+
+* `root_element`
+* `collection_path` and `resource_path`
+
+Those settings are based on the class name, so you don’t have to redefine them each time you create a new children class (but you still can). Every other setting is inherited from the parent (associations, scopes, JSON settings, etc.).
 
 ```ruby
 module MyAPI
@@ -643,6 +648,29 @@ User.find(1)
 # GET /users/1
 ```
 
+### Scopes
+
+Just like with ActiveRecord, you can define named scopes for your models. Scopes are chainable and can be used within other scopes.
+
+```ruby
+class User
+  include Her::Model
+
+  scope :by_role, lambda { |role| where(:role => role) }
+  scope :admins, lambda { by_role('admin') }
+  scope :active, lambda { where(:active => 1) }
+end
+
+@admins = User.admins
+# GET /users?role=admin
+
+@moderators = User.by_role('moderator')
+# GET /users?role=moderator
+
+@active_admins = User.active.admins # @admins.active would have worked here too
+# GET /users?role=admin&active=1
+```
+
 ### Multiple APIs
 
 It is possible to use different APIs for different models. Instead of calling `Her::API.setup`, you can create instances of `Her::API`:

data/lib/her/model/associations/belongs_to_association.rb

@@ -2,6 +2,27 @@ module Her
   module Model
     module Associations
       class BelongsToAssociation < Association
+        # @private
+        def self.attach(klass, name, attrs)
+          attrs = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :data_key => name,
+            :foreign_key => "#{name}_id",
+            :path => "/#{name.to_s.pluralize}/:id"
+          }.merge(attrs)
+          klass.associations[:belongs_to] << attrs
+
+          klass.instance_eval do
+            define_method(name) do
+              cached_name = :"@_her_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::BelongsToAssociation.new(self, attrs))
+            end
+          end
+        end
+
         def build(attributes = {})
           @klass.new(attributes)
         end
@@ -12,6 +33,7 @@ module Her
           resource
         end
 
+        # @private
         def fetch
           foreign_key_value = @parent.attributes[@opts[:foreign_key].to_sym]
           return nil if (@parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @query_attrs.empty?) || foreign_key_value.blank?

data/lib/her/model/associations/has_many_association.rb

@@ -2,6 +2,27 @@ module Her
   module Model
     module Associations
       class HasManyAssociation < Association
+        # @private
+        def self.attach(klass, name, attrs)
+          attrs = {
+            :class_name     => name.to_s.classify,
+            :name           => name,
+            :data_key       => name,
+            :path           => "/#{name}",
+            :inverse_of => nil
+          }.merge(attrs)
+          klass.associations[:has_many] << attrs
+
+          klass.instance_eval do
+            define_method(name) do
+              cached_name = :"@_her_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasManyAssociation.new(self, attrs))
+            end
+          end
+        end
+
         def build(attributes = {})
           @klass.new(attributes.merge(:"#{@parent.singularized_resource_name}_id" => @parent.id))
         end
@@ -17,6 +38,7 @@ module Her
           resource
         end
 
+        # @private
         def fetch
           return Her::Collection.new if @parent.attributes.include?(@name) && @parent.attributes[@name].empty? && @query_attrs.empty?
 

data/lib/her/model/associations/has_one_association.rb

@@ -2,6 +2,26 @@ module Her
   module Model
     module Associations
       class HasOneAssociation < Association
+        # @private
+        def self.attach(klass, name, attrs)
+          attrs = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :data_key => name,
+            :path => "/#{name}"
+          }.merge(attrs)
+          klass.associations[:has_one] << attrs
+
+          klass.instance_eval do
+            define_method(name) do
+              cached_name = :"@_her_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasOneAssociation.new(self, attrs))
+            end
+          end
+        end
+
         def build(attributes = {})
           @klass.new(attributes.merge(:"#{@parent.singularized_resource_name}_id" => @parent.id))
         end
@@ -12,6 +32,7 @@ module Her
           resource
         end
 
+        # @private
         def fetch
           return nil if @parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @query_attrs.empty?
 

data/lib/her/model/associations.rb

@@ -29,11 +29,7 @@ module Her
         # @private
         def associations
           @_her_associations ||= begin
-            if superclass.respond_to?(:associations)
-              superclass.associations.dup
-            else
-              {}
-            end
+            superclass.respond_to?(:associations) ? superclass.associations.dup : Hash.new { |h,k| h[k] = [] }
           end
         end
         alias :relationships :associations
@@ -82,21 +78,7 @@ module Her
         #   @user.articles # => [#<Article(articles/2) id=2 title="Hello world.">]
         #   # Fetched via GET "/users/1/articles"
         def has_many(name, attrs={})
-          attrs = {
-            :class_name     => name.to_s.classify,
-            :name           => name,
-            :data_key       => name,
-            :path           => "/#{name}",
-            :inverse_of => nil
-          }.merge(attrs)
-          (associations[:has_many] ||= []) << attrs
-
-          define_method(name) do
-            cached_name = :"@_her_association_#{name}"
-
-            cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
-            cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasManyAssociation.new(self, attrs))
-          end
+          Her::Model::Associations::HasManyAssociation.attach(self, name, attrs)
         end
 
         # Define an *has_one* association.
@@ -118,20 +100,7 @@ module Her
         #   @user.organization # => #<Organization(organizations/2) id=2 name="Foobar Inc.">
         #   # Fetched via GET "/users/1/organization"
         def has_one(name, attrs={})
-          attrs = {
-            :class_name => name.to_s.classify,
-            :name => name,
-            :data_key => name,
-            :path => "/#{name}"
-          }.merge(attrs)
-          (associations[:has_one] ||= []) << attrs
-
-          define_method(name) do
-            cached_name = :"@_her_association_#{name}"
-
-            cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
-            cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasOneAssociation.new(self, attrs))
-          end
+          Her::Model::Associations::HasOneAssociation.attach(self, name, attrs)
         end
 
         # Define a *belongs_to* association.
@@ -153,21 +122,7 @@ module Her
         #   @user.team # => #<Team(teams/2) id=2 name="Developers">
         #   # Fetched via GET "/teams/2"
         def belongs_to(name, attrs={})
-          attrs = {
-            :class_name => name.to_s.classify,
-            :name => name,
-            :data_key => name,
-            :foreign_key => "#{name}_id",
-            :path => "/#{name.to_s.pluralize}/:id"
-          }.merge(attrs)
-          (associations[:belongs_to] ||= []) << attrs
-
-          define_method(name) do
-            cached_name = :"@_her_association_#{name}"
-
-            cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
-            cached_data || instance_variable_set(cached_name, Her::Model::Associations::BelongsToAssociation.new(self, attrs))
-          end
+          Her::Model::Associations::BelongsToAssociation.attach(self, name, attrs)
         end
       end
     end

data/lib/her/model/http.rb

@@ -3,6 +3,7 @@ module Her
     # This module interacts with Her::API to fetch HTTP data
     module HTTP
       extend ActiveSupport::Concern
+      METHODS = [:get, :post, :put, :patch, :delete]
 
       module ClassMethods
         # Change which API the model will use to make its HTTP requests
@@ -36,7 +37,7 @@ module Her
         # - <method>_collection(path, attrs, &block)
         # - <method>_resource(path, attrs, &block)
         # - custom_<method>(path, attrs)
-        [:get, :post, :put, :patch, :delete].each do |method|
+        METHODS.each do |method|
           define_method method do |path, attrs={}|
             path = build_request_path_from_string_or_symbol(path, attrs)
             send(:"#{method}_raw", path, attrs) do |parsed_data, response|

data/lib/her/model/orm.rb

@@ -109,10 +109,23 @@ module Her
           end
         end
 
-        # Delegate the following methods to `scoped`
-        [:all, :where, :create, :page, :per_page].each do |method|
-          define_method method do |*attrs|
-            scoped.send(method, attrs.first)
+        # Create a new chainable scope
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #
+        #     scope :admins, lambda { where(:admin => 1) }
+        #     scope :page, lambda { |page| where(:page => page) }
+        #   enc
+        #
+        #   User.admins # Called via GET "/users?admin=1"
+        #   User.page(2).all # Called via GET "/users?page=2"
+        def scope(name, code)
+          define_singleton_method(name) { |*args| instance_exec(*args, &code) }
+
+          Relation.instance_eval do
+            define_method(name) { |*args| instance_exec(*args, &code) }
           end
         end
 
@@ -121,6 +134,11 @@ module Her
           Relation.new(self)
         end
 
+        # Delegate the following methods to `scoped`
+        [:all, :where, :create].each do |method|
+          define_method(method) { |*attrs| scoped.send(method, attrs.first) }
+        end
+
         # Save an existing resource and return it
         #
         # @example

data/lib/her/model/relation.rb

@@ -17,18 +17,12 @@ module Her
       # Add a query string parameter
       def where(attrs = {})
         return self if attrs.blank?
-        self.clone.tap { |a| a.query_attrs = a.query_attrs.merge(attrs) }
-      end
-      alias :all :where
-
-      def page(page)
-        where(:page => page)
-      end
-
-      def per_page(per_page)
-        where(:per_page => per_page)
+        self.clone.tap do |r|
+          r.query_attrs = r.query_attrs.merge(attrs)
+          r.clear_fetch_cache!
+        end
       end
-      alias :per :per_page
+      alias all where
 
       # Bubble all methods to the fetched collection
       def method_missing(method, *args, &blk)
@@ -108,6 +102,10 @@ module Her
       def first_or_initialize(attrs = {})
         fetch.first || build(attrs)
       end
+
+      def clear_fetch_cache!
+        instance_variable_set(:@_fetch, nil)
+      end
     end
   end
 end

data/lib/her/model.rb

@@ -50,7 +50,7 @@ module Her
       # Define the default primary key
       primary_key :id
 
-      # Define default storage variables for errors and metadata
+      # Define default storage accessors for errors and metadata
       store_response_errors :response_errors
       store_metadata :metadata
 

data/lib/her/version.rb

@@ -1,3 +1,3 @@
 module Her
-  VERSION = "0.6"
+  VERSION = "0.6.1"
 end

data/spec/model/associations_spec.rb

@@ -3,71 +3,80 @@ require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
 describe Her::Model::Associations do
   context "setting associations without details" do
-    before do
-      spawn_model "Foo::User"
-    end
+    before { spawn_model "Foo::User" }
+    subject { Foo::User.associations }
 
-    it "handles a single 'has_many' association" do
-      Foo::User.has_many :comments
-      Foo::User.associations[:has_many].should == [{ :name => :comments, :data_key => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }]
+    context "single has_many association" do
+      before { Foo::User.has_many :comments }
+      its([:has_many]) { should eql [{ :name => :comments, :data_key => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }] }
     end
 
-    it "handles multiples 'has_many' association" do
-      Foo::User.has_many :comments
-      Foo::User.has_many :posts
-      Foo::User.associations[:has_many].should == [{ :name => :comments, :data_key => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }, { :name => :posts, :data_key => :posts, :class_name => "Post", :path => "/posts", :inverse_of => nil }]
+    context "multiple has_many associations" do
+      before do
+        Foo::User.has_many :comments
+        Foo::User.has_many :posts
+      end
+
+      its([:has_many]) { should eql [{ :name => :comments, :data_key => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }, { :name => :posts, :data_key => :posts, :class_name => "Post", :path => "/posts", :inverse_of => nil }] }
     end
 
-    it "handles a single 'has_one' association" do
-      Foo::User.has_one :category
-      Foo::User.associations[:has_one].should == [{ :name => :category, :data_key => :category, :class_name => "Category", :path => "/category" }]
+    context "single has_one association" do
+      before { Foo::User.has_one :category }
+      its([:has_one]) { should eql [{ :name => :category, :data_key => :category, :class_name => "Category", :path => "/category" }] }
     end
 
-    it "handles multiples 'has_one' association" do
-      Foo::User.has_one :category
-      Foo::User.has_one :role
-      Foo::User.associations[:has_one].should == [{ :name => :category, :data_key => :category, :class_name => "Category", :path => "/category" }, { :name => :role, :data_key => :role, :class_name => "Role", :path => "/role" }]
+    context "multiple has_one associations" do
+      before do
+        Foo::User.has_one :category
+        Foo::User.has_one :role
+      end
+
+      its([:has_one]) { should eql [{ :name => :category, :data_key => :category, :class_name => "Category", :path => "/category" }, { :name => :role, :data_key => :role, :class_name => "Role", :path => "/role" }] }
     end
 
-    it "handles a single belongs_to association" do
-      Foo::User.belongs_to :organization
-      Foo::User.associations[:belongs_to].should == [{ :name => :organization, :data_key => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }]
+    context "single belongs_to association" do
+      before { Foo::User.belongs_to :organization }
+      its([:belongs_to]) { should eql [{ :name => :organization, :data_key => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }] }
     end
 
-    it "handles multiples 'belongs_to' association" do
-      Foo::User.belongs_to :organization
-      Foo::User.belongs_to :family
-      Foo::User.associations[:belongs_to].should == [{ :name => :organization, :data_key => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }, { :name => :family, :data_key => :family, :class_name => "Family", :foreign_key => "family_id", :path => "/families/:id" }]
+    context "multiple belongs_to association" do
+      before do
+        Foo::User.belongs_to :organization
+        Foo::User.belongs_to :family
+      end
+
+      its([:belongs_to]) { should eql [{ :name => :organization, :data_key => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }, { :name => :family, :data_key => :family, :class_name => "Family", :foreign_key => "family_id", :path => "/families/:id" }] }
     end
   end
 
   context "setting associations with details" do
-    before do
-      spawn_model "Foo::User"
-    end
+    before { spawn_model "Foo::User" }
+    subject { Foo::User.associations }
 
-    it "handles a single 'has_many' association" do
-      Foo::User.has_many :comments, :class_name => "Post", :inverse_of => :admin, :data_key => :user_comments
-      Foo::User.associations[:has_many].should == [{ :name => :comments, :data_key => :user_comments, :class_name => "Post", :path => "/comments", :inverse_of => :admin }]
-    end
+    context "in base class" do
+      context "single has_many association" do
+        before { Foo::User.has_many :comments, :class_name => "Post", :inverse_of => :admin, :data_key => :user_comments }
+        its([:has_many]) { should eql [{ :name => :comments, :data_key => :user_comments, :class_name => "Post", :path => "/comments", :inverse_of => :admin }] }
+      end
 
-    it "handles a single 'has_one' association" do
-      Foo::User.has_one :category, :class_name => "Topic", :foreign_key => "topic_id", :data_key => :topic
-      Foo::User.associations[:has_one].should == [{ :name => :category, :data_key => :topic, :class_name => "Topic", :foreign_key => "topic_id", :path => "/category" }]
-    end
+      context "signle has_one association" do
+        before { Foo::User.has_one :category, :class_name => "Topic", :foreign_key => "topic_id", :data_key => :topic }
+        its([:has_one]) { should eql [{ :name => :category, :data_key => :topic, :class_name => "Topic", :foreign_key => "topic_id", :path => "/category" }] }
+      end
 
-    it "handles a single belongs_to association" do
-      Foo::User.belongs_to :organization, :class_name => "Business", :foreign_key => "org_id", :data_key => :org
-      Foo::User.associations[:belongs_to].should == [{ :name => :organization, :data_key => :org, :class_name => "Business", :foreign_key => "org_id", :path => "/organizations/:id" }]
+      context "single belongs_to association" do
+        before { Foo::User.belongs_to :organization, :class_name => "Business", :foreign_key => "org_id", :data_key => :org }
+        its([:belongs_to]) { should eql [{ :name => :organization, :data_key => :org, :class_name => "Business", :foreign_key => "org_id", :path => "/organizations/:id" }] }
+      end
     end
 
-    context "inheriting associations from a superclass" do
-      it "copies associations to the subclass" do
-        Foo::User.has_many :comments, :class_name => "Post"
-        subclass = Class.new(Foo::User)
-        subclass.associations.object_id.should_not == Foo::User.associations.object_id
-        subclass.associations[:has_many].length.should == 1
-        subclass.associations[:has_many].first[:class_name].should == "Post"
+    context "in parent class" do
+      before { Foo::User.has_many :comments, :class_name => "Post" }
+
+      describe "associations accessor" do
+        subject { Class.new(Foo::User).associations }
+        its(:object_id) { should_not eql Foo::User.associations.object_id }
+      its([:has_many]) { should eql [{ :name => :comments, :data_key => :comments, :class_name => "Post", :path => "/comments", :inverse_of => nil }] }
       end
     end
   end

data/spec/model/orm_spec.rb

@@ -205,16 +205,6 @@ describe Her::Model::ORM do
       @users.where(:age => 42).should be_all { |u| u.age == 42 }
       @users.where(:age => 40).should be_all { |u| u.age == 40 }
     end
-
-    it "handles finding with paging parameters" do
-      @users = User.page(2).per_page(20)
-      @users.query_attrs[:page].should == 2
-      @users.query_attrs[:per_page].should == 20
-
-      @users = User.all.page(2).per_page(20)
-      @users.query_attrs[:page].should == 2
-      @users.query_attrs[:per_page].should == 20
-    end
   end
 
   context "creating resources" do

data/spec/model/relation_spec.rb

@@ -3,27 +3,58 @@ require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
 describe Her::Model::Relation do
   describe :where do
-    before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.adapter :test do |stub|
-          stub.get("/users") { |env| ok! [{ :id => 1, :fullname => "Tobias Fünke" }, { :id => 2, :fullname => "Lindsay Fünke" }] }
-          stub.get("/users?admin=1") { |env| ok! [{ :id => 1, :fullname => "Tobias Fünke" }] }
+    context "for base classes" do
+      before do
+        Her::API.setup :url => "https://api.example.com" do |builder|
+          builder.use Her::Middleware::FirstLevelParseJSON
+          builder.adapter :test do |stub|
+            stub.get("/users?foo=1&bar=2") { |env| ok! [{ :id => 2, :fullname => "Tobias Fünke" }] }
+            stub.get("/users?admin=1") { |env| ok! [{ :id => 1, :fullname => "Tobias Fünke" }] }
+            stub.get("/users") { |env| ok! [{ :id => 1, :fullname => "Tobias Fünke" }, { :id => 2, :fullname => "Lindsay Fünke" }] }
+          end
         end
+
+        spawn_model "Foo::User"
       end
 
-      spawn_model "Foo::User"
-    end
+      it "doesn't fetch the data immediatly" do
+        Her::Model::Relation.any_instance.should_receive(:fetch).never
+        @users = Foo::User.where(:admin => 1)
+      end
+
+      it "fetches the data and passes query parameters" do
+        Her::Model::Relation.any_instance.should_receive(:fetch).once.and_call_original
+        @users = Foo::User.where(:admin => 1)
+        @users.length.should == 1
+      end
 
-    it "doesn't fetch the data immediatly" do
-      Her::Model::Relation.any_instance.should_receive(:fetch).never
-      @users = Foo::User.where(:admin => 1)
+      it "chains multiple where statements" do
+        @user = Foo::User.where(:foo => 1).where(:bar => 2).first
+        @user.id.should == 2
+      end
     end
 
-    it "fetches the data and passes query parameters" do
-      Her::Model::Relation.any_instance.should_receive(:fetch).once.and_call_original
-      @users = Foo::User.where(:admin => 1)
-      @users.length.should == 2
+    context "for parent class" do
+      before do
+        Her::API.setup :url => "https://api.example.com" do |builder|
+          builder.use Her::Middleware::FirstLevelParseJSON
+          builder.adapter :test do |stub|
+            stub.get("/users?page=2") { |env| ok! [{ :id => 1, :fullname => "Tobias Fünke" }, { :id => 2, :fullname => "Lindsay Fünke" }] }
+          end
+        end
+
+        spawn_model("Foo::Model") do
+          scope :page, lambda { |page| where(:page => page) }
+        end
+
+        class User < Foo::Model; end
+        @spawned_models << :User
+      end
+
+      it "propagates the scopes through its children" do
+        @users = User.page(2)
+        @users.length.should == 2
+      end
     end
   end
 
@@ -59,31 +90,47 @@ describe Her::Model::Relation do
     end
   end
 
-  describe "#page and #per_page" do
+  describe :build do
+    before { spawn_model "Foo::User" }
+
+    it "handles new resource with build" do
+      @new_user = Foo::User.where(:fullname => "Tobias Fünke").build
+      @new_user.new?.should be_true
+      @new_user.fullname.should == "Tobias Fünke"
+    end
+  end
+
+  describe :scope do
     before do
       Her::API.setup :url => "https://api.example.com" do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON
         builder.adapter :test do |stub|
-          stub.get("/users?page=2&per_page=1") { |env| ok! [{ :id => 2, :fullname => "Lindsay Fünke" }] }
+          stub.get("/users?what=4&where=3") { |env| ok! [{ :id => 3, :fullname => "Maeby Fünke" }] }
+          stub.get("/users?what=2") { |env| ok! [{ :id => 2, :fullname => "Lindsay Fünke" }] }
+          stub.get("/users?where=6") { |env| ok! [{ :id => 4, :fullname => "Tobias Fünke" }] }
         end
       end
 
-      spawn_model "Foo::User"
+      spawn_model 'Foo::User' do
+        scope :foo, lambda { |v| where(:what => v) }
+        scope :bar, lambda { |v| where(:where => v) }
+        scope :baz, lambda { bar(6) }
+      end
     end
 
-    it "passes the pagination parameters" do
-      @user = Foo::User.page(2).per_page(1).first
+    it "passes query parameters" do
+      @user = Foo::User.foo(2).first
       @user.id.should == 2
     end
-  end
 
-  describe :build do
-    before { spawn_model "Foo::User" }
+    it "passes multiple query parameters" do
+      @user = Foo::User.foo(4).bar(3).first
+      @user.id.should == 3
+    end
 
-    it "handles new resource with build" do
-      @new_user = Foo::User.where(:fullname => "Tobias Fünke").build
-      @new_user.new?.should be_true
-      @new_user.fullname.should == "Tobias Fünke"
+    it "handles embedded scopes" do
+      @user = Foo::User.baz.first
+      @user.id.should == 4
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: her
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: 0.6.1
 platform: ruby
 authors:
 - Rémi Prévost
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-20 00:00:00.000000000 Z
+date: 2013-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake