ssherman-mongo_mapper 0.8.6

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

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyPolymorphicProxy < ManyDocumentsProxy
+        private
+          def apply_scope(doc)
+            doc[association.type_key_name] = doc.class.name
+            super
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class OneEmbeddedProxy < Proxy
+        def build(attributes={})
+          @target = klass.new(attributes)
+          assign_references(@target)
+          loaded
+          @target
+        end
+
+        def replace(doc)
+          if doc.respond_to?(:attributes)
+            @target = klass.load(doc.attributes)
+          else
+            @target = klass.load(doc)
+          end
+          assign_references(@target)
+          loaded
+          @target
+        end
+
+        protected
+
+          def find_target
+            if @value
+              klass.load(@value).tap do |child|
+                assign_references(child)
+              end
+            end
+          end
+
+          def assign_references(doc)
+            doc._parent_document = proxy_owner if doc
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+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
+
+          if doc.nil?
+            target.update_attributes(foreign_key => nil) unless target.nil?
+          else
+            proxy_owner.save if proxy_owner.new?
+            doc = klass.new(doc) unless doc.is_a?(klass)
+            doc[foreign_key] = proxy_owner.id
+            doc.save if doc.new?
+            loaded
+            @target = doc
+          end
+        end
+
+        protected
+          def find_target
+            target_class.first(association.query_options.merge(foreign_key => proxy_owner.id))
+          end
+
+          def instantiate_target(instantiator, attrs={})
+            @target = target_class.send(instantiator, attrs.update(foreign_key => proxy_owner.id))
+            loaded
+            @target
+          end
+
+          def target_class
+            @target_class ||= options[:class] || (options[:class_name] || association.name.to_s.camelize).constantize
+          end
+
+          def foreign_key
+            options[:foreign_key] || proxy_owner.class.name.foreign_key
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# encoding: UTF-8
+require 'forwardable'
+module MongoMapper
+  module Plugins
+    module Associations
+      class Proxy
+        extend Forwardable
+
+        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 :proxy_owner, :association, :target
+
+        alias :proxy_target :target
+        alias :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
+
+        # 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
+        def to_json(*options)
+          load_target
+          target.to_json(*options)
+        end
+
+        # see comments to to_json
+        def as_json(*options)
+          load_target
+          target.as_json(*options)
+        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
+              target.send(method, *args, &block)
+            end
+          end
+
+          def load_target
+            unless loaded?
+              if @target.is_a?(Array) && @target.any?
+                @target = find_target + @target.find_all { |record| record.new? }
+              else
+                @target = find_target
+              end
+              loaded
+            end
+            @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/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