mongo_mapper 0.8.6 → 0.9.0

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

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneAssociation < BelongsToAssociation
+        def embeddable?
+          klass.embeddable?
+        end
+
+        def proxy_class
+          @proxy_class ||= klass.embeddable? ? OneEmbeddedProxy : OneProxy
+        end
+
+        def autosave?
+          options.fetch(:autosave, embeddable?)
+        end
+      end
+    end
+  end
+end

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

@@ -16,11 +16,16 @@ module MongoMapper
           else
             @target = klass.load(doc)
           end
+          @target.default_id_value if @target && @target.id.nil?
           assign_references(@target)
           loaded
           @target
         end
 
+        def save_to_collection(options={})
+          @target.persist(options) if @target
+        end
+
         protected
 
           def find_target

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

@@ -19,7 +19,7 @@ module MongoMapper
           load_target
 
           if !target.nil? && target != doc
-            if options[:dependent] && !target.new?
+            if options[:dependent] && target.persisted?
               case options[:dependent]
                 when :delete
                   target.delete
@@ -32,13 +32,13 @@ module MongoMapper
             end
           end
 
-          reset
-
-          unless doc.nil?
-            proxy_owner.save if proxy_owner.new?
-            doc = klass.new(doc) unless klass === doc
+          if doc.nil?
+            target.update_attributes(foreign_key => nil) unless target.nil?
+          else
+            proxy_owner.save unless proxy_owner.persisted?
+            doc = klass.new(doc) unless doc.is_a?(klass)
             doc[foreign_key] = proxy_owner.id
-            doc.save if doc.new?
+            doc.save unless doc.persisted?
             loaded
             @target = doc
           end

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

@@ -9,7 +9,7 @@ module MongoMapper
         alias :proxy_respond_to? :respond_to?
         alias :proxy_extend :extend
 
-        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^respond_to_missing\?$|^object_id$)/ }
 
         attr_reader :proxy_owner, :association, :target
 
@@ -113,7 +113,7 @@ module MongoMapper
           def load_target
             unless loaded?
               if @target.is_a?(Array) && @target.any?
-                @target = find_target + @target.find_all { |record| record.new? }
+                @target = find_target + @target.find_all { |record| !record.persisted? }
               else
                 @target = find_target
               end

data/lib/mongo_mapper/plugins/caching.rb

@@ -2,10 +2,12 @@
 module MongoMapper
   module Plugins
     module Caching
+      extend ActiveSupport::Concern
+
       module InstanceMethods
         def cache_key(*suffixes)
           cache_key = case
-                        when new?
+                        when !persisted?
                           "#{self.class.name}/new"
                         when timestamp = self[:updated_at]
                           "#{self.class.name}/#{id}-#{timestamp.to_s(:number)}"

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -1,240 +1,31 @@
 # encoding: UTF-8
-# Almost all of this callback stuff is pulled directly from ActiveSupport
-# in the interest of support rails 2 and 3 at the same time and is the
-# same copyright as rails.
 module MongoMapper
   module Plugins
     module Callbacks
