novelys_mongo_mapper 0.6.10

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

@@ -0,0 +1,23 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyEmbeddedProxy < EmbeddedCollection
+        def replace(values)
+          @_values = values.map do |v|
+            v.respond_to?(:attributes) ? v.attributes : v
+          end
+          reset
+        end
+
+        private
+          def find_target
+            (@_values || []).map do |v|
+              child = klass.load(v)
+              assign_root_document(child)
+              child
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyPolymorphicProxy < ManyDocumentsProxy
+        private
+          def apply_scope(doc)
+            doc[reflection.type_key_name] = doc.class.name
+            super
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneProxy < Proxy
+        undef_method :object_id
+        
+        def build(attrs={})
+          instantiate_target(:new, attrs)
+        end
+
+        def create(attrs={})
+          instantiate_target(:create, attrs)
+        end
+
+        def create!(attrs={})
+          instantiate_target(:create!, attrs)
+        end
+
+        def replace(doc)
+          load_target
+
+          if !target.nil? && target != doc
+            if options[:dependent] && !target.new?
+              case options[:dependent]
+                when :delete
+                  target.delete
+                when :destroy
+                  target.destroy
+                when :nullify
+                  target[foreign_key] = nil
+                  target.save
+              end
+            end
+          end
+
+          reset
+
+          unless doc.nil?
+            owner.save if owner.new?
+            doc[foreign_key] = owner.id
+            doc.save if doc.new?
+            loaded
+            @target = doc
+          end
+        end
+
+        protected
+          def find_target
+            target_class.first(reflection.finder_options.merge(foreign_key => owner.id))
+          end
+
+          def instantiate_target(instantiator, attrs={})
+            @target = target_class.send(instantiator, attrs.update(foreign_key => owner.id))
+            loaded
+            @target
+          end
+
+          def target_class
+            @target_class ||= options[:class] || (options[:class_name] || reflection.name.to_s.camelize).constantize
+          end
+
+          def foreign_key
+            options[:foreign_key] || owner.class.name.foreign_key
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class Proxy
+        alias :proxy_respond_to? :respond_to?
+        alias :proxy_extend :extend
+
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+        attr_reader :owner, :reflection, :target
+
+        alias :proxy_owner :owner
+        alias :proxy_target :target
+        alias :proxy_reflection :reflection
+
+        delegate :klass, :to => :proxy_reflection
+        delegate :options, :to => :proxy_reflection
+        delegate :collection, :to => :klass
+
+        def initialize(owner, reflection)
+          @owner, @reflection, @loaded = owner, reflection, false
+          Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+          reset
+        end
+
+        def inspect
+          load_target
+          target.inspect
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def loaded
+          @loaded = true
+        end
+
+        def nil?
+          load_target
+          target.nil?
+        end
+
+        def blank?
+          load_target
+          target.blank?
+        end
+
+        def present?
+          load_target
+          target.present?
+        end
+
+        def reload
+          reset
+          load_target
+          self unless target.nil?
+        end
+
+        def replace(v)
+          raise NotImplementedError
+        end
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def respond_to?(*args)
+          proxy_respond_to?(*args) || (load_target && target.respond_to?(*args))
+        end
+
+        def send(method, *args)
+          if proxy_respond_to?(method)
+            super
+          else
+            load_target
+            target.send(method, *args)
+          end
+        end
+
+        def ===(other)
+          load_target
+          other === target
+        end
+
+        protected
+          def method_missing(method, *args, &block)
+            if load_target
+              if block_given?
+                target.send(method, *args)  { |*block_args| block.call(*block_args) }
+              else
+                target.send(method, *args)
+              end
+            end
+          end
+
+          def load_target
+            @target = find_target unless loaded?
+            loaded
+            @target
+          rescue MongoMapper::DocumentNotFound
+            reset
+          end
+
+          def find_target
+            raise NotImplementedError
+          end
+
+          def flatten_deeper(array)
+            array.collect do |element|
+              (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element
+            end.flatten
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -0,0 +1,76 @@
+module MongoMapper
+  module Plugins
+    module Callbacks
+      METHODS = ["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"]
+      
+      def self.configure(model)
+        model.class_eval do
+          include ActiveSupport::Callbacks
+
+          define_callbacks *METHODS
+          
+          # If Rails 3, support the new callback syntax
+          if metaclass.method_defined?(:set_callback)
+            METHODS.each do |method|
+              class_eval <<-"end_eval", __FILE__, __LINE__
+                def self.#{method}(*methods, &block)
+                  set_callback :#{method}, *methods, &block
+                end
+              end_eval
+            end
+          end
+        end
+      end
+      
+      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
+
+        def destroy
+          run_callbacks(:before_destroy)
+          result = super
+          run_callbacks(:after_destroy)
+          result
+        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
+    end
+  end
+end

data/lib/mongo_mapper/plugins/clone.rb

@@ -0,0 +1,13 @@
+module MongoMapper
+  module Plugins
+    module Clone
+      module InstanceMethods
+        def clone
+          clone_attributes = self.attributes
+          clone_attributes.delete("_id")
+          self.class.new(clone_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/descendants.rb

@@ -0,0 +1,16 @@
+module MongoMapper
+  module Plugins
+    module Descendants
+      module ClassMethods
+        def inherited(descendant)
+          (@descendants ||= []) << descendant
+          super
+        end
+
+        def descendants
+          @descendants
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/dirty.rb

@@ -0,0 +1,119 @@
+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, '')
+
+            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
+
+        def initialize(*args)
+          super
+          changed_keys.clear if args.first.blank? || !new?
+        end
+
+        def save(*args)
+          if status = super
+            changed_keys.clear
+          end
+          status
+        end
+
+        def save!(*args)
+          status = super
+          changed_keys.clear
+          status
+        end
+
+        def reload(*args)
+          document = super
+          changed_keys.clear
+          document
+        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
+
+          def key_will_change!(key)
+            changed_keys[key] = clone_key_value(key)
+          end
+
+          def write_key(key, value)
+            key = key.to_s
+
+            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)
+            end
+
+            super(key, value)
+          end
+
+          def value_changed?(key_name, old, value)
+            key = keys[key_name]
+
+            if key.number? && value.blank?
+              value = nil
+            end
+
+            old != value
+          end
+      end
+    end
+  end
+end