mongo_mapper 0.8.6 → 0.9.0

data/lib/mongo_mapper/plugins/rails.rb

@@ -2,9 +2,7 @@
 module MongoMapper
   module Plugins
     module Rails
-      def self.configure(model)
-        model.extend ActiveModel::Naming if defined?(ActiveModel)
-      end
+      extend ActiveSupport::Concern
 
       module InstanceMethods
         def to_param
@@ -27,8 +25,8 @@ module MongoMapper
           self[name]
         end
 
-        def read_attribute_before_typecast(name)
-          read_key_before_typecast(name)
+        def read_attribute_before_type_cast(name)
+          read_key_before_type_cast(name)
         end
 
         def write_attribute(name, value)

data/lib/mongo_mapper/plugins/safe.rb

@@ -2,6 +2,8 @@
 module MongoMapper
   module Plugins
     module Safe
+      extend ActiveSupport::Concern
+
       module ClassMethods
         def inherited(subclass)
           super

data/lib/mongo_mapper/plugins/sci.rb

@@ -2,6 +2,8 @@
 module MongoMapper
   module Plugins
     module Sci
+      extend ActiveSupport::Concern
+
       module ClassMethods
         def inherited(subclass)
           key :_type, String unless key?(:_type)

data/lib/mongo_mapper/plugins/scopes.rb

@@ -2,6 +2,8 @@
 module MongoMapper
   module Plugins
     module Scopes
+      extend ActiveSupport::Concern
+
       module ClassMethods
         def scope(name, scope_options={})
           scopes[name] = lambda do |*args|

data/lib/mongo_mapper/plugins/serialization.rb

@@ -1,73 +1,94 @@
 # encoding: UTF-8
-require 'active_support/json'
+require 'active_model/serializers/json'
+require 'active_model/serializers/xml'
 
 module MongoMapper
   module Plugins
     module Serialization
-      def self.configure(model)
-        model.class_eval { cattr_accessor :include_root_in_json, :instance_writer => true }
+      extend ActiveSupport::Concern
+
+      included do
+        include ::ActiveModel::Serializers::JSON
+        include ::ActiveModel::Serializers::Xml
+        self.include_root_in_json = false
       end
 
       module InstanceMethods
-        def as_json options={}
+        def serializable_attributes
+          attributes.keys.map { |k| k.to_s } + ['id'] - ['_id']
+        end
+
+        def serializable_hash(options = nil)
           options ||= {}
-          unless options[:only]
-            methods = [options.delete(:methods)].flatten.compact
-            methods << :id
-            options[:methods] = methods.uniq
-          end
 
-          except = [options.delete(:except)].flatten.compact
-          except << :_id
-          options[:except] = except
+          options[:only]   = Array.wrap(options[:only]).map { |k| k.to_s }
+          options[:except] = Array.wrap(options[:except]).map { |k| k.to_s }
 
-          # Direct rip from Rails 3 ActiveModel Serialization (#serializable_hash)
-          hash = begin
-            options[:only]   = Array.wrap(options[:only]).map { |n| n.to_s }
-            options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+          attribute_names = serializable_attributes
 
-            attribute_names = attributes.keys.sort
-            if options[:only].any?
-              attribute_names &= options[:only]
-            elsif options[:except].any?
-              attribute_names -= options[:except]
-            end
+          if options[:only].any?
+            attribute_names &= options[:only]
+          elsif options[:except].any?
+            attribute_names -= options[:except]
+          end
 
-            method_names = Array.wrap(options[:methods]).inject([]) do |methods, name|
-              methods << name if respond_to?(name.to_s)
-              methods
+          attribute_names += Array.wrap(options[:methods]).map { |m| m.to_s }.select do |method|
+            respond_to?(method)
+          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 + method_names).inject({}) { |hash, name|
-              hash[name] = send(name)
-              hash
-            }
+          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
-          # End rip
-
-          options.delete(:only) if options[:only].nil? or options[:only].empty?
-
-          hash.each do |key, value|
-            if value.is_a?(Array)
-              hash[key] = value.map do |item|
-                item.respond_to?(:as_json) ? item.as_json(options) : item
-              end
-            elsif value.is_a? BSON::ObjectId
-              hash[key] = value.to_s
-            elsif value.respond_to?(:as_json)
-              hash[key] = value.as_json(options)
+
+          hash
+        end
+
+      private
+
+        def serializable_add_includes(options = {})
+          return unless include_associations = options.delete(:include)
+
+          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)
+
+          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
 
