mongo_mapper 0.7.0 → 0.7.1

data/lib/mongo_mapper/plugins/keys.rb

@@ -170,11 +170,14 @@ module MongoMapper
 
         def attributes=(attrs)
           return if attrs.blank?
-          
+
           attrs.each_pair do |name, value|
             writer_method = "#{name}="
 
             if respond_to?(writer_method)
+              if writer_method == '_root_document='
+                puts "_root_document= #{value.inspect}"
+              end
               self.send(writer_method, value)
             else
               self[name.to_s] = value
@@ -217,7 +220,7 @@ module MongoMapper
         def id
           _id
         end
-        
+
         def id=(value)
           if self.class.using_object_id?
             value = MongoMapper.normalize_object_id(value)
@@ -259,7 +262,7 @@ module MongoMapper
           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
@@ -280,11 +283,16 @@ module MongoMapper
 
           def write_key(name, value)
             key = keys[name]
+
+            if key.embeddable? && value.is_a?(key.type)
+              value._parent_document = self
+            end
+
             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
 
@@ -309,7 +317,11 @@ module MongoMapper
 
         def get(value)
           if value.nil? && !default_value.nil?
-            return default_value
+            if default_value.respond_to?(:call)
+              return default_value.call
+            else
+              return default_value
+            end
           end
 
           type.from_mongo(value)

data/lib/mongo_mapper/plugins/modifiers.rb

@@ -0,0 +1,87 @@
+module MongoMapper
+  module Plugins
+    module Modifiers
+      module ClassMethods
+        def increment(*args)
+          modifier_update('$inc', args)
+        end
+
+        def decrement(*args)
+          criteria, keys = criteria_and_keys_from_args(args)
+          values, to_decrement = keys.values, {}
+          keys.keys.each_with_index { |k, i| to_decrement[k] = -values[i].abs }
+          collection.update(criteria, {'$inc' => to_decrement}, :multi => true)
+        end
+
+        def set(*args)
+          modifier_update('$set', args)
+        end
+
+        def push(*args)
+          modifier_update('$push', args)
+        end
+
+        def push_all(*args)
+          modifier_update('$pushAll', args)
+        end
+
+        def push_uniq(*args)
+          criteria, keys = criteria_and_keys_from_args(args)
+          keys.each { |key, value | criteria[key] = {'$ne' => value} }
+          collection.update(criteria, {'$push' => keys}, :multi => true)
+        end
+
+        def pull(*args)
+          modifier_update('$pull', args)
+        end
+
+        def pull_all(*args)
+          modifier_update('$pullAll', args)
+        end
+
+        def pop(*args)
+          modifier_update('$pop', args)
+        end
+
+        private
+          def modifier_update(modifier, args)
+            criteria, keys = criteria_and_keys_from_args(args)
+            modifiers = {modifier => keys}
+            collection.update(criteria, modifiers, :multi => true)
+          end
+
+          def criteria_and_keys_from_args(args)
+            keys     = args.pop
+            criteria = args[0].is_a?(Hash) ? args[0] : {:id => args}
+            [to_criteria(criteria), keys]
+          end
+      end
+
+      module InstanceMethods
+        def increment(hash)
+          self.class.increment({:_id => id}, hash)
+        end
+
+        def decrement(hash)
+          self.class.decrement({:_id => id}, hash)
+        end
+
+        def set(hash)
+          self.class.set({:_id => id}, hash)
+        end
+
+        def push(hash)
+          self.class.push({:_id => id}, hash)
+        end
+
+        def pull(hash)
+          self.class.pull({:_id => id}, hash)
+        end
+
+        def push_uniq(hash)
+          self.class.push_uniq({:_id => id}, hash)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/pagination/proxy.rb

@@ -2,8 +2,8 @@ module MongoMapper
   module Plugins
     module Pagination
       class Proxy
-        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
-
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|respond_to\?|proxy_|^object_id$)/ }
+                
         attr_accessor :subject
         attr_reader :total_entries, :per_page, :current_page
         alias limit per_page
@@ -50,7 +50,11 @@ module MongoMapper
         def method_missing(name, *args, &block)
           @subject.send(name, *args, &block)
         end
-
+        
+        def respond_to?(name, *args, &block)
+          super || @subject.respond_to?(name, *args, &block)
+        end
+        
         private
           def per_page=(value)
             value = 25 if value.blank?

data/lib/mongo_mapper/plugins/protected.rb

@@ -37,7 +37,7 @@ module MongoMapper
         protected
           def filter_protected_attrs(attrs)
             return attrs if protected_attributes.blank?
-            attrs.dup.delete_if { |key, val| protected_attributes.include?(key) }
+            attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
           end
       end
     end

data/lib/mongo_mapper/plugins/rails.rb

@@ -1,41 +1,49 @@
 module MongoMapper
   module Plugins
     module Rails
+      def self.configure(model)
+        model.extend ActiveModel::Naming if defined?(ActiveModel)
+      end
+
       module InstanceMethods
         def to_param
           id.to_s
         end
-        
+
+        def to_model
+          self
+        end
+
         def new_record?
           new?
         end
