Added support for Locator.locate_many and Locator.locate_many_signed …

…to efficiently fetch many models

CHANGELOG.md

@@ -0,0 +1,3 @@
+*   Added support for Locator.locate_many and Locator.locate_many_signed to efficiently fetch many models.
+
+    *Tom Ward, DHH*

lib/global_id/locator.rb

@@ -1,3 +1,6 @@
+require 'active_support'
+require 'active_support/core_ext/enumerable' # For Enumerable#index_by
+
 class GlobalID
   module Locator
     class << self
@@ -15,6 +18,31 @@ def locate(gid, options = {})
         end
       end
 
+      # Takes an array of GlobalIDs or strings that can be turned into a GlobalIDs.
+      # The GlobalIDs are located using Model.find(:all, ids), so the models must respond to
+      # that finder signature.
+      #
+      # This approach will efficiently call only one #find per model class, but still interpolate
+      # the results to match the order in which the gids were passed.
+      #
+      # Options:
+      # * <tt>:only</tt> - A class, module or Array of classes and/or modules that are
+      #   allowed to be located.  Passing one or more classes limits instances of returned
+      #   classes to those classes or their subclasses.  Passing one or more modules in limits
+      #   instances of returned classes to those including that module.  If no classes or
+      #   modules match, +nil+ is returned.
+      def locate_many(gids, options = {})
+        if (allowed_gids = parse_allowed(gids, options[:only])).any?
+          models_and_ids  = allowed_gids.collect { |gid| [ gid.model_name.constantize, gid.model_id ] }
+          ids_by_model    = models_and_ids.group_by(&:first)
+          loaded_by_model = Hash[ids_by_model.map { |model, ids| [ model, model.find(:all, ids.map(&:last)).index_by(&:id) ] }]
+
+          models_and_ids.collect { |(model, id)| loaded_by_model[model][id] }.compact
+        else
+          []
+        end
+      end
+
       # Takes either a SignedGlobalID or a string that can be turned into a SignedGlobalID
       #
       # Options:
@@ -27,6 +55,23 @@ def locate_signed(sgid, options = {})
         SignedGlobalID.find sgid, options
       end
 
+      # Takes an array of SignedGlobalIDs or strings that can be turned into a SignedGlobalIDs.
+      # The SignedGlobalIDs are located using Model.find(:all, ids), so the models must respond to
+      # that finder signature.
+      #
+      # This approach will efficiently call only one #find per model class, but still interpolate
+      # the results to match the order in which the gids were passed.
+      #
+      # Options:
+      # * <tt>:only</tt> - A class, module or Array of classes and/or modules that are
+      #   allowed to be located.  Passing one or more classes limits instances of returned
+      #   classes to those classes or their subclasses.  Passing one or more modules in limits
+      #   instances of returned classes to those including that module.  If no classes or
+      #   modules match, +nil+ is returned.
+      def locate_many_signed(sgids, options = {})
+        locate_many sgids.collect { |sgid| SignedGlobalID.parse(sgid) }, options
+      end
+
       # Tie a locator to an app.
       # Useful when different apps collaborate and reference each others' Global IDs.
       #
@@ -64,6 +109,10 @@ def find_allowed?(model_class, only = nil)
           only ? Array(only).any? { |c| model_class <= c } : true
         end
 
+        def parse_allowed(gids, only = nil)
+          gids.collect { |gid| GlobalID.parse(gid) }.compact.select { |gid| find_allowed?(gid.model_class, only) }
+        end
+
         def normalize_app(app)
           app.to_s.downcase
         end

test/cases/global_locator_test.rb

@@ -55,6 +55,22 @@ class GlobalLocatorTest < ActiveSupport::TestCase
     assert_equal @gid.model_id, found.id
   end
 
+  test 'by many GIDs of one class' do
+    assert_equal [ Person.new('1'), Person.new('2') ],
+      GlobalID::Locator.locate_many([ Person.new('1').to_gid, Person.new('2').to_gid ])
+  end
+
+  test 'by many GIDs of mixed classes' do
+    assert_equal [ Person.new('1'), Person::Child.new('1'), Person.new('2') ],
+      GlobalID::Locator.locate_many([ Person.new('1').to_gid, Person::Child.new('1').to_gid, Person.new('2').to_gid ])
+  end  
+
+  test 'by many GIDs with only: restriction to match subclass' do
+    assert_equal [ Person::Child.new('1') ],
+      GlobalID::Locator.locate_many([ Person.new('1').to_gid, Person::Child.new('1').to_gid, Person.new('2').to_gid ], only: Person::Child)
+  end
+
+
   test 'by SGID' do
     found = GlobalID::Locator.locate_signed(@sgid)
     assert_kind_of @sgid.model_class, found
@@ -103,6 +119,22 @@ class GlobalLocatorTest < ActiveSupport::TestCase
     assert_equal @sgid.model_id, found.id
   end
 
+  test 'by many SGIDs of one class' do
+    assert_equal [ Person.new('1'), Person.new('2') ],
+      GlobalID::Locator.locate_many_signed([ Person.new('1').to_sgid, Person.new('2').to_sgid ])
+  end
+
+  test 'by many SGIDs of mixed classes' do
+    assert_equal [ Person.new('1'), Person::Child.new('1'), Person.new('2') ],
+      GlobalID::Locator.locate_many_signed([ Person.new('1').to_sgid, Person::Child.new('1').to_sgid, Person.new('2').to_sgid ])
+  end  
+
+  test 'by many SGIDs with only: restriction to match subclass' do
+    assert_equal [ Person::Child.new('1') ],
+      GlobalID::Locator.locate_many_signed([ Person.new('1').to_sgid, Person::Child.new('1').to_sgid, Person.new('2').to_sgid ], only: Person::Child)
+  end
+
+
   test 'by GID string' do
     found = GlobalID::Locator.locate(@gid.to_s)
     assert_kind_of @gid.model_class, found

test/models/person.rb

@@ -3,16 +3,20 @@ class Person
 
   attr_reader :id
 
-  def self.find(id)
-    new(id)
+  def self.find(*args)
+    if args.first == :all
+      args.from(1).flatten.collect { |id| new(id) }
+    else
+      new(args.first)
+    end
   end
 
   def initialize(id = 1)
     @id = id
   end
 
   def ==(other)
-    id == other.try(:id)
+    other.is_a?(self.class) && id == other.try(:id)
   end
 end