mongo_mapper-rails3 0.7.0.1

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -0,0 +1,87 @@
+module MongoMapper
+  module Plugins
+    module Callbacks
+      extend ActiveSupport::Concern
+      included do
+        extend ActiveModel::Callbacks
+
+        # Define all the callbacks that are accepted by the document.
+        define_model_callbacks \
+        :create,
+        :destroy,
+        :save,
+        :update,
+        :terminator => false
+        
+        define_callbacks :validation, :terminator => "result == false", :scope => [:kind, :name]
+
+        extend ValidationCallbacks
+
+        [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
+          alias_method_chain method, :callbacks
+        end
+      end
+        
+      module ValidationCallbacks
+        def before_validation(*args, &block)
+          options = args.extract_options!
+          options[:if] = Array(options[:if])
+          options[:if] << "@_on_validate == :#{options[:on]}" if options[:on]
+          set_callback(:validation, :before, *(args << options), &block)
+        end
+
+        def after_validation(*args, &block)
+          options = args.extract_options!
+          options[:prepend] = true
+          options[:if] = Array(options[:if])
+          options[:if] << "!halted && value != false"
+          options[:if] << "@_on_validate == :#{options[:on]}" if options[:on]
+          set_callback(:validation, :after, *(args << options), &block)
+        end
+      
+        def before_validation_on_what(what, *args, &block)
+          options = args.extract_options!
+          options[:on] = what
+          before_validation(*(args << options), &block)
+        end
+        
+        def before_validation_on_create(*args, &block); before_validation_on_what(:create, *args, &block); end
+        def before_validation_on_update(*args, &block); before_validation_on_what(:update, *args, &block); end
+      end
+
+      def create_or_update_with_callbacks(*args) #:nodoc:
+        _run_save_callbacks do
+          create_or_update_without_callbacks(*args)
+        end
+      end
+      private :create_or_update_with_callbacks
+
+      def create_with_callbacks(*args) #:nodoc:
+        _run_create_callbacks do
+          create_without_callbacks(*args)
+        end
+      end
+      private :create_with_callbacks
+
+      def update_with_callbacks(*args) #:nodoc:
+        _run_update_callbacks do
+          update_without_callbacks(*args)
+        end
+      end
+      private :update_with_callbacks
+
+      def valid_with_callbacks? #:nodoc:
+        @_on_validate = new_record? ? :create : :update
+        _run_validation_callbacks do
+          valid_without_callbacks?
+        end
+      end
+
+      def destroy_with_callbacks #:nodoc:
+        _run_destroy_callbacks do
+          destroy_without_callbacks
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/clone.rb

@@ -0,0 +1,14 @@
+module MongoMapper
+  module Plugins
+    module Clone
+      extend ActiveSupport::Concern
+      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,17 @@
+module MongoMapper
+  module Plugins
+    module Descendants
+      extend ActiveSupport::Concern
+      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 @@
+module MongoMapper
+  module Plugins
+    module Dirty
+      extend ActiveSupport::Concern
+      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/equality.rb

@@ -0,0 +1,24 @@
+module MongoMapper
+  module Plugins
+    module Equality
+      extend ActiveSupport::Concern
+      module InstanceMethods
+        def ==(other)
+          other.is_a?(self.class) && _id == other._id
+        end
+        
+        def eql?(other)
+          self == other
+        end
+        
+        def equal?(other)
+          object_id === other.object_id
+        end
+        
+        def hash
+          _id.hash
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -0,0 +1,124 @@
+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
+      
+      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
+
+        def find_one(options={})
+          criteria, query_options = to_query(options)
+
+          if simple_find?(criteria) && identity_map.key?(criteria[:_id])
+            identity_map[criteria[:_id]]
+          else
+            super.tap do |document|
+              remove_documents_from_map(document) if selecting_fields?(query_options)
+            end
+          end
+        end
+
+        def find_many(options)
+          criteria, query_options = to_query(options)
+          super.tap do |documents|
+            remove_documents_from_map(documents) if selecting_fields?(query_options)
+          end
+        end
+
+        def load(attrs)
+          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 remove_documents_from_map(*documents)
+            documents.flatten.compact.each do |document|
+              identity_map.delete(document._id)
+            end
+          end
+
+          def simple_find?(criteria)
+            criteria.keys == [:_id] || criteria.keys.to_set == [:_id, :_type].to_set
+          end
+
+          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

data/lib/mongo_mapper/plugins/inspect.rb

@@ -0,0 +1,15 @@
+module MongoMapper
+  module Plugins
+    module Inspect
+      extend ActiveSupport::Concern
+      module InstanceMethods
+        def inspect
+          attributes_as_nice_string = key_names.collect do |name|
+            "#{name}: #{self[name].inspect}"
+          end.join(", ")
+          "#<#{self.class} #{attributes_as_nice_string}>"
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/keys.rb

@@ -0,0 +1,310 @@
+module MongoMapper
+  module Plugins
+    module Keys
+      extend ActiveSupport::Concern
+      
+      def self.configure(model)
+        model.key :_id, ObjectId
+      end
+
+      module ClassMethods
+        def inherited(descendant)
+          descendant.instance_variable_set(:@keys, keys.dup)
+          super
+        end
+
+        def keys
+          @keys ||= HashWithIndifferentAccess.new
+        end
+
+        def key(*args)
+          key = Key.new(*args)
+          keys[key.name] = key
+
+          create_accessors_for(key)
+          create_key_in_descendants(*args)
+          create_indexes_for(key)
+          create_validations_for(key)
+
+          key
+        end
+
+        def using_object_id?
+          object_id_key?(:_id)
+        end
+
+        def object_id_key?(name)
+          key = keys[name.to_s]
+          key && key.type == ObjectId
+        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)
+          begin
+            klass = attrs['_type'].present? ? attrs['_type'].constantize : self
+            klass.new(attrs, true)
+          rescue NameError
+            new(attrs, true)
+          end
+        end
+
+        private
+          def accessors_module
+            module_defined =  if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
+                                const_defined?('MongoMapperKeys')
+                              else
+                                const_defined?('MongoMapperKeys', false)
+                              end
+
+            if 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_typecast
+                read_key_before_typecast(:#{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)
+            return if descendants.blank?
+            descendants.each { |descendant| descendant.key(*args) }
+          end
+
+          def create_indexes_for(key)
+            ensure_index key.name if key.options[:index] && !key.embeddable?
+          end
+
+          def create_validations_for(key)
+            attribute = key.name.to_sym
+
+            if key.options[:required]
+              validates_presence_of(attribute)
+            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, :within => key.options[:in])
+            end
+            if key.options[:within]
+              validates_inclusion_of(attribute, :within => key.options[:within])
+            end
+
+            if key.options[:not_in]
+              validates_exclusion_of(attribute, :within => 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
+
+      module InstanceMethods
+        def new?
+          @new
+        end
+
+        def attributes=(attrs)
+          return if attrs.blank?
+          
+          attrs.each_pair do |name, value|
+            writer_method = "#{name}="
+
+            if respond_to?(writer_method)
+              self.send(writer_method, value)
+            else
+              self[name.to_s] = value
+            end
+          end
+        end
+
+        def attributes
+          attrs = HashWithIndifferentAccess.new
+
+          keys.each_pair 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)
+              attrs[association.name] = documents.map { |document| document.to_mongo }
+            end
+          end
+
+          attrs
+        end
+        alias :to_mongo :attributes
+
+        def assign(attrs={})
+          self.attributes = attrs
+        end
+
+        def update_attributes(attrs={})
+          assign(attrs)
+          save
+        end
+
+        def update_attributes!(attrs={})
+          assign(attrs)
+          save!
+        end
+
+        def id
+          _id
+        end
+        
+        def id=(value)
+          if self.class.using_object_id?
+            value = MongoMapper.normalize_object_id(value)
+          end
+
+          self[:_id] = value
+        end
+
+        def [](name)
+          read_key(name)
+        end
+
+        def []=(name, value)
+          ensure_key_exists(name)
+          write_key(name, value)
+        end
+
+        # @api public
+        def keys
+          self.class.keys
+        end
+
+        # @api private?
+        def key_names
+          keys.keys
+        end
+
+        # @api private?
+        def non_embedded_keys
+          keys.values.select { |key| !key.embeddable? }
+        end
+
+        # @api private?
+        def embedded_keys
+          keys.values.select { |key| key.embeddable? }
+        end
+
+        private
+          def assign_type_if_present
+            self._type = self.class.name if respond_to?(:_type=)
+          end
+          
+          def ensure_key_exists(name)
+            self.class.key(name) unless respond_to?("#{name}=")
+          end
+
+          def read_key(name)
+            if key = keys[name]
+              var_name = "@#{name}"
+              value = key.get(instance_variable_get(var_name))
+              instance_variable_set(var_name, value)
+            else
+              raise KeyNotFound, "Could not find key: #{name.inspect}"
+            end
+          end
+
+          def read_key_before_typecast(name)
+            instance_variable_get("@#{name}_before_typecast")
+          end
+
+          def write_key(name, value)
+            key = keys[name]
+            instance_variable_set "@#{name}_before_typecast", value
+            instance_variable_set "@#{name}", key.set(value)
+          end
+      end
+      
+      class Key
+        attr_accessor :name, :type, :options, :default_value
+
+        def initialize(*args)
+          options = args.extract_options!
+          @name, @type = args.shift.to_s, args.shift
+          self.options = (options || {}).symbolize_keys
+          self.default_value = self.options.delete(:default)
+        end
+
+        def ==(other)
+          @name == other.name && @type == other.type
+        end
+
+        def embeddable?
+          type.respond_to?(:embeddable?) && type.embeddable? ? true : false
+        end
+
+        def number?
+          [Integer, Float].include?(type)
+        end
+
+        def get(value)
+          if value.nil? && !default_value.nil?
+            return default_value
+          end
+
+          type.from_mongo(value)
+        end
+
+        def set(value)
+          type.to_mongo(value)
+        end
+      end
+    end
+  end
+end