-      def self.configure(model)
-        model.class_eval do
-          define_callbacks(
-            :before_save,                 :after_save,
-            :before_create,               :after_create,
-            :before_update,               :after_update,
-            :before_validation,           :after_validation,
-            :before_validation_on_create, :after_validation_on_create,
-            :before_validation_on_update, :after_validation_on_update,
-            :before_destroy,              :after_destroy,
-            :validate_on_create,          :validate_on_update,
-            :validate
-          )
-        end
-      end
-
-      module ClassMethods
-        def define_callbacks(*callbacks)
-          callbacks.each do |callback|
-            class_eval <<-"end_eval"
-              def self.#{callback}(*methods, &block)
-                callbacks = CallbackChain.build(:#{callback}, *methods, &block)
-                @#{callback}_callbacks ||= CallbackChain.new
-                @#{callback}_callbacks.concat callbacks
-              end
-
-              def self.#{callback}_callback_chain
-                @#{callback}_callbacks ||= CallbackChain.new
-
-                if superclass.respond_to?(:#{callback}_callback_chain)
-                  CallbackChain.new(
-                    superclass.#{callback}_callback_chain +
-                    @#{callback}_callbacks
-                  )
-                else
-                  @#{callback}_callbacks
-                end
-              end
-            end_eval
-          end
-        end
-      end
+      extend ActiveSupport::Concern
 
       module InstanceMethods
-        def valid?
-          action = new? ? 'create' : 'update'
-          run_callbacks(:before_validation)
-          run_callbacks("before_validation_on_#{action}".to_sym)
-          result = super
-          run_callbacks("after_validation_on_#{action}".to_sym)
-          run_callbacks(:after_validation)
-          result
-        end
-
-        # Overriding validatable's valid_for_group? to integrate validation callbacks
-        def valid_for_group?(group) #:nodoc:
-          errors.clear
-          run_before_validations
-          run_callbacks(:validate)
-          new? ? run_callbacks(:validate_on_create) : run_callbacks(:validate_on_update)
-          self.class.validate_children(self, group)
-          self.validate_group(group)
-          errors.empty?
+        def valid?(context = nil)
+          context ||= (new_record? ? :create : :update)
+          super(context) && errors.empty?
         end
 
         def destroy
-          run_callbacks(:before_destroy)
-          result = super
-          run_callbacks(:after_destroy)
-          result
-        end
-
-        def run_callbacks(kind, options={}, &block)
-          callback_chain_method = "#{kind}_callback_chain"
-          return unless self.class.respond_to?(callback_chain_method)
-          self.class.send(callback_chain_method).run(self, options, &block)
-          self.embedded_associations.each do |association|
-            if association.one?
-              self.send(association.name).run_callbacks(kind, options, &block)
-            else
-              self.send(association.name).each do |document|
-                document.run_callbacks(kind, options, &block)
-              end
-            end
-          end
-        end
-
-        private
-          def create_or_update(*args)
-            run_callbacks(:before_save)
-            if result = super
-              run_callbacks(:after_save)
-            end
-            result
-          end
-
-          def create(*args)
-            run_callbacks(:before_create)
-            result = super
-            run_callbacks(:after_create)
-            result
-          end
-
-          def update(*args)
-            run_callbacks(:before_update)
-            result = super
-            run_callbacks(:after_update)
-            result
-          end
-      end
-
-      class CallbackChain < Array
-        def self.build(kind, *methods, &block)
-          methods, options = extract_options(*methods, &block)
-          methods.map! { |method| Callback.new(kind, method, options) }
-          new(methods)
-        end
-
-        def run(object, options={}, &terminator)
-          enumerator = options[:enumerator] || :each
-
-          unless block_given?
-            send(enumerator) { |callback| callback.call(object) }
-          else
-            send(enumerator) do |callback|
-              result = callback.call(object)
-              break result if terminator.call(result, object)
-            end
-          end
-        end
-
-        # TODO: Decompose into more Array like behavior
-        def replace_or_append!(chain)
-          if index = index(chain)
-            self[index] = chain
-          else
-            self << chain
-          end
-          self
-        end
-
-        def find(callback, &block)
-          select { |c| c == callback && (!block_given? || yield(c)) }.first
+          run_callbacks(:destroy) { super }
         end
 
-        def delete(callback)
-          super(callback.is_a?(Callback) ? callback : find(callback))
+      private
+        def create_or_update(*)
+          run_callbacks(:save) { super }
         end
 
-        private
-          def self.extract_options(*methods, &block)
-            methods.flatten!
-            options = methods.extract_options!
-            methods << block if block_given?
-            return methods, options
-          end
-
-          def extract_options(*methods, &block)
-            self.class.extract_options(*methods, &block)
-          end
-      end
-
-      class Callback
-        attr_reader :kind, :method, :identifier, :options
-
-        def initialize(kind, method, options={})
-          @kind       = kind
-          @method     = method
-          @identifier = options[:identifier]
-          @options    = options
+        def create(*)
+          run_callbacks(:create) { super }
         end
 
-        def ==(other)
-          case other
-          when Callback
-            (self.identifier && self.identifier == other.identifier) || self.method == other.method
-          else
-            (self.identifier && self.identifier == other) || self.method == other
-          end
+        def update(*)
+          run_callbacks(:update) { super }
         end
-
-        def eql?(other)
-          self == other
-        end
-
-        def dup
-          self.class.new(@kind, @method, @options.dup)
-        end
-
-        def hash
-          if @identifier
-            @identifier.hash
-          else
-            @method.hash
-          end
-        end
-
-        def call(*args, &block)
-          evaluate_method(method, *args, &block) if should_run_callback?(*args)
-        rescue LocalJumpError
-          raise ArgumentError,
-            "Cannot yield from a Proc type filter. The Proc must take two " +
-            "arguments and execute #call on the second argument."
-        end
-
-        private
-          def evaluate_method(method, *args, &block)
-            case method
-              when Symbol
-                object = args.shift
-                object.send(method, *args, &block)
-              when String
-                eval(method, args.first.instance_eval { binding })
-              when Proc, Method
-                method.call(*args, &block)
-              else
-                if method.respond_to?(kind)
-                  method.send(kind, *args, &block)
-                else
-                  raise ArgumentError,
-                    "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
-                    "a block to be invoked, or an object responding to the callback method."
-                end
-            end
-          end
-
-          def should_run_callback?(*args)
-            [options[:if]].flatten.compact.all? { |a| evaluate_method(a, *args) } &&
-            ![options[:unless]].flatten.compact.any? { |a| evaluate_method(a, *args) }
-          end
       end
     end
   end

data/lib/mongo_mapper/plugins/clone.rb

@@ -2,11 +2,13 @@
 module MongoMapper
   module Plugins
     module Clone
+      extend ActiveSupport::Concern
+
       module InstanceMethods
         def initialize_copy(other)
           @_new       = true
           @_destroyed = false
-          default_id_value({})
+          default_id_value
           associations.each do |name, association|
             instance_variable_set(association.ivar, nil)
           end

data/lib/mongo_mapper/plugins/dirty.rb

@@ -2,122 +2,69 @@
 module MongoMapper
   module Plugins
     module Dirty
-      module InstanceMethods
-        def method_missing(method, *args, &block)
-          if method.to_s =~ /(_changed\?|_change|_will_change!|_was)$/
-            method_suffix = $1
-            key = method.to_s.gsub(method_suffix, '')
+      extend ActiveSupport::Concern
 
-            if key_names.include?(key)
-              case method_suffix
-                when '_changed?'
-                  key_changed?(key)
-                when '_change'
-                  key_change(key)
-                when '_will_change!'
-                  key_will_change!(key)
-                when '_was'
-                  key_was(key)
-              end
-            else
-              super
-            end
-          else
-            super
-          end
-        end
-
-        def changed?
-          !changed_keys.empty?
-        end
-
-        def changed
-          changed_keys.keys
-        end
-
-        def changes
-          changed.inject({}) { |h, key| h[key] = key_change(key); h }
-        end
+      include ::ActiveModel::Dirty
 
+      module InstanceMethods
         def initialize(*)
           # never register initial id assignment as a change
-          super.tap { changed_keys.delete('_id') }
+          super.tap { changed_attributes.delete('_id') }
         end
 
         def initialize_from_database(*)
-          super.tap { changed_keys.clear }
+          super.tap { changed_attributes.clear }
         end
 
         def save(*)
-          if status = super
-            changed_keys.clear
-          end
-          status
+          clear_changes { super }
         end
 
         def save!(*)
-          status = super
-          changed_keys.clear
-          status
+          clear_changes { super }
         end
 
         def reload(*)
-          document = super
-          changed_keys.clear
-          document
+          super.tap { clear_changes }
         end
 
-        private
-          def clone_key_value(key)
-            value = read_key(key)
-            value.duplicable? ? value.clone : value
-          rescue TypeError, NoMethodError
-            value
-          end
-
-          def changed_keys
-            @changed_keys ||= {}
-          end
-
-          def key_changed?(key)
-            changed_keys.include?(key)
-          end
-
-          def key_change(key)
-            [changed_keys[key], __send__(key)] if key_changed?(key)
-          end
-
-          def key_was(key)
-            key_changed?(key) ? changed_keys[key] : __send__(key)
-          end
+        protected
 
-          def key_will_change!(key)
-            changed_keys[key] = clone_key_value(key)
-          end
-
-          def write_key(key, value)
-            key = key.to_s
+        def attribute_method?(attr)
+          # This overrides ::ActiveSupport::Dirty#attribute_method? to allow attributes to be any key
+          # in the attributes hash ( default ) or any key defined on the model that may not yet have
+          # had a value stored in the attributes collection.
+          super || key_names.include?(attr)
+        end
 
-            if changed_keys.include?(key)
-              old = changed_keys[key]
-              changed_keys.delete(key) unless value_changed?(key, old, value)
-            else
-              old = clone_key_value(key)
-              changed_keys[key] = old if value_changed?(key, old, value)
+        def clear_changes
+          previous = changes
+          (block_given? ? yield : true).tap do |result|
+            unless result == false #failed validation; nil is OK.
+              @previously_changed = previous
+              changed_attributes.clear
             end
-
-            super(key, value)
           end
+        end
 
-          def value_changed?(key_name, old, value)
-            key = keys[key_name]
+        private
 
-            if key.number? && value.blank?
-              value = nil
-            end
+        def write_key(key, value)
+          key = key.to_s
+          old = read_key(key)
+          attribute_will_change!(key) if attribute_should_change?(key, old, value)
+          changed_attributes.delete(key) unless value_changed?(key, attribute_was(key), value)
+          super(key, value)
+        end
 
-            old != value
-          end
+        def attribute_should_change?(key, old, value)
+          attribute_changed?(key) == false && value_changed?(key, old, value)
+        end
+
+        def value_changed?(key_name, old, value)
+          value = nil if keys[key_name.to_s].number? && value.blank?
+          old != value
+        end
       end
     end
   end