-          # Replicate Rails 3 naming - and also bin anytihng after : for use in our dynamic classes from unit tests
-          hash = { ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self.class.name)).gsub(/:.*/,'') => hash } if include_root_in_json
-          hash
+          options[:include] = include_associations
         end
+
       end
 
       module ClassMethods
         def from_json(json)
-          self.new(ActiveSupport::JSON.decode(json))
+          self.new.from_json(json)
+        end
+
+        def from_xml(xml)
+          self.new.from_xml(xml)
         end
       end
 

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -2,6 +2,8 @@
 module MongoMapper
   module Plugins
     module Timestamps
+      extend ActiveSupport::Concern
+
       module ClassMethods
         def timestamps!
           key :created_at, Time
@@ -13,7 +15,7 @@ module MongoMapper
       module InstanceMethods
         def update_timestamps
           now = Time.now.utc
-          self[:created_at] = now if new? && !created_at?
+          self[:created_at] = now if !persisted? && !created_at?
           self[:updated_at] = now
         end
       end

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -2,6 +2,8 @@
 module MongoMapper
   module Plugins
     module Userstamps
+      extend ActiveSupport::Concern
+
       module ClassMethods
         def userstamps!
           key :creator_id, ObjectId

data/lib/mongo_mapper/plugins/validations.rb

@@ -2,30 +2,44 @@
 module MongoMapper
   module Plugins
     module Validations
-      def self.configure(model)
-        model.class_eval do
-          include Validatable
-          extend Validations::DocumentMacros
+      extend ActiveSupport::Concern
+
+      include ::ActiveModel::Validations
+
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with UniquenessValidator, _merge_attributes(attr_names)
         end
-      end
 
-      module DocumentMacros
-        def validates_uniqueness_of(*args)
-          add_validations(args, Validations::ValidatesUniquenessOf)
+        def validates_associated(*attr_names)
+          validates_with AssociatedValidator, _merge_attributes(attr_names)
         end
       end
 
-      class ValidatesUniquenessOf < Validatable::ValidationBase
-        option :scope, :case_sensitive
-        default :case_sensitive => true
+      class UniquenessValidator < ::ActiveModel::EachValidator
+        def initialize(options)
+          super(options.reverse_merge(:case_sensitive => true))
+        end
+
+        def setup(klass)
+          @klass = klass
+        end
+
+        def validate_each(record, attribute, value)
+          conditions = scope_conditions(record)
 
-        def valid?(instance)
-          value = instance[attribute]
-          return allow_nil if value.nil? and not allow_nil.nil?
-          return allow_blank if value.blank? and not allow_blank.nil?
-          base_conditions = case_sensitive ? {self.attribute => value} : {}
-          doc = instance.class.first(base_conditions.merge(scope_conditions(instance)).merge(where_conditions(instance)))
-          doc.nil? || instance._id == doc._id
+          if options[:case_sensitive]
+            conditions[attribute] = value
+          else
+            conditions[attribute] = /^#{Regexp.escape(value.to_s)}$/i
+          end
+
+          # Make sure we're not including the current document in the query
+          conditions[:_id.ne] = record._id if record._id
+
+          if @klass.exists?(conditions)
+            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+          end
         end
 
         def message(instance)
@@ -33,18 +47,20 @@ module MongoMapper
         end
 
         def scope_conditions(instance)
-          return {} unless scope
-          Array(scope).inject({}) do |conditions, key|
+          Array(options[:scope] || []).inject({}) do |conditions, key|
             conditions.merge(key => instance[key])
           end
         end
+      end
 
-        def where_conditions(instance)
-          conditions = {}
-          conditions[attribute] = /^#{Regexp.escape(instance[attribute].to_s)}$/i unless case_sensitive
-          conditions
+      class AssociatedValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if !Array.wrap(value).all? { |c| c.nil? || c.valid? }
+            record.errors.add(attribute, :invalid, :default => options[:message], :value => value)
+          end
         end
       end
+
     end
   end
 end

