mongo_mapper 0.10.1 → 0.11.0

data/lib/mongo_mapper/plugins/persistence.rb

@@ -57,14 +57,12 @@ module MongoMapper
           end
       end
 
-      module InstanceMethods
-        def collection
-          _root_document.class.collection
-        end
+      def collection
+        _root_document.class.collection
+      end
 
-        def database
-          _root_document.class.database
-        end
+      def database
+        _root_document.class.database
       end
     end
   end

data/lib/mongo_mapper/plugins/protected.rb

@@ -23,25 +23,23 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def attributes=(attrs={})
-          super(filter_protected_attrs(attrs))
-        end
-
-        def update_attributes(attrs={})
-          super(filter_protected_attrs(attrs))
-        end
+      def attributes=(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
 
-        def update_attributes!(attrs={})
-          super(filter_protected_attrs(attrs))
-        end
+      def update_attributes(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
 
-        protected
-          def filter_protected_attrs(attrs)
-            return attrs if protected_attributes.blank? || attrs.blank?
-            attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
-          end
+      def update_attributes!(attrs={})
+        super(filter_protected_attrs(attrs))
       end
+
+      protected
+        def filter_protected_attrs(attrs)
+          return attrs if protected_attributes.blank? || attrs.blank?
+          attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
+        end
     end
   end
 end

data/lib/mongo_mapper/plugins/querying.rb

@@ -137,44 +137,42 @@ module MongoMapper
           end
       end
 
-      module InstanceMethods
-        def save(options={})
-          options.assert_valid_keys(:validate, :safe)
-          create_or_update(options)
-        end
+      def save(options={})
+        options.assert_valid_keys(:validate, :safe)
+        create_or_update(options)
+      end
 
-        def save!(options={})
-          options.assert_valid_keys(:safe)
-          save(options) || raise(DocumentNotValid.new(self))
-        end
+      def save!(options={})
+        options.assert_valid_keys(:safe)
+        save(options) || raise(DocumentNotValid.new(self))
+      end
 
-        def destroy
-          delete
-        end
+      def destroy
+        delete
+      end
 
-        def delete
-          self.class.delete(id).tap { @_destroyed = true } if persisted?
-        end
+      def delete
+        self.class.delete(id).tap { @_destroyed = true } if persisted?
+      end
 
-        private
-          def create_or_update(options={})
-            result = persisted? ? update(options) : create(options)
-            result != false
-          end
+      private
+        def create_or_update(options={})
+          result = persisted? ? update(options) : create(options)
+          result != false
+        end
 
-          def create(options={})
-            save_to_collection(options)
-          end
+        def create(options={})
+          save_to_collection(options)
+        end
 
-          def update(options={})
-            save_to_collection(options)
-          end
+        def update(options={})
+          save_to_collection(options)
+        end
 
-          def save_to_collection(options={})
-            @_new = false
-            collection.save(to_mongo, :safe => options[:safe])
-          end
-      end
+        def save_to_collection(options={})
+          @_new = false
+          collection.save(to_mongo, :safe => options[:safe])
+        end
     end
   end
 end

data/lib/mongo_mapper/plugins/rails.rb

@@ -2,36 +2,35 @@
 module MongoMapper
   module Plugins
     module Rails
+      autoload :ActiveRecordAssociationAdapter, "mongo_mapper/plugins/rails/active_record_association_adapter"
       extend ActiveSupport::Concern
 
-      module InstanceMethods
-        def to_param
-          id.to_s if persisted?
-        end
+      def to_param
+        id.to_s if persisted?
+      end
 
-        def to_model
-          self
-        end
+      def to_model
+        self
+      end
 
-        def to_key
-          [id] if persisted?
-        end
+      def to_key
+        [id] if persisted?
+      end
 
-        def new_record?
-          new?
-        end
+      def new_record?
+        new?
+      end
 
-        def read_attribute(name)
-          self[name]
-        end
+      def read_attribute(name)
+        self[name]
+      end
 
-        def read_attribute_before_type_cast(name)
-          read_key_before_type_cast(name)
-        end
+      def read_attribute_before_type_cast(name)
+        read_key_before_type_cast(name)
+      end
 
-        def write_attribute(name, value)
-          self[name] = value
-        end
+      def write_attribute(name, value)
+        self[name] = value
       end
 
       module ClassMethods
@@ -46,6 +45,13 @@ module MongoMapper
         def column_names
           keys.keys
         end
+
+        # Returns returns an ActiveRecordAssociationAdapter for an association. This adapter has an API that is a
+        # subset of ActiveRecord::Reflection::AssociationReflection. This allows MongoMapper to be used with the
+        # association helpers in gems like simple_form and formtastic.
+        def reflect_on_association(name)
+          ActiveRecordAssociationAdapter.for_association(associations[name]) if associations[name]
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/rails/active_record_association_adapter.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Rails
+      class ActiveRecordAssociationAdapter
+        attr_reader :klass, :macro, :name, :options
+
+        def self.for_association(association)
+          macro = case association
+          when MongoMapper::Plugins::Associations::BelongsToAssociation
+            :belongs_to
+          when MongoMapper::Plugins::Associations::ManyAssociation
+            :has_many
+          when MongoMapper::Plugins::Associations::OneAssociation
+            :has_one
+          else
+            raise "no #{name} for association of type #{association.class}"
+          end
+
+          new(association, macro)
+        end
+
+        def initialize(association, macro)
+          @klass, @name = association.klass, association.name
+          # only include compatible options
+          @options = association.options.slice(:conditions, :order)
+
+          @macro = macro
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/safe.rb

@@ -19,11 +19,9 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def save_to_collection(options={})
-          options[:safe] = self.class.safe? unless options.key?(:safe)
-          super
-        end
+      def save_to_collection(options={})
+        options[:safe] = self.class.safe? unless options.key?(:safe)
+        super
       end
     end
   end

data/lib/mongo_mapper/plugins/sci.rb

@@ -27,11 +27,9 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def initialize(*args)
-          super
-          write_key :_type, self.class.name if self.class.key?(:_type)
-        end
+      def initialize(*args)
+        super
+        write_key :_type, self.class.name if self.class.key?(:_type)
       end
     end
   end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -13,77 +13,74 @@ module MongoMapper
         self.include_root_in_json = false
       end
 
-      module InstanceMethods
-        def serializable_attributes
-          attributes.keys.map { |k| k.to_s } + ['id'] - ['_id']
-        end
-
-        def serializable_hash(options = nil)
-          options ||= {}
+      def serializable_attributes
+        attributes.keys.map { |k| k.to_s } + ['id'] - ['_id']
+      end
 
-          options[:only]   = Array.wrap(options[:only]).map { |k| k.to_s }
-          options[:except] = Array.wrap(options[:except]).map { |k| k.to_s }
+      def serializable_hash(options = nil)
+        options ||= {}
 
-          attribute_names = serializable_attributes
+        options[:only]   = Array.wrap(options[:only]).map { |k| k.to_s }
+        options[:except] = Array.wrap(options[:except]).map { |k| k.to_s }
 
-          if options[:only].any?
-            attribute_names &= options[:only]
-          elsif options[:except].any?
-            attribute_names -= options[:except]
-          end
+        attribute_names = serializable_attributes
 
-          attribute_names += Array.wrap(options[:methods]).map { |m| m.to_s }.select do |method|
-            respond_to?(method)
-          end
+        if options[:only].any?
+          attribute_names &= options[:only]
+        elsif options[:except].any?
+          attribute_names -= options[:except]
+        end
 
-          hash = attribute_names.sort.inject({}) do |hash, name|
-            value = send(name)
-            hash[name] = if value.is_a?(Array)
-              value.map {|v| v.respond_to?(:serializable_hash) ? v.serializable_hash : v }
-            elsif value.respond_to?(:serializable_hash)
-              value.serializable_hash
-            else
-              value
-            end
-            hash
-          end
+        attribute_names += Array.wrap(options[:methods]).map { |m| m.to_s }.select do |method|
+          respond_to?(method)
+        end
 
-          serializable_add_includes(options) do |association, records, opts|
-            hash[association.to_s] = records.is_a?(Array) ?
-              records.map { |r| r.serializable_hash(opts) } :
-              records.serializable_hash(opts)
+        hash = attribute_names.sort.inject({}) do |hash, name|
+          value = send(name)
+          hash[name] = if value.is_a?(Array)
+            value.map {|v| v.respond_to?(:serializable_hash) ? v.serializable_hash : v }
+          elsif value.respond_to?(:serializable_hash)
+            value.serializable_hash
+          else
+            value
           end
-
           hash
         end
 
-        def to_xml(options = {}, &block)
-          XmlSerializer.new(self, options).serialize(&block)
+        serializable_add_includes(options) do |association, records, opts|
+          hash[association.to_s] = records.is_a?(Array) ?
+            records.map { |r| r.serializable_hash(opts) } :
+            records.serializable_hash(opts)
         end
 
-      private
+        hash
+      end
 
-        def serializable_add_includes(options = {})
-          return unless include_associations = options.delete(:include)
+      def to_xml(options = {}, &block)
+        XmlSerializer.new(self, options).serialize(&block)
+      end
 
-          base_only_or_except = { :except => options[:except],
-                                  :only => options[:only] }
+    private
 
-          include_has_options = include_associations.is_a?(Hash)
-          associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
+      def serializable_add_includes(options = {})
+        return unless include_associations = options.delete(:include)
 
-          associations.each do |association|
-            records = get_proxy(self.class.associations[association])
-            unless records.nil?
-              association_options = include_has_options ? include_associations[association] : base_only_or_except
-              opts = options.merge(association_options)
-              yield(association, records, opts)
-            end
-          end
+        base_only_or_except = { :except => options[:except],
+                                :only => options[:only] }
+
+        include_has_options = include_associations.is_a?(Hash)
+        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
 
-          options[:include] = include_associations
+        associations.each do |association|
+          records = get_proxy(self.class.associations[association])
+          unless records.nil?
+            association_options = include_has_options ? include_associations[association] : base_only_or_except
+            opts = options.merge(association_options)
+            yield(association, records, opts)
+          end
         end
 
+        options[:include] = include_associations
       end
 
       module ClassMethods

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -12,12 +12,10 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def update_timestamps
-          now = Time.now.utc
-          self[:created_at] = now if !persisted? && !created_at?
-          self[:updated_at] = now
-        end
+      def update_timestamps
+        now = Time.now.utc
+        self[:created_at] = now if !persisted? && !created_at?
+        self[:updated_at] = now
       end
     end
   end

data/lib/mongo_mapper/plugins/validations.rb

@@ -17,16 +17,14 @@ module MongoMapper
         end
       end
 
-      module InstanceMethods
-        def save(options = {})
-          options.reverse_merge!(:validate => true)
-          !options[:validate] || valid? ? super : false
-        end
+      def save(options = {})
+        options.reverse_merge!(:validate => true)
+        !options[:validate] || valid? ? super : false
+      end
 
-        def valid?(context = nil)
-          context ||= (new_record? ? :create : :update)
-          super(context)
-        end
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super(context)
       end
 
       class UniquenessValidator < ::ActiveModel::EachValidator
@@ -68,7 +66,7 @@ module MongoMapper
 
       class AssociatedValidator < ::ActiveModel::EachValidator
         def validate_each(record, attribute, value)
-          if !Array.wrap(value).all? { |c| c.nil? || c.valid? }
+          if !Array.wrap(value).all? { |c| c.nil? || c.valid?(options[:context]) }
             record.errors.add(attribute, :invalid, :message => options[:message], :value => value)
           end
         end