mongo_mapper 0.14.0 → 0.15.4

data/lib/mongo_mapper/plugins/associations/many_association.rb

@@ -17,6 +17,8 @@ module MongoMapper
               ManyPolymorphicProxy
             elsif as?
               ManyDocumentsAsProxy
+            elsif in_foreign_array?
+              InForeignArrayProxy
             elsif in_array?
               InArrayProxy
             else
@@ -26,14 +28,13 @@ module MongoMapper
         end
 
         def setup(model)
-          model.associations_module.module_eval <<-end_eval
+          model.associations_module.module_eval(<<-end_eval, __FILE__, __LINE__ + 1)
             def #{name}
-              get_proxy(associations[#{name.inspect}])
+              get_proxy(associations[#{name.inspect}]).read
             end
 
             def #{name}=(value)
-              get_proxy(associations[#{name.inspect}]).replace(value)
-              value
+              get_proxy(associations[#{name.inspect}]).write(value)
             end
           end_eval
 
@@ -60,4 +61,4 @@ module MongoMapper
       end
     end
   end
-end
+end

data/lib/mongo_mapper/plugins/associations/{belongs_to_proxy.rb → proxy/belongs_to_proxy.rb}

@@ -47,6 +47,12 @@ module MongoMapper
           loaded
           @target
         end
+
+      private
+
+        def stale_target?
+          loaded? && proxy_owner[association.foreign_key] != @target&.id
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/associations/proxy/collection.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class Collection < Proxy
+        include Enumerable
+
+        def to_a
+          load_target
+
+          target.is_a?(Array) ?
+            target :
+            Array(target)
+        end
+
+        alias_method :to_ary, :to_a
+
+        def each(&block)
+          to_a.each(&block)
+        end
+
+        def [](val)
+          objs = to_a
+          objs ? objs[val] : nil
+        end
+
+        def empty?
+          to_a.empty?
+        end
+
+        def size
+          to_a.size
+        end
+
+        def length
+          to_a.length
+        end
+
+        def reset
+          super
+          target = []
+        end
+
+        def read
+          self
+        end
+
+        def write(value)
+          replace(value)
+          read
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/{in_array_proxy.rb → proxy/in_array_proxy.rb}

@@ -6,11 +6,11 @@ module MongoMapper
         include DynamicQuerying::ClassMethods
 
         def find(*args)
-          query.find(*scoped_ids(args))
+          order_results(query.find(*scoped_ids(args)))
         end
 
         def find!(*args)
-          query.find!(*scoped_ids(args))
+          order_results(query.find!(*scoped_ids(args)))
         end
 
         def paginate(options)
@@ -20,17 +20,29 @@ module MongoMapper
 
         def all(options={})
           return [] if ids.blank?
-          query(options).all
+          order_results(query(options).all)
         end
 
         def first(options={})
           return nil if ids.blank?
-          query(options).first
+
+          if ordered?
+            ids = find_ordered_ids(options)
+            find!(ids.first) if ids.any?
+          else
+            query(options).first
+          end
         end
 
         def last(options={})
           return nil if ids.blank?
-          query(options).last
+
+          if ordered?
+            ids = find_ordered_ids(options)
+            find!(ids.last) if ids.any?
+          else
+            query(options).last
+          end
         end
 
         def count(options={})
@@ -120,6 +132,13 @@ module MongoMapper
           valid.empty? ? nil : valid
         end
 
+        def find_ordered_ids(options={})
+          return ids if options.empty?
+
+          matched_ids = klass.collection.distinct(:_id, query(options).criteria.to_hash)
+          matched_ids.sort_by! { |matched_id| ids.index(matched_id) }
+        end
+
         def find_target
           return [] if ids.blank?
           all
@@ -128,7 +147,18 @@ module MongoMapper
         def ids
           proxy_owner[options[:in]]
         end
+
+        def order_results(objects)
+          return objects if !ordered?
+          return objects unless objects.respond_to?(:to_a) && objects.respond_to?(:sort_by)
+          objects.sort_by { |obj| ids.index(obj.id) }
+        end
+
+        def ordered?
+          association.ordered?
+        end
+
       end
     end
   end
-end
+end

data/lib/mongo_mapper/plugins/associations/proxy/in_foreign_array_proxy.rb

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class InForeignArrayProxy < Collection
+        include DynamicQuerying::ClassMethods
+
+        def find(*args)
+          query.find(*scoped_ids(args))
+        end
+
+        def find!(*args)
+          query.find!(*scoped_ids(args))
+        end
+
+        def paginate(options)
+          query.paginate(options)
+        end
+
+        def all(options={})
+          query(options).all
+        end
+
+        def first(options={})
+          query(options).first
+        end
+
+        def last(options={})
+          query(options).last
+        end
+
+        def count(options={})
+          query(options).count
+        end
+
+        def destroy_all(options={})
+          all(options).each do |doc|
+            doc.destroy
+          end
+          reset
+        end
+
+        def delete_all(options={})
+          docs = query(options).fields(:_id).all
+          klass.delete(docs.map { |d| d.id })
+          reset
+        end
+
+        def nullify
+          replace([])
+          reset
+        end
+
+        def create(attrs={})
+          doc = klass.create(attrs)
+          if doc.persisted?
+            inverse_association(doc) << proxy_owner
+            doc.save
+            reset
+          end
+          doc
+        end
+
+        def create!(attrs={})
+          doc = klass.create!(attrs)
+
+          if doc.persisted?
+            inverse_association(doc) << proxy_owner
+            doc.save
+            reset
+          end
+          doc
+        end
+
+        def <<(*docs)
+          flatten_deeper(docs).each do |doc|
+            inverse_association(doc) << proxy_owner
+            doc.save
+          end
+          reset
+        end
+        alias_method :push, :<<
+        alias_method :concat, :<<
+
+        def replace(docs)
+          doc_ids = docs.map do |doc|
+            doc.save unless doc.persisted?
+            inverse_association(doc) << proxy_owner
+            doc.save
+            doc.id
+          end
+
+          replace_selector =  { options[:from] => proxy_owner.id }
+          unless doc_ids.empty?
+            replace_selector[:_id] = {"$not" => {"$in" => doc_ids}}
+          end
+
+          klass.collection.update_many(replace_selector, {
+            "$pull" => { options[:from] => proxy_owner.id }
+          })
+
+          reset
+        end
+
+        private
+
+          def query(options={})
+            klass.query({}.
+              merge(association.query_options).
+              merge(options).
+              merge(criteria))
+          end
+
+          def criteria
+            {options[:from] => proxy_owner.id}
+          end
+
+          def scoped_ids(args)
+            valid = args.flatten.map do |id|
+              id = ObjectId.to_mongo(id) if klass.using_object_id?
+              id
+            end
+            valid.empty? ? nil : valid
+          end
+
+          def find_target
+            all
+          end
+
+          def inverse_association(doc)
+            doc.send(options[:as].to_s.pluralize)
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/{many_documents_proxy.rb → proxy/many_documents_proxy.rb}

@@ -76,10 +76,6 @@ module MongoMapper
           @target.each { |doc| doc.save(options) } if @target
         end
 
-        def each(&block)
-          load_target.each(&block)
-        end
-
       protected
 
         def query(options={})

data/lib/mongo_mapper/plugins/associations/{one_embedded_proxy.rb → proxy/one_embedded_proxy.rb}

@@ -11,7 +11,9 @@ module MongoMapper
         end
 
         def replace(doc)
-          if doc.respond_to?(:attributes)
+          if doc.instance_of?(klass)
+            @target = doc
+          elsif doc.respond_to?(:attributes)
             @target = klass.load(doc.attributes, true)
           else
             @target = klass.load(doc, true)

data/lib/mongo_mapper/plugins/associations/proxy/proxy.rb

@@ -0,0 +1,164 @@
+# encoding: UTF-8
+require 'forwardable'
+
+module MongoMapper
+  module Plugins
+    module Associations
+      class Proxy
+        extend Forwardable
+
+        class << self
+          def define_proxy_method(method)
+            define_method(method) do |*args, &block|
+              proxy_method(method, *args, &block)
+            end
+          end
+        end
+
+        attr_reader :proxy_owner, :association, :target
+
+        alias_method :proxy_respond_to?, :respond_to?
+        alias_method :proxy_extend, :extend
+        alias_method :proxy_association, :association
+
+        def_delegators :proxy_association, :klass, :options
+        def_delegator  :klass, :collection
+
+        def initialize(owner, association)
+          @proxy_owner, @association, @loaded = owner, association, false
+          Array(association.options[:extend]).each { |ext| proxy_extend(ext) }
+          reset
+        end
+
+        [
+          :is_a?,
+          :to_mongo,
+          :==,
+          :!=,
+          :nil?,
+          :blank?,
+          :present?,
+          # Active support in rails 3 beta 4 can override to_json after this is loaded,
+          # at least when run in mongomapper tests. The implementation was changed in master
+          # some time after this, so not sure whether this is still a problem.
+          #
+          # In rails 2, this isn't a problem however it also solves an issue where
+          # to_json isn't forwarded because it supports to_json itself
+          :to_json,
+          # see comments to to_json
+          :as_json,
+        ].each do |m|
+          define_proxy_method(m)
+        end
+
+        def inspect
+          load_target
+          "#<#{self.class.inspect}:#{object_id} #{@target.inspect}>"
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def loaded
+          @loaded = true
+        end
+
+        def reload
+          reset
+          load_target
+          self unless target.nil?
+        end
+
+        # :nocov:
+        def replace(v)
+          raise NotImplementedError
+        end
+        # :nocov:
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def respond_to?(*args)
+          super || (load_target && target.respond_to?(*args))
+        end
+
+        def read
+          load_target
+          @target
+        end
+
+        def write(value)
+          replace(value)
+          read
+        end
+
+        def proxy_method(method, *args, &block)
+          load_target
+          target.public_send(method, *args, &block)
+        end
+
+      protected
+
+        def load_target
+          if !loaded? || stale_target?
+            if @target.is_a?(Array) && @target.any?
+              @target = find_target + @target.find_all { |record| !record.persisted? }
+            else
+              @target = find_target
+            end
+            loaded
+          end
+          @target
+        rescue MongoMapper::DocumentNotFound
+          reset
+        end
+
+        # :nocov:
+        def find_target
+          raise NotImplementedError
+        end
+        # :nocov:
+
+        def flatten_deeper(array)
+          array.collect do |element|
+            (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element
+          end.flatten
+        end
+
+      private
+
+        def stale_target?
+          false
+        end
+
+        def define_proxy_method(method)
+          metaclass = class << self; self; end
+          metaclass.class_eval do
+            define_proxy_method(method)
+          end
+        end
+
+        def define_and_call_proxy_method(method, *args, &block)
+          define_proxy_method(method)
+          public_send(method, *args, &block)
+        end
+
+        def method_missing(method, *args, &block)
+          # load the target just in case it isn't loaded
+          load_target
+
+          # only define the method if the target has the method
+          # NOTE: include private methods!
+          if target.respond_to?(method, true)
+            define_and_call_proxy_method(method, *args, &block)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end