thorsson-mongo_mapper 0.8.2

data/lib/mongo_mapper/plugins/caching.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Caching
+      module InstanceMethods
+        def cache_key(*suffixes)
+          cache_key = case
+                        when new?
+                          "#{self.class.name}/new"
+                        when timestamp = self[:updated_at]
+                          "#{self.class.name}/#{id}-#{timestamp.to_s(:number)}"
+                        else
+                          "#{self.class.name}/#{id}"
+                      end
+          cache_key += "/#{suffixes.join('/')}" unless suffixes.empty?
+          cache_key
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -0,0 +1,241 @@
+# 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
+
+      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?
+        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
+        end
+
+        def delete(callback)
+          super(callback.is_a?(Callback) ? callback : find(callback))
+        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
+        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
+        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
+end

data/lib/mongo_mapper/plugins/clone.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Clone
+      module InstanceMethods
+        def initialize_copy(other)
+          @_new       = true
+          @_destroyed = false
+          default_id_value({})
+          self.attributes = other.attributes.clone.except(:_id).inject({}) do |hash, entry|
+            key, value = entry
+            hash[key] = value.duplicable? ? value.clone : value
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/descendants.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+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,120 @@
+# encoding: UTF-8
+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

data/lib/mongo_mapper/plugins/document.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Document
+      module ClassMethods
+        def embeddable?
+          false
+        end
+      end
+
+      module InstanceMethods
+        def new?
+          @_new
+        end
+
+        def destroyed?
+          @_destroyed == true
+        end
+
+        def reload
+          if doc = collection.find_one(:_id => id)
+            tap do |instance|
+              instance.class.associations.each_key do |association_name|
+                send(association_name).reset if respond_to?(association_name)
+              end
+              instance.attributes = doc
+            end
+          else
+            raise DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection"
+          end
+        end
+
+        # Used by embedded docs to find root easily without if/respond_to? stuff.
+        # Documents are always root documents.
+        def _root_document
+          self
+        end
+      end
+    end
+  end
+end