lookout-mongo_mapper 0.11.3

data/lib/mongo_mapper/plugins/embedded_callbacks.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module EmbeddedCallbacks
+      extend ActiveSupport::Concern
+
+      included do
+        extend  ::ActiveModel::Callbacks
+
+        define_model_callbacks :save, :create, :update, :destroy, :only => [:before, :after]
+        define_model_callbacks :touch, :only => [:after]
+
+        embedded_callbacks_on
+      end
+
+      module ClassMethods
+        def embedded_callbacks_on
+          @embedded_callbacks_status = true
+        end
+
+        def embedded_callbacks_off
+          @embedded_callbacks_status = false
+        end
+
+        def embedded_callbacks_on?
+          @embedded_callbacks_status == true
+        end
+
+        def embedded_callbacks_off?
+          !embedded_callbacks_on?
+        end
+      end
+
+      def run_callbacks(callback, *args, &block)
+
+        if self.class.embedded_callbacks_on?
+          embedded_docs = []
+
+          embedded_associations.each do |association|
+            embedded_docs += Array(get_proxy(association).send(:load_target))
+          end
+
+          block = embedded_docs.inject(block) do |chain, doc|
+            if doc.class.respond_to?("_#{callback}_callbacks")
+              lambda { doc.run_callbacks(callback, *args, &chain) }
+            else
+              chain
+            end
+          end
+        end
+
+        super callback, *args, &block
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/embedded_document.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module EmbeddedDocument
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :_parent_document
+      end
+
+      module ClassMethods
+        def embeddable?
+          true
+        end
+
+        def embedded_in(owner_name)
+          alias_method owner_name, :_parent_document
+        end
+      end
+
+      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|
+          persist(options) if result
+        end
+      end
+
+      def save!(options={})
+        valid? || raise(DocumentNotValid.new(self))
+        _root_document.try(:save!, options).tap do |result|
+          persist(options) if result
+        end
+      end
+
+      def persist(options={})
+        @_new = false
+        clear_changes if respond_to?(:clear_changes)
+        save_to_collection(options)
+      end
+
+      def _root_document
+        @_root_document ||= _parent_document.try(:_root_document)
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/equality.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Equality
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def ===(other)
+          other.is_a?(self)
+        end
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && _id == other._id
+      end
+      alias :== :eql?
+
+      def hash
+        _id.hash
+      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
+      extend ActiveSupport::Concern
+
+      def self.models
+        @models ||= Set.new
+      end
+
+      def self.clear
+        models.each { |m| m.identity_map.clear }
+      end
+
+      included do
+        IdentityMap.models << self
+      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.amend(opts)
+            super.tap do |docs|
+              model.remove_documents_from_map(docs) if query.fields?
+            end
+          end
+
+          def find_one(opts={})
+            query = clone.amend(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
+
+      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

data/lib/mongo_mapper/plugins/indexes.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Indexes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        extend Forwardable
+        def_delegators :collection, :ensure_index, :create_index, :drop_index, :drop_indexes
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/inspect.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Inspect
+      extend ActiveSupport::Concern
+
+      def inspect(include_nil = false)
+        keys = include_nil ? key_names : attributes.keys
+        attributes_as_nice_string = keys.sort.collect do |name|
+          "#{name}: #{self.send(:"#{name}").inspect}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/keys.rb

@@ -0,0 +1,313 @@
+# encoding: UTF-8
+require 'mongo_mapper/plugins/keys/key'
+
+module MongoMapper
+  module Plugins
+    module Keys
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveSupport::DescendantsTracker
+        key :_id, ObjectId, :default => lambda { BSON::ObjectId.new }
+      end
+
+      module ClassMethods
+        def inherited(descendant)
+          descendant.instance_variable_set(:@keys, keys.dup)
+          super
+        end
+
+        def keys
+          @keys ||= {}
+        end
+
+        def key(*args)
+          Key.new(*args).tap do |key|
+            keys[key.name] = key
+            create_accessors_for(key)
+            create_key_in_descendants(*args)
+            create_indexes_for(key)
+            create_validations_for(key)
+          end
+        end
+
+        def key?(key)
+          keys.keys.include?(key.to_s)
+        end
+
+        def using_object_id?
+          object_id_key?(:_id)
+        end
+
+        def object_id_keys
+          keys.keys.select { |key| keys[key].type == ObjectId }.map { |k| k.to_sym }
+        end
+
+        def object_id_key?(name)
+          object_id_keys.include?(name.to_sym)
+        end
+
+        def to_mongo(instance)
+          return nil if instance.nil?
+          instance.to_mongo
+        end
+
+        def from_mongo(value)
+          return nil if value.nil?
+          value.is_a?(self) ? value : load(value)
+        end
+
+        # load is overridden in identity map to ensure same objects are loaded
+        def load(attrs)
+          return nil if attrs.nil?
+          begin
+            attrs['_type'].present? ? attrs['_type'].constantize : self
+          rescue NameError
+            self
+          end.allocate.initialize_from_database(attrs)
+        end
+
+        private
+          def key_accessors_module_defined?
+            if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
+              const_defined?('MongoMapperKeys')
+            else
+              const_defined?('MongoMapperKeys', false)
+            end
+          end
+
+          def accessors_module
+            if key_accessors_module_defined?
+              const_get 'MongoMapperKeys'
+            else
+              const_set 'MongoMapperKeys', Module.new
+            end
+          end
+
+          def create_accessors_for(key)
+            accessors_module.module_eval <<-end_eval
+              def #{key.name}
+                read_key(:#{key.name})
+              end
+
+              def #{key.name}_before_type_cast
+                read_key_before_type_cast(:#{key.name})
+              end
+
+              def #{key.name}=(value)
+                write_key(:#{key.name}, value)
+              end
+
+              def #{key.name}?
+                read_key(:#{key.name}).present?
+              end
+            end_eval
+
+            include accessors_module
+          end
+
+          def create_key_in_descendants(*args)
+            descendants.each { |descendant| descendant.key(*args) }
+          end
+
+          def create_indexes_for(key)
+            if key.options[:index] && !key.embeddable?
+              warn "[DEPRECATION] :index option when defining key #{key.name.inspect} is deprecated. Put indexes in `db/indexes.rb`"
+              ensure_index key.name
+            end
+          end
+
+          def create_validations_for(key)
+            attribute = key.name.to_sym
+
+            if key.options[:required]
+              if key.type == Boolean
+                validates_inclusion_of attribute, :in => [true, false]
+              else
+                validates_presence_of(attribute)
+              end
+            end
+
+            if key.options[:unique]
+              validates_uniqueness_of(attribute)
+            end
+
+            if key.options[:numeric]
+              number_options = key.type == Integer ? {:only_integer => true} : {}
+              validates_numericality_of(attribute, number_options)
+            end
+
+            if key.options[:format]
+              validates_format_of(attribute, :with => key.options[:format])
+            end
+
+            if key.options[:in]
+              validates_inclusion_of(attribute, :in => key.options[:in])
+            end
+
+            if key.options[:not_in]
+              validates_exclusion_of(attribute, :in => key.options[:not_in])
+            end
+
+            if key.options[:length]
+              length_options = case key.options[:length]
+              when Integer
+                {:minimum => 0, :maximum => key.options[:length]}
+              when Range
+                {:within => key.options[:length]}
+              when Hash
+                key.options[:length]
+              end
+              validates_length_of(attribute, length_options)
+            end
+          end
+      end
+
+      def initialize(attrs={})
+        @_new = true
+        self.attributes = attrs
+      end
+
+      def initialize_from_database(attrs={})
+        @_new = false
+        load_from_database(attrs)
+        self
+      end
+
+      def persisted?
+        !new? && !destroyed?
+      end
+
+      def attributes=(attrs)
+        return if attrs.blank?
+
+        attrs.each_pair do |key, value|
+          if respond_to?(:"#{key}=")
+            self.send(:"#{key}=", value)
+          else
+            self[key] = value
+          end
+        end
+      end
+
+      def attributes
+        HashWithIndifferentAccess.new.tap do |attrs|
+          keys.select { |name,key| !self[key.name].nil? || key.type == ObjectId }.each do |name, key|
+            value = key.set(self[key.name])
+            attrs[name] = value
+          end
+
+          embedded_associations.each do |association|
+            if documents = instance_variable_get(association.ivar)
+              if association.is_a?(Associations::OneAssociation)
+                attrs[association.name] = documents.to_mongo
+              else
+                attrs[association.name] = documents.map { |document| document.to_mongo }
+              end
+            end
+          end
+        end
+      end
+      alias :to_mongo :attributes
+
+      def assign(attrs={})
+        warn "[DEPRECATION] #assign is deprecated, use #attributes="
+        self.attributes = attrs
+      end
+
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+      end
+
+      def update_attributes!(attrs={})
+        self.attributes = attrs
+        save!
+      end
+
+      def update_attribute(name, value)
+        self.send(:"#{name}=", value)
+        save(:validate => false)
+      end
+
+      def id
+        _id
+      end
+
+      def id=(value)
+        if self.class.using_object_id?
+          value = ObjectId.to_mongo(value)
+        end
+
+        self[:_id] = value
+      end
+
+      def [](name)
+        read_key(name)
+      end
+
+      def []=(name, value)
+        ensure_key_exists(name)
+        write_key(name, value)
+      end
+
+      def keys
+        self.class.keys
+      end
+
+      def key_names
+        keys.keys
+      end
+
+      def non_embedded_keys
+        keys.values.select { |key| !key.embeddable? }
+      end
+
+      def embedded_keys
+        keys.values.select { |key| key.embeddable? }
+      end
+
+      private
+        def load_from_database(attrs)
+          return if attrs.blank?
+          attrs.each do |key, value|
+            if respond_to?(:"#{key}=") && !self.class.key?(key)
+              self.send(:"#{key}=", value)
+            else
+              self[key] = value
+            end
+          end
+        end
+
+        def ensure_key_exists(name)
+          self.class.key(name) unless respond_to?("#{name}=")
+        end
+
+        def set_parent_document(key, value)
+          if key.embeddable? && value.is_a?(key.type)
+            value._parent_document = self
+          end
+        end
+
+        def read_key(key_name)
+          if key = keys[key_name.to_s]
+            value = key.get(instance_variable_get(:"@#{key_name}"))
+            set_parent_document(key, value)
+            instance_variable_set(:"@#{key_name}", value)
+          end
+        end
+
+        def read_key_before_type_cast(name)
+          instance_variable_get(:"@#{name}_before_type_cast")
+        end
+
+        def write_key(name, value)
+          key = keys[name.to_s]
+          set_parent_document(key, value)
+          instance_variable_set :"@#{name}_before_type_cast", value
+          instance_variable_set :"@#{name}", key.set(value)
+        end
+    end
+  end
+end
+