data/lib/mongo_mapper/railtie.rb

@@ -0,0 +1,49 @@
+require "mongo_mapper"
+require "rails"
+require "active_model/railtie"
+
+module MongoMapper
+  # = MongoMapper Railtie
+  class Railtie < Rails::Railtie
+
+    config.mongo_mapper = ActiveSupport::OrderedOptions.new
+
+    rake_tasks do
+      load "mongo_mapper/railtie/database.rake"
+    end
+
+    initializer "mongo_mapper.set_configs" do |app|
+      ActiveSupport.on_load(:mongo_mapper) do
+        app.config.mongo_mapper.each do |k,v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    # This sets the database configuration and establishes the connection.
+    initializer "mongo_mapper.initialize_database" do |app|
+      config_file = Rails.root.join('config/mongo.yml')
+      if config_file.file?
+        config = YAML.load(ERB.new(config_file.read).result)
+        MongoMapper.setup(config, Rails.env, :logger => Rails.logger)
+      end
+    end
+
+    # Clear the identity map after each request
+    initializer "mongo_mapper.clear_identity_map" do |app|
+      app.config.middleware.use 'MongoMapper::Middleware::IdentityMap'
+    end
+
+    initializer "mongo_mapper.prepare_dispatcher" do |app|
+      # See http://groups.google.com/group/mongomapper/browse_thread/thread/68f62e8eda43b43a/4841dba76938290c
+      # to_prepare is called before each request in development mode and the first request in production.
+      ActionDispatch::Callbacks.to_prepare do
+        unless app.config.cache_classes
+          # Rails reloading was making descendants fill up and leak memory, these make sure they get cleared
+          ActiveSupport::DescendantsTracker.clear
+          MongoMapper::Plugins::IdentityMap.models.clear
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/railtie/database.rake

@@ -0,0 +1,60 @@
+namespace :db do
+
+  if not Rake::Task.task_defined?("db:drop")
+    desc 'Drops all the collections for the database for the current Rails.env'
+    task :drop => :environment do
+      MongoMapper.database.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:seed")
+    # if another ORM has defined db:seed, don't run it twice.
+    desc 'Load the seed data from db/seeds.rb'
+    task :seed => :environment do
+      seed_file = File.join(Rails.root, 'db', 'seeds.rb')
+      load(seed_file) if File.exist?(seed_file)
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:setup")
+    desc 'Create the database, and initialize with the seed data'
+    task :setup => [ 'db:create', 'db:seed' ]
+  end
+
+  if not Rake::Task.task_defined?("db:reseed")
+    desc 'Delete data and seed'
+    task :reseed => [ 'db:drop', 'db:seed' ]
+  end
+
+  if not Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        # noop
+      end
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare => :environment do
+        MongoMapper.connect('test')
+        MongoMapper.database.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+        MongoMapper.connect(Rails.env)
+      end
+    end
+  end
+end
+
+task 'test:prepare' => 'db:test:prepare'

data/lib/mongo_mapper/support/descendant_appends.rb

@@ -4,29 +4,29 @@ require 'set'
 module MongoMapper
   module Support
     module DescendantAppends
-      def included(model)
-        extra_extensions.each { |extension| model.extend(extension) }
-        extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
-        descendants << model
-      end
-
-      # @api public
-      def descendants
-        @descendants ||= Set.new
+      def included(model = nil, &block)
+        if model
+          extra_extensions.each { |extension| model.extend(extension) }
+          extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
+          direct_descendants << model
+        end
+        super
       end
 
       # @api public
       def append_extensions(*extensions)
+        warn "[DEPRECATED] append_extensions is deprecated. Use #plugin with a module that extends ActiveSupport::Concern."
         extra_extensions.concat(extensions)
-        descendants.each do |model|
+        direct_descendants.each do |model|
           extensions.each { |extension| model.extend(extension) }
         end
       end
 
       # @api public
       def append_inclusions(*inclusions)
+        warn "[DEPRECATED] append_inclusions is deprecated. Use #plugin with a module that extends ActiveSupport::Concern."
         extra_inclusions.concat(inclusions)
-        descendants.each do |model|
+        direct_descendants.each do |model|
           inclusions.each { |inclusion| model.send(:include, inclusion) }
         end
       end