ign-mongo_mapper 0.8.6.1

data/lib/mongo_mapper/plugins/clone.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Clone
+      module InstanceMethods
+        def initialize_copy(other)
+          @_new       = true
+          @_destroyed = false
+          default_id_value
+          associations.each do |name, association|
+            instance_variable_set(association.ivar, nil)
+          end
+          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,124 @@
+# 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(*)
+          # never register initial id assignment as a change
+          super.tap { changed_keys.delete('_id') }
+        end
+
+        def initialize_from_database(*)
+          super.tap { changed_keys.clear }
+        end
+
+        def save(*)
+          if status = super
+            changed_keys.clear
+          end
+          status
+        end
+
+        def save!(*)
+          status = super
+          changed_keys.clear
+          status
+        end
+
+        def reload(*)
+          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_value do |association|
+                get_proxy(association).reset
+              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

data/lib/mongo_mapper/plugins/dynamic_querying.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+require 'mongo_mapper/plugins/dynamic_querying/dynamic_finder'
+
+module MongoMapper
+  module Plugins
+    module DynamicQuerying
+      module ClassMethods
+        def dynamic_find(finder, args)
+          attributes = {}
+
+          finder.attributes.each_with_index do |attr, index|
+            attributes[attr] = args[index]
+          end
+
+          options = args.extract_options!.merge(attributes)
+
+          if result = send(finder.finder, options)
+            result
+          else
+            if finder.raise?
+              raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
+            end
+
+            if finder.instantiator
+              self.send(finder.instantiator, attributes)
+            end
+          end
+        end
+
+        protected
+          def method_missing(method, *args, &block)
+            finder = DynamicFinder.new(method)
+
+            if finder.found?
+              dynamic_find(finder, args)
+            else
+              super
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/dynamic_querying/dynamic_finder.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module DynamicQuerying
+      class DynamicFinder
+        attr_reader :method, :attributes, :finder, :bang, :instantiator
+
+        def initialize(method)
+          @method = method
+          @finder = :first
+          @bang   = false
+          match
+        end
+
+        def found?
+          @finder.present?
+        end
+
+        def raise?
+          bang == true
+        end
+
+        protected
+          def match
+            case method.to_s
+              when /^find_(all_by|by)_([_a-zA-Z]\w*)$/
+                @finder = :all if $1 == 'all_by'
+                names = $2
+              when /^find_by_([_a-zA-Z]\w*)\!$/
+                @bang = true
+                names = $1
+              when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
+                @instantiator = $1 == 'initialize' ? :new : :create
+                names = $2
+              else
+                @finder = nil
+            end
+
+            @attributes = names && names.split('_and_')
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/embedded_document.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module EmbeddedDocument
+      def self.configure(model)
+        model.class_eval do
+          attr_accessor :_parent_document
+        end
+      end
+
+      module ClassMethods
+        def embeddable?
+          true
+        end
+
+        def embedded_in(owner_name)
+          define_method(owner_name) { _parent_document }
+        end
+      end
+
+      module InstanceMethods
+        def new?
+          _root_document.try(:new?) || @_new
+        end
+
+        def destroyed?
+          !!_root_document.try(:destroyed?)
+        end
+
+        def save(options={})
+          _root_document.try(:save, options).tap do |result|
+            @_new = false if result
+          end
+        end
+
+        def save!(options={})
+          _root_document.try(:save, options).tap do |result|
+            @_new = false if result
+          end
+        end
+
+        def _root_document
+          @_root_document ||= _parent_document.try(:_root_document)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/equality.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Equality
+      module InstanceMethods
+        def eql?(other)
+          other.is_a?(self.class) && _id == other._id
+        end
+        alias :== :eql?
+
+        def hash
+          _id.hash
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+require 'set'
+
+module MongoMapper
+  module Plugins
+    module IdentityMap
+      def self.models
+        @models ||= Set.new
+      end
+
+      def self.clear
+        models.each { |m| m.identity_map.clear }
+      end
+
+      def self.configure(model)
+        IdentityMap.models << model
+      end
+
+      module ClassMethods
+        def inherited(descendant)
+          descendant.identity_map = identity_map
+          super
+        end
+
+        def identity_map
+          @identity_map ||= {}
+        end
+
+        def identity_map=(v)
+          @identity_map = v
+        end
+
+        module IdentityMapQueryMethods
+          def all(opts={})
+            query = clone.update(opts)
+            super.tap do |docs|
+              model.remove_documents_from_map(docs) if query.fields?
+            end
+          end
+
+          def find_one(opts={})
+            query = clone.update(opts)
+
+            if model.identity_map_on? && query.simple? && model.identity_map[query[:_id]]
+              model.identity_map[query[:_id]]
+            else
+              super.tap do |doc|
+                model.remove_documents_from_map(doc) if query.fields?
+              end
+            end
+          end
+        end
+
+        def query(opts={})
+          super.extend(IdentityMapQueryMethods)
+        end
+
+        def remove_documents_from_map(*documents)
+          documents.flatten.compact.each do |document|
+            identity_map.delete(document['_id'])
+          end
+        end
+
+        def load(attrs)
+          return nil if attrs.nil?
+          document = identity_map[attrs['_id']]
+
+          if document.nil? || identity_map_off?
+            document = super
+            identity_map[document._id] = document if identity_map_on?
+          end
+
+          document
+        end
+
+        def identity_map_status
+          defined?(@identity_map_status) ? @identity_map_status : true
+        end
+
+        def identity_map_on
+          @identity_map_status = true
+        end
+
+        def identity_map_off
+          @identity_map_status = false
+        end
+
+        def identity_map_on?
+          identity_map_status
+        end
+
+        def identity_map_off?
+          !identity_map_on?
+        end
+
+        def without_identity_map(&block)
+          identity_map_off
+          yield
+        ensure
+          identity_map_on
+        end
+
+        private
+          def selecting_fields?(options)
+            !options[:fields].nil?
+          end
+      end
+
+      module InstanceMethods
+        def identity_map
+          self.class.identity_map
+        end
+
+        def save(*args)
+          if result = super
+            identity_map[_id] = self if self.class.identity_map_on?
+          end
+          result
+        end
+
+        def delete
+          identity_map.delete(_id) if self.class.identity_map_on?
+          super
+        end
+      end
+    end
+  end
+end