-        
+
         def read_attribute(name)
           self[name]
         end
-        
+
         def read_attribute_before_typecast(name)
           read_key_before_typecast(name)
         end
-        
+
         def write_attribute(name, value)
           self[name] = value
         end
       end
-      
+
       module ClassMethods
         def has_one(*args)
           one(*args)
         end
-        
+
         def has_many(*args)
           many(*args)
         end
-        
+
         def column_names
           keys.keys
         end
-        
+
         def human_name
           self.name.demodulize.titleize
         end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -4,102 +4,72 @@ module MongoMapper
   module Plugins
     module Serialization
       def self.configure(model)
-        model.class_eval { include Json }
+        model.class_eval { cattr_accessor :include_root_in_json, :instance_writer => true }
       end
       
-      class Serializer
-        attr_reader :options
-
-        def initialize(record, options={})
-          @record, @options = record, options.dup
-        end
-
-        def serializable_key_names
-          key_names = @record.attributes.keys
-
-          if options[:only]
-            options.delete(:except)
-            key_names = key_names & Array(options[:only]).collect { |n| n.to_s }
-          else
-            options[:except] = Array(options[:except])
-            key_names = key_names - options[:except].collect { |n| n.to_s }
-          end
-
-          key_names
-        end
-
-        def serializable_method_names
-          Array(options[:methods]).inject([]) do |method_attributes, name|
-            method_attributes << name if @record.respond_to?(name.to_s)
-            method_attributes
+      module InstanceMethods
+        def as_json options={}
+          options ||= {}
+          unless options[:only]
+            methods = [options.delete(:methods)].flatten.compact
+            methods << :id
+            options[:methods] = methods.uniq
           end
-        end
 
-        def serializable_names
-          serializable_key_names + serializable_method_names
-        end
+          except = [options.delete(:except)].flatten.compact
+          except << :_id
+          options[:except] = except
 
-        def serializable_record
-          returning(serializable_record = {}) do
-            serializable_names.each { |name| serializable_record[name] = @record.send(name) }
-          end
-        end
+          # 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 }
 
-        def serialize
-          # overwrite to implement
-        end
+            attribute_names = attributes.keys.sort
+            if options[:only].any?
+              attribute_names &= options[:only]
+            elsif options[:except].any?
+              attribute_names -= options[:except]
+            end
 
-        def to_s(&block)
-          serialize(&block)
-        end
-      end
-      
-      module Json
-        def self.included(base)
-          base.cattr_accessor :include_root_in_json, :instance_writer => false
-          base.extend ClassMethods
-        end
+            method_names = Array.wrap(options[:methods]).inject([]) do |methods, name|
+              methods << name if respond_to?(name.to_s)
+              methods
+            end
 
-        module ClassMethods
-          def json_class_name
-            @json_class_name ||= name.demodulize.underscore.inspect
+            (attribute_names + method_names).inject({}) { |hash, name|
+              hash[name] = send(name)
+              hash
+            }
           end
-        end
-
-        def to_json(options={})
-          apply_to_json_defaults(options)
-
-          if include_root_in_json
-            "{#{self.class.json_class_name}: #{JsonSerializer.new(self, options).to_s}}"
-          else
-            JsonSerializer.new(self, options).to_s
+          # 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? Mongo::ObjectID
+              hash[key] = value.to_s
+            elsif value.respond_to?(:as_json)
+              hash[key] = value.as_json(options)
+            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)).gsub(/:.*/,'') => hash } if include_root_in_json
+          hash
         end
+      end
 
+      module ClassMethods
         def from_json(json)
-          self.attributes = ActiveSupport::JSON.decode(json)
-          self
+          self.new(ActiveSupport::JSON.decode(json))
         end
-
-        class JsonSerializer < Serializer
-          def serialize
-            serializable_record.to_json
-          end
-        end
-
-        private
-          def apply_to_json_defaults(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
-          end
       end
+
     end
   end
 end

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -0,0 +1,21 @@
+module MongoMapper
+  module Plugins
+    module Timestamps
+      module ClassMethods
+        def timestamps!
+          key :created_at, Time
+          key :updated_at, Time
+          class_eval { before_save :update_timestamps }
+        end
+      end
+      
+      module InstanceMethods
+        def update_timestamps
+          now = Time.now.utc
+          self[:created_at] = now if new? && !created_at?
+          self[:updated_at] = now
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -0,0 +1,14 @@
+module MongoMapper
+  module Plugins
+    module Userstamps
+      module ClassMethods
+        def userstamps!
+          key :creator_id, ObjectId
+          key :updater_id, ObjectId
+          belongs_to :creator, :class_name => 'User'
+          belongs_to :updater, :class_name => 'User'
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/query.rb

@@ -93,7 +93,7 @@ module MongoMapper
       def to_order(field, direction=nil)
         direction ||= 'ASC'
         direction = direction.upcase == 'ASC' ? 1 : -1
-        [field.to_s, direction]
+        [normalized_key(field).to_s, direction]
       end
 
       def normalized_key(field)

data/lib/mongo_mapper/version.rb

@@ -0,0 +1,3 @@
+module MongoMapper
+  Version = '0.7.1'
+end