remote_association 0.0.2 → 0.0.3

data/.gitignore

@@ -1,3 +1,4 @@
 *swp
 spec/config/database.yml
 pkg/*
+.idea/

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    remote_association (0.0.2)
+    remote_association (0.0.3)
       activerecord (~> 3.2)
       activeresource (~> 3.2)
       activesupport (~> 3.2)
@@ -24,22 +24,22 @@ GEM
       i18n (~> 0.6)
       multi_json (~> 1.0)
     arel (3.0.2)
-    builder (3.0.0)
+    builder (3.0.3)
     database_cleaner (0.8.0)
     diff-lcs (1.1.3)
     fakeweb (1.3.0)
-    i18n (0.6.0)
+    i18n (0.6.1)
     multi_json (1.3.6)
-    pg (0.14.0)
+    pg (0.14.1)
     rake (0.9.2.2)
     rspec (2.11.0)
       rspec-core (~> 2.11.0)
       rspec-expectations (~> 2.11.0)
       rspec-mocks (~> 2.11.0)
     rspec-core (2.11.1)
-    rspec-expectations (2.11.2)
+    rspec-expectations (2.11.3)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.2)
+    rspec-mocks (2.11.3)
     tzinfo (0.3.33)
 
 PLATFORMS

data/LICENSE

@@ -16,7 +16,7 @@ included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+NON INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -3,7 +3,7 @@
 
 # Remote Association
 
-  Add ```has_``` and ```belongs_``` associations to models inherited from ActiveResource::Base
+  Add ```has_one_remote```, ```has_many_remote```, and ```belongs_to_remote``` associations to models inherited from ActiveResource::Base
 
   Say, you have Author and a service with Profiles. You can access profile of author as easy as `author.profile`.
 
@@ -20,16 +20,48 @@
 ## Example
 
 ```ruby
+  class UserGroup < ActiveResource::Base
+    self.site = 'http://example.com'
+  end
+
   class Profile < ActiveResource::Base
-    self.site = REMOTE_HOST
+    self.site = 'http://example.com'
+  end
+
+  class Badge < ActiveResource::Base
+    self.site = 'http://example.com'
   end
+
   class User < ActiveRecord::Base
     include RemoteAssociation::Base
-    has_one_remote :profile
+
+    has_one_remote      :profile
+    has_many_remote     :badges
+    belongs_to_remote   :group, class_name: 'UserGroup', foreign_key: :group_id, primary_key: 'search[id_in]'
   end
 
-  User.first.profile
+  User.first.profile   # => <Profile>
+  User.first.group     # => <Group>
+  User.first.badges    # => [<Badge>, <Badge>]
+```
+
+## Advanced  usage
+
+```ruby
+  # Will load associated objects, when we will need them
+  users = Users.scoped.includes_remote(:profile, :badges)
+
+  # just adding SQL condition to out users relation
+  users = users.where(active: true)
+
+  # add additional search condition for request to Profiles API
+  users = users.where_remote(profile: {search: {kind_in: ['Facebook', 'GitHub']}})
 
+  # time to do ordering and pagination...
+  users = users.offset.(100).limit(5).order('name ASC')
+
+  # Fetch 10 users from DB, fetch 10 Profiles and Avatars for those users
+  users = users.all
 ```
 
 ## Installation
@@ -38,14 +70,24 @@ Add this line to your application's Gemfile:
 
     gem 'remote_association'
 
-## TODO
-
-Implement 'has_many_remote' analogie of 'AR.has_many'
-
 ## Contributing
 
 1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+2. Set up testing database via
+
+    rake spec:db:setup
+
+3. Create your feature branch
+
+    git checkout -b my-new-feature
+
+4. Add tests and run via `rspec`
+5. Commit your changes
+
+    git commit -am 'Added some feature'
+
+6. Push to the branch
+
+    git push origin my-new-feature
+
+7. Create new Pull Request

data/lib/remote_association/active_record/relation.rb

@@ -1,61 +1,141 @@
+require 'ostruct'
+
 module ActiveRecord
   class Relation
-    # Loads relations to ActiveModel models of models, selected by current relation.
-    # The analogy is <tt>includes(*args)</tt> of ActiveRecord.
+    # Queues loading of relations to ActiveModel models of models, selected by current relation.
+    # The full analogy is <tt>includes(*args)</tt> of ActiveRecord: all the realted objects will
+    # be loaded when one or all objects of relation are required.
     #
     # May raise <tt>RemoteAssociation::SettingsNotFoundError</tt> if one of args can't be found among
     # Class.activeresource_relations settings
     #
-    # Returns all the records matched by the options of the relation, same as <tt>all(*args)</tt>
+    # Would not perform remote request if all associated foreign_keys of belongs_to_remote association are nil
+    #
+    # Returns self - <tt>ActiveRecord::Relation</tt>
     #
     # === Examples
     #
-    # Author.scoped.includes_remote(:profile, :avatar)
+    # Author.scoped.includes_remote(:profile, :avatar).where(author_name: 'Tom').all
     def includes_remote(*args)
       args.each do |r|
         settings = klass.activeresource_relations[r.to_sym]
         raise RemoteAssociation::SettingsNotFoundError, "Can't find settings for #{r} association" if settings.blank?
 
-        ar_accessor = r.to_sym
-        foregin_key = settings[:foreign_key]
-        ar_class    = settings[:class_name ].constantize
+        ar_class = settings[:class_name].constantize
 
-        fetch_and_join_for_has_one_remote(ar_accessor, foregin_key, ar_class) if settings[:association_type] == :has_one_remote
-        fetch_and_join_for_belongs_to_remote(ar_accessor, foregin_key, ar_class) if settings[:association_type] == :belongs_to_remote
+        remote_associations << OpenStruct.new(
+                                ar_accessor:      r.to_sym,
+                                foreign_key:      settings[:foreign_key],
+                                ar_class:         ar_class,
+                                association_type: settings[:association_type]
+                              )
       end
 
-      set_remote_resources_prefetched
+      self
+    end
+
+    # Adds conditions (i.e. http query string parameters) to request of each remote API. Those are parameters to query string.
+    #
+    # Returns self - <tt>ActiveRecord::Relation</tt>
+    #
+    # === Example
+    #
+    # Author.scoped.includes_remote(:profile, :avatar).where_remote(profile: {search: {public: true}}, avatar: { primary: true }).all
+    #
+    # #=> Will do requests to:
+    # #  * http://.../prefiles.json?author_id[]=1&author_id[]=N&search[public][]=true
+    # #  * http://.../avatars.json?author_id[]=1&author_id[]=N&primary=true
+    def where_remote(conditions = {})
+      conditions.each do |association, conditions|
+        remote_conditions[association.to_sym] = remote_conditions[association.to_sym].deep_merge(conditions)
+      end
 
-      self.all
+      self
     end
 
-    private
+  private
+
+    # Array of remote associations to load.
+    # It contains Hashes with settings for loader.
+    attr_accessor :remote_associations
+
+    def remote_associations
+      @remote_associations ||= []
+    end
+
+    # Hash of parameters to merge into API requests.
+    attr_accessor :remote_conditions
+
+    def remote_conditions
+      @remote_conditions ||= Hash.new({})
+    end
+
+    # A method proxy for exec_queries: it wraps around original one
+    # and preloads remote associations. Returns {Array} of fetched
+    # records, like original exec_queries.
+    def exec_queries_with_remote_associations
+      exec_queries_without_remote_associations
+      preload_remote_associations
+      @records
+    end
 
-      def fetch_and_join_for_has_one_remote(ar_accessor, foregin_key, ar_class)
-        keys = self.uniq.pluck(:id)
+    alias_method :exec_queries_without_remote_associations, :exec_queries
+    alias_method :exec_queries, :exec_queries_with_remote_associations
 
-        remote_objects = ar_class.find(:all, :params => { foregin_key => keys })
+    # Does heavy lifting on fetching remote associations from distant places:
+    #   - checks, if remote_resources_loaded? already
+    #   - iterates through remote_associations and loads objects for each one
+    def preload_remote_associations
+      return true if remote_resources_loaded?
 
-        self.each do |u|
-          u.send("#{ar_accessor}=", remote_objects.select {|s| s.send(foregin_key) == u.id })
+      remote_associations.each do |r|
+        case r.association_type
+          when :has_one_remote    then fetch_and_join_for_has_any_remote(r)
+          when :has_many_remote   then fetch_and_join_for_has_any_remote(r)
+          when :belongs_to_remote then fetch_and_join_for_belongs_to_remote(r)
         end
       end
 
-      def fetch_and_join_for_belongs_to_remote(ar_accessor, foregin_key, ar_class)
-        keys = self.uniq.pluck(foregin_key.to_sym)
+      set_remote_resources_loaded unless remote_associations.empty?
+    end
 
-        remote_objects = ar_class.find(:all, :params => { :id => keys })
+    def fetch_and_join_for_has_any_remote(settings)
+      keys = @records.uniq.map(&:id)
 
-        self.each do |u|
-          u.send("#{ar_accessor}=", remote_objects.select {|s| u.send(foregin_key) == s.id })
-        end
+      remote_objects = fetch_remote_objects(settings.ar_class, keys, settings.ar_accessor)
+
+      @records.each do |record|
+        record.send("#{settings.ar_accessor}=", remote_objects.select { |s| s.send(settings.foreign_key) == record.id })
       end
+    end
 
-      def set_remote_resources_prefetched
-        self.each do |u|
-          u.instance_variable_set(:@remote_resources_prefetched, true)
-        end
+    def fetch_and_join_for_belongs_to_remote(settings)
+      keys = @records.uniq.map {|r| r.send settings.foreign_key.to_sym }.compact
+
+      return if keys.empty?
+
+      remote_objects = fetch_remote_objects(settings.ar_class, keys, settings.ar_accessor)
+
+      @records.each do |record|
+        record.send("#{settings.ar_accessor}=", remote_objects.select { |s| record.send(settings.foreign_key) == s.id })
       end
+    end
+
+    def set_remote_resources_loaded
+      @remote_resources_loaded = true
+      @records.each do |record|
+        record.instance_variable_set(:@remote_resources_loaded, true)
+      end
+    end
+
+    def fetch_remote_objects(ar_class, keys, ar_accessor)
+      params = klass.build_params_hash(keys).deep_merge(remote_conditions[ar_accessor.to_sym])
+      ar_class.find(:all, :params => params )
+    end
+
+    def remote_resources_loaded?
+      !!@remote_resources_loaded
+    end
 
   end
 end

data/lib/remote_association/belongs_to_remote.rb

@@ -9,6 +9,7 @@ module RemoteAssociation
       #
       # [association]
       #   Returns the associated object. +nil+ is returned if none is found.
+      #   When foreign_key value is nil, remote request would not be executed.
       # [association=(associate)]
       #   Just setter, no saves.
       #
@@ -34,15 +35,20 @@ module RemoteAssociation
       # association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly,
       # <tt>belongs_to_remote :favorite_person, :class_name => "Person"</tt> will use a foreign key
       # of "favorite_person_id".
+      # [:primary_key]
+      # Specify the http query parameter to find associated object used for the association. By default this is <tt>id</tt>.
+      # Example:
+      #  belongs_to_remote :firm, :primary_key => 'search[id_in]' #=> ...?firms.json?search%5Bid_in%5D%5B%5D=1
       #
       # Option examples:
-      # belongs_to :firm, :foreign_key => "client_of"
-      # belongs_to :author, :class_name => "Person", :foreign_key => "author_id"
+      #   belongs_to_remote :firm, :foreign_key => "client_of"
+      #   belongs_to_remote :author, :class_name => "Person", :foreign_key => "author_id"
       def belongs_to_remote(remote_rel, options ={})
         rel_options = {
                        class_name:  remote_rel.to_s.classify,
                        foreign_key: remote_rel.to_s.foreign_key,
-                       association_type: :belongs_to_remote
+                       association_type: :belongs_to_remote,
+                       primary_key: 'id'
                       }.merge(options.symbolize_keys)
 
         add_activeresource_relation(remote_rel.to_sym, rel_options)
@@ -52,16 +58,22 @@ module RemoteAssociation
           attr_accessor :#{remote_rel}
 
           def #{remote_rel}
-            if remote_resources_prefetched?
+            if remote_resources_loaded?
               @#{remote_rel} ? @#{remote_rel}.first : nil
             else
-              @#{remote_rel} ||= #{rel_options[:class_name]}.find(:first, params: { id: [self.#{rel_options[:foreign_key]}]})
+              @#{remote_rel} ||= self.#{rel_options[:foreign_key]}.present? ? #{rel_options[:class_name]}.find(:first, params: self.class.build_params_hash(self.#{rel_options[:foreign_key]})) : nil
             end
           end
 
+          ##
+          # Returns Hash with HTTP parameters to query remote API
+          def self.build_params_hash(keys)
+            keys = [keys] unless keys.kind_of?(Array)
+            {"#{rel_options[:primary_key]}" => keys}
+          end
+
         RUBY
 
       end
-
   end
 end

data/lib/remote_association/has_many_remote.rb

@@ -0,0 +1,72 @@
+module RemoteAssociation
+  module HasManyRemote
+    # Specifies a one-to-many association with another class. This method should only be used
+    # if this class is a kind of ActiveResource::Base and service for this resource can
+    # return some kind of foreign key.
+    #
+    # Methods will be added for retrieval and query for a single associated object, for which
+    # this object holds an id:
+    #
+    # [associations()]
+    #   Returns the associated objects. +[]+ is returned if none is found.
+    # [associations=(associates)]
+    #   Just setter, no saves.
+    #
+    # (+associations+ is replaced with the symbol passed as the first argument, so
+    # <tt>has_many_remote :authors</tt> would add among others <tt>authors.nil?</tt>.)
+    #
+    # === Example
+    #
+    # A Author class declares <tt>has_many_remote :profiles</tt>, which will add:
+    # * <tt>Author#profiles</tt> (similar to <tt>Profile.find(:all, params: { author_id: [author.id]})</tt>)
+    # * <tt>Author#profiles=(profile)</tt> (will set @profiles instance variable of Author# to profile value)
+    # The declaration can also include an options hash to specialize the behavior of the association.
+    #
+    # === Options
+    #
+    # [:class_name]
+    #   Specify the class name of the association. Use it only if that name can't be inferred
+    #   from the association name. So <tt>has_many_remote :profiles</tt> will by default be linked to the Profile class, but
+    #   if the real class name is SocialProfile, you'll have to specify it with this option.
+    # [:foreign_key]
+    #   Specify the foreign key used for searching association on remote service. By default this is guessed to be the name
+    #   of the current class with an "_id" suffix. So a class Author that defines a <tt>has_many_remote :profiles</tt>
+    #   association will use "author_id" as the default <tt>:foreign_key</tt>.
+    #   This key will be used in :get request. Example: <tt>GET http://example.com/profiles?author_id[]=1</tt>
+    #
+    # Option examples:
+    #   has_many_remote :firms, :foreign_key => "client_of"
+    #   has_many_remote :badges, :class_name => "Label", :foreign_key => "author_id"
+    def has_many_remote(remote_rel, options ={})
+      rel_options = {
+          class_name: remote_rel.to_s.singularize.classify,
+          foreign_key: self.model_name.to_s.foreign_key,
+          association_type: :has_many_remote
+      }.merge(options.symbolize_keys)
+
+      add_activeresource_relation(remote_rel.to_sym, rel_options)
+
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+
+        attr_accessor :#{remote_rel}
+
+        def #{remote_rel}                                                 #  def customers
+          if remote_resources_loaded?                                     #    if remote_resources_loaded?
+            @#{remote_rel} ? @#{remote_rel} : []                          #      @customers ? @customers : []
+          else                                                            #    else
+            @#{remote_rel} ||= #{rel_options[:class_name]}.               #      @customers ||= Person.
+              find(:all, params: self.class.build_params_hash(self.id))   #        find(:all, params: self.class.build_params_hash(self.id))
+          end                                                             #    end
+        end                                                               #  end
+
+        ##
+        # Returns Hash with HTTP parameters to query remote API
+        def self.build_params_hash(keys)
+          keys = [keys] unless keys.kind_of?(Array)
+          {"#{rel_options[:foreign_key]}" => keys}
+        end
+
+      RUBY
+    end
+  end
+end

data/lib/remote_association/has_one_remote.rb

@@ -18,7 +18,7 @@ module RemoteAssociation
       # === Example
       #
       # A Author class declares <tt>has_one_remote :profile</tt>, which will add:
-      # * <tt>Authort#profile</tt> (similar to <tt>Profile.find(:first, params: { author_id: [author.id]})</tt>)
+      # * <tt>Author#profile</tt> (similar to <tt>Profile.find(:first, params: { author_id: [author.id]})</tt>)
       # * <tt>Author#profile=(profile)</tt> (will set @profile instance variable of Author# to profile value)
       # The declaration can also include an options hash to specialize the behavior of the association.
       #
@@ -51,13 +51,20 @@ module RemoteAssociation
           attr_accessor :#{remote_rel}
 
           def #{remote_rel}
-            if remote_resources_prefetched?
+            if remote_resources_loaded?
               @#{remote_rel} ? @#{remote_rel}.first : nil
             else
-              @#{remote_rel} ||= #{rel_options[:class_name]}.find(:first, params: { #{rel_options[:foreign_key]}: [self.id]})
+              @#{remote_rel} ||= #{rel_options[:class_name]}.find(:first, params: self.class.build_params_hash(self.id))
             end
           end
 
+          ##
+          # Returns Hash with HTTP parameters to query remote API
+          def self.build_params_hash(keys)
+            keys = [keys] unless keys.kind_of?(Array)
+            {"#{rel_options[:foreign_key]}" => keys}
+          end
+
         RUBY
 
       end

data/lib/remote_association/version.rb

@@ -1,3 +1,3 @@
 module RemoteAssociation
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/remote_association.rb

@@ -3,6 +3,7 @@ require "active_support"
 
 require "remote_association/version"
 require "remote_association/has_one_remote"
+require "remote_association/has_many_remote"
 require "remote_association/belongs_to_remote"
 require "remote_association/active_record/relation"
 
@@ -11,7 +12,8 @@ module RemoteAssociation
   # Include this class to hav associations to ActiveResource models
   #
   # It will add methods to your class:
-  # * <tt>has_one_remote(name, *oprions)</tt>
+  # * <tt>has_one_remote(name, *options)</tt>
+  # * <tt>has_many_remote(name, *options)</tt>
   # * <tt>activeresource_relations</tt>
   # * <tt>add_activeresource_relation(name, options)</tt>
   module Base
@@ -25,6 +27,7 @@ module RemoteAssociation
 
     module ClassMethods
       include RemoteAssociation::HasOneRemote
+      include RemoteAssociation::HasManyRemote
       include RemoteAssociation::BelongsToRemote
 
       # Adds settings of relation to ActiveResource model.
@@ -55,8 +58,8 @@ module RemoteAssociation
     module InstanceMethods
 
       # Returns <tt>true</tt> if associations to remote relations already loaded and set
-      def remote_resources_prefetched?
-        @remote_resources_prefetched
+      def remote_resources_loaded?
+        @remote_resources_loaded
       end
     end
   end

data/spec/remote_association/belongs_to_remote_spec.rb

@@ -24,20 +24,57 @@ describe RemoteAssociation, "method :belongs_to_remote" do
       include RemoteAssociation::Base
       belongs_to_remote :user
     end
-    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?id%5B%5D=1", body: @body )
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?id%5B%5D=1", body: @body)
 
     Profile.first.user.name.should eq('User A')
   end
 
+  it 'returns nil if no object present' do
+    unset_const(:Profile)
+    class Profile < ActiveRecord::Base
+      include RemoteAssociation::Base
+      belongs_to_remote :user
+    end
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?id%5B%5D=1", body: [].to_json)
+
+    Profile.first.user.should be_nil
+  end
+
   it 'should prefetch remote associations of models with defaults (single request)' do
     add_profile(2, 2, "letter B")
     FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?id%5B%5D=1&id%5B%5D=2", body: @full_body)
 
-    profiles = Profile.scoped.includes_remote(:user)
+    profiles = Profile.scoped.includes_remote(:user).all
     profiles.first.user.name.should eq('User A')
     profiles.last.user.name.should eq('User B')
   end
 
+  it "should not request remote collection in single request when all foreign_keys are nil" do
+    Profile.delete_all
+    add_profile(1, 'NULL', "A")
+    add_profile(2, 'NULL', "A")
+    profiles = Profile.scoped.includes_remote(:user).all
+    profiles.map(&:user).should eq [nil, nil]
+  end
+
+  it "should not request remote data when foreign_key value is nil" do
+    profile = Profile.new(user_id: nil)
+    profile.user.should be_nil
+  end
+
+  describe "#build_params_hash" do
+    it "returns valid Hash of HTTP query string parameters" do
+      unset_const(:Profile)
+      class Profile < ActiveRecord::Base
+        include RemoteAssociation::Base
+        belongs_to_remote :user
+      end
+
+      Profile.build_params_hash(10).should eq({'id' => [10]})
+      Profile.build_params_hash([10, 13, 15]).should eq({'id' => [10, 13, 15]})
+    end
+  end
+
   describe "has options:"  do
     it ":class_name - able to choose custom class of association" do
       unset_const(:Profile)
@@ -50,8 +87,9 @@ describe RemoteAssociation, "method :belongs_to_remote" do
         include RemoteAssociation::Base
         belongs_to_remote :user, class_name: "CustomUser"
       end
-      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?id%5B%5D=1", body: @body )
+      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?id%5B%5D=1", body: @body)
     end
+
     it ":foreign_key - can set key to extract from it's model" do
       unset_const(:Profile)
       class Profile < ActiveRecord::Base
@@ -61,10 +99,18 @@ describe RemoteAssociation, "method :belongs_to_remote" do
       end
       FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?id%5B%5D=1", body: @body)
     end
+
+    it ":primary_key - can set key to query from remote API" do
+      unset_const(:Profile)
+      class Profile < ActiveRecord::Base
+        include RemoteAssociation::Base
+        belongs_to_remote :user, primary_key: 'search[id_in]'
+      end
+      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/users.json?search%5Bid_in%5D%5B%5D=1", body: @body)
+    end
+
     after(:each) do
       Profile.first.user.name.should eq('User A')
     end
   end
-
-
 end

data/spec/remote_association/has_many_remote_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe RemoteAssociation, 'method :has_many_remote' do
+  before(:all) do
+    @body = [
+      {profile: {id: 1, user_id: 1, like: "letter A"}},
+      {profile: {id: 2, user_id: 1, like: "letter B"}}
+    ].to_json
+    @full_body = [
+      {profile: {id: 1, user_id: 1, like: "letter A"}},
+      {profile: {id: 2, user_id: 1, like: "letter B"}},
+      {profile: {id: 3, user_id: 2, like: "letter C"}},
+    ].to_json
+  end
+
+  before(:each) do
+    unset_const(:User)
+    unset_const(:Profile)
+    class User < ActiveRecord::Base
+      include RemoteAssociation::Base
+      has_many_remote :profiles
+    end
+    class Profile < ActiveResource::Base
+      self.site = REMOTE_HOST
+    end
+
+    add_user(1,"User A")
+    add_user(2,"User B")
+  end
+
+  it 'uses default settings' do
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1", body: @body )
+    User.first.profiles.map(&:like).should eq ["letter A", "letter B"]
+  end
+
+  it 'returns empty Array if no objects present' do
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1", body: [].to_json )
+    User.first.profiles.should eq []
+  end
+
+  it 'should prefetch remote associations of models with defaults (single request)' do
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1&user_id%5B%5D=2", body: @full_body)
+
+    users = User.scoped.includes_remote(:profiles).all
+    users.first.profiles.map(&:like).should eq ["letter A", "letter B"]
+    users.last.profiles.map(&:like).should eq ["letter C"]
+  end
+
+  describe '#build_params_hash' do
+    it 'returns valid Hash of HTTP query string parameters' do
+      User.build_params_hash(10).should eq({'user_id' => [10]})
+      User.build_params_hash([10, 13, 15]).should eq({'user_id' => [10, 13, 15]})
+    end
+  end
+
+  describe 'options' do
+    it ":class_name" do
+      unset_const(:User)
+      unset_const(:CustomProfile)
+      class CustomProfile < ActiveResource::Base
+        self.site = REMOTE_HOST
+        self.element_name = "profile"
+      end
+      class User < ActiveRecord::Base
+        include RemoteAssociation::Base
+        has_many_remote :profiles, class_name: "CustomProfile"
+      end
+      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1", body: @body )
+    end
+
+    it ":foreign_key" do
+      unset_const(:User)
+      class User < ActiveRecord::Base
+        include RemoteAssociation::Base
+        has_many_remote :profiles, foreign_key: 'search[login_id_in]'
+      end
+      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?search%5Blogin_id_in%5D%5B%5D=1", body: @body)
+    end
+
+    after(:each) do
+      User.first.profiles.map(&:like).should eq(['letter A', 'letter B'])
+    end
+  end
+end

data/spec/remote_association/has_one_remote_spec.rb

@@ -30,14 +30,26 @@ describe RemoteAssociation, "method :has_one_remote" do
     User.first.profile.like.should eq('letter A')
   end
 
+  it 'returns nil if no object present' do
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1", body: [].to_json )
+    User.first.profile.should be_nil
+  end
+
   it 'should prefetch remote associations of models with defaults (single request)' do
     FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1&user_id%5B%5D=2", body: @full_body)
 
-    users = User.scoped.includes_remote(:profile)
+    users = User.scoped.includes_remote(:profile).all
     users.first.profile.like.should eq('letter A')
     users.last.profile.like.should eq('letter B')
   end
 
+  describe "#build_params_hash" do
+    it "returns valid Hash of HTTP query string parameters" do
+      User.build_params_hash(10).should eq({'user_id' => [10]})
+      User.build_params_hash([10, 13, 15]).should eq({'user_id' => [10, 13, 15]})
+    end
+  end
+
   describe "has options:"  do
     it ":class_name - able to choose custom class of association" do
       unset_const(:User)
@@ -56,9 +68,9 @@ describe RemoteAssociation, "method :has_one_remote" do
       unset_const(:User)
       class User < ActiveRecord::Base
         include RemoteAssociation::Base
-        has_one_remote :profile, foreign_key: :login_id
+        has_one_remote :profile, foreign_key: 'search[login_id_in]'
       end
-      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?login_id%5B%5D=1", body: @body)
+      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?search%5Blogin_id_in%5D%5B%5D=1", body: @body)
     end
     after(:each) do
       User.first.profile.like.should eq('letter A')

data/spec/remote_association/remote_association_spec.rb

@@ -7,6 +7,7 @@ describe RemoteAssociation do
       {profile: {id: 2, user_id: 2, like: "letter B"}}
     ]
   end
+
   before(:each) do
     unset_const(:Profile)
     unset_const(:User)
@@ -42,11 +43,47 @@ describe RemoteAssociation do
     FakeWeb.register_uri(:get, "#{REMOTE_HOST}/other_profiles.json?user_id%5B%5D=1&user_id%5B%5D=2", body: @profiles_json.to_json)
     FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1&user_id%5B%5D=2", body: @profiles_json.to_json)
 
-    users = User.scoped.includes_remote(:profile, :other_profile)
+    users = User.scoped.includes_remote(:profile, :other_profile).all
     users.first.profile.like.should eq('letter A')
     users.last.profile.like.should eq('letter B')
     users.first.other_profile.like.should eq('letter A')
     users.last.other_profile.like.should eq('letter B')
   end
 
+  it "should fetch remote objects right after ActiveRecord fetched array of data" do
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=2",
+       body: [{profile: {id: 2, user_id: 2, like: "letter B"}}].to_json)
+
+    t = User.arel_table
+    users = User.where(t[:name].matches('%User%')).includes_remote(:profile).
+                         where(t[:name].matches('%B%')).all
+    users.map(&:profile).flatten.map(&:like).should eq(['letter B'])
+  end
+
+  it "can set additional conditions for API call" do
+    unset_const(:OtherProfile)
+    unset_const(:User)
+    class OtherProfile < ActiveResource::Base
+      self.site = REMOTE_HOST
+    end
+    class User < ActiveRecord::Base
+      include RemoteAssociation::Base
+      has_one_remote :profile
+      has_one_remote :other_profile
+    end
+
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=2&search%5Bcountry_equals%5D=Ukraine&search%5Bage_less%5D=30",
+       body: [{profile: {id: 2, user_id: 2, like: "letter B"}}].to_json)
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/other_profiles.json?capitals=false&user_id%5B%5D=2",
+       body: [{other_profile: {id: 2, user_id: 2, like: "letter b"}}].to_json)
+
+    users = User.scoped.includes_remote(:profile, :other_profile).
+                  where_remote(profile: {search: {country_equals: 'Ukraine'}}, other_profile: {capitals: false} ).
+                  where(id: 2).
+                  where_remote(profile: {search: {age_less: 30}}).all
+    users.first.profile.like.should eq('letter B')
+    users.first.other_profile.like.should eq('letter b')
+
+  end
+
 end

data/spec/spec_helper.rb

@@ -26,6 +26,7 @@ RSpec.configure do |config|
 
   config.after(:each) do
     DatabaseCleaner.clean
+    FakeWeb.clean_registry
   end
 end
 

data/spec/tasks/db_setup.rake

@@ -29,7 +29,7 @@ DROP TABLE IF EXISTS "public"."profiles";
 
 CREATE TABLE "public"."profiles" (
 	"id" int4 NOT NULL,
-	"user_id" int4 NOT NULL,
+	"user_id" int4,
 	"like" varchar(255) NOT NULL,
 	CONSTRAINT "profiles_pkey" PRIMARY KEY ("id") NOT DEFERRABLE INITIALLY IMMEDIATE
 )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remote_association
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-24 00:00:00.000000000 Z
+date: 2012-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -141,11 +141,13 @@ files:
 - lib/remote_association.rb
 - lib/remote_association/active_record/relation.rb
 - lib/remote_association/belongs_to_remote.rb
+- lib/remote_association/has_many_remote.rb
 - lib/remote_association/has_one_remote.rb
 - lib/remote_association/version.rb
 - remote_association.gemspec
 - spec/config/database.example.yml
 - spec/remote_association/belongs_to_remote_spec.rb
+- spec/remote_association/has_many_remote_spec.rb
 - spec/remote_association/has_one_remote_spec.rb
 - spec/remote_association/remote_association_spec.rb
 - spec/spec_helper.rb
@@ -164,7 +166,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3408694101896139864
+      hash: 2376249119482484222
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -173,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3408694101896139864
+      hash: 2376249119482484222
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -183,6 +185,7 @@ summary: Adds relations to ActiveResource models
 test_files:
 - spec/config/database.example.yml
 - spec/remote_association/belongs_to_remote_spec.rb
+- spec/remote_association/has_many_remote_spec.rb
 - spec/remote_association/has_one_remote_spec.rb
 - spec/remote_association/remote_association_spec.rb
 - spec/spec_helper.rb