mongo_mapper-rails3 0.7.0.1 → 0.7.2

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -1,87 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,310 +0,0 @@
-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