jmonteiro-mongo_mapper 0.1.0

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

@@ -0,0 +1,66 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneProxy < Proxy
+        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,65 @@
+module MongoMapper
+  module Plugins
+    module Callbacks
+      module InstanceMethods
+        def self.included(model)
+          model.class_eval do
+            include ActiveSupport::Callbacks
+
+            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
+            )
+          end
+        end
+        
+        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(attrs={})
+          super
+          changed_keys.clear if attrs.blank?
+        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

data/lib/mongo_mapper/plugins/equality.rb

@@ -0,0 +1,11 @@
+module MongoMapper
+  module Plugins
+    module Equality
+      module InstanceMethods
+        def ==(other)
+          other.is_a?(self.class) && _id == other._id
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -0,0 +1,66 @@
+module MongoMapper
+  module Plugins
+    module IdentityMap
+      module ClassMethods
+        def identity_map
+          Thread.current[:mongo_mapper_identity_map] ||= {}
+        end
+
+        def identity_map=(v)
+          Thread.current[:mongo_mapper_identity_map] = v
+        end
+
+        def identity_map_key(id)
+          "#{self}:#{id}"
+        end
+
+        def find_one(options={})
+          criteria, options = to_finder_options(options)
+          key = identity_map_key(criteria[:_id])
+
+          if document = identity_map[key]
+            document
+          else
+            document = super
+          end
+          
+          document
+        end
+
+        def load(attrs)
+          id = attrs[:_id] || attrs[:id] || attrs['_id'] || attrs['id']
+          key = identity_map_key(id)
+
+          unless document = identity_map[key]
+            document = super
+            identity_map[document.identity_map_key] = document
+          end
+
+          document
+        end
+      end
+
+      module InstanceMethods
+        def identity_map_key
+          @identity_map_key ||= self.class.identity_map_key(_id)
+        end
+
+        def identity_map
+          self.class.identity_map
+        end
+
+        def save
+          if result = super
+            identity_map[identity_map_key] = self
+          end
+          result
+        end
+
+        def delete
+          identity_map.delete(identity_map_key)
+          super
+        end
+      end
+    end
+  end
+end