mongo_mapper_ign 0.7.4 → 0.7.6

data/lib/mongo_mapper/plugins/inspect.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Inspect

data/lib/mongo_mapper/plugins/keys.rb

@@ -1,6 +1,9 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Keys
+      autoload :Key, 'mongo_mapper/plugins/keys/key'
+
       def self.configure(model)
         model.key :_id, ObjectId
       end
@@ -17,15 +20,13 @@ module MongoMapper
         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
+          Key.new(*args).tap do |key|
+            keys[key.name] = key
+            create_accessors_for(key)
+            create_key_in_descendants(*args)
+            create_indexes_for(key)
+            create_validations_for(key)
+          end
         end
 
         def key?(key)
@@ -36,9 +37,12 @@ module MongoMapper
           object_id_key?(:_id)
         end
 
+        def object_id_keys
+          keys.keys.select { |key| keys[key].type == ObjectId }.map(&:to_sym)
+        end
+
         def object_id_key?(name)
-          key = keys[name.to_s]
-          key && key.type == ObjectId
+          object_id_keys.include?(name.to_sym)
         end
 
         def to_mongo(instance)
@@ -53,6 +57,7 @@ module MongoMapper
 
         # load is overridden in identity map to ensure same objects are loaded
         def load(attrs)
+          return nil if attrs.nil?
           begin
             klass = attrs['_type'].present? ? attrs['_type'].constantize : self
             klass.new(attrs, true)
@@ -62,14 +67,16 @@ module MongoMapper
         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
+          def key_accessors_module_defined?
+            if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
+              const_defined?('MongoMapperKeys')
+            else
+              const_defined?('MongoMapperKeys', false)
+            end
+          end
 
-            if module_defined
+          def accessors_module
+            if key_accessors_module_defined?
               const_get 'MongoMapperKeys'
             else
               const_set 'MongoMapperKeys', Module.new
@@ -154,7 +161,7 @@ module MongoMapper
 
           if from_database
             @new = false
-            self.attributes = attrs
+            load_from_database(attrs)
           else
             @new = true
             assign(attrs)
@@ -170,13 +177,11 @@ module MongoMapper
         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)
+          attrs.each_pair do |key, value|
+            if respond_to?(:"#{key}=")
+              self.send(:"#{key}=", value)
             else
-              self[name.to_s] = value
+              self[key] = value
             end
           end
         end
@@ -255,6 +260,17 @@ module MongoMapper
         end
 
         private
+          def load_from_database(attrs)
+            return if attrs.blank?
+            attrs.each do |key, value|
+              if respond_to?(:"#{key}=") && !self.class.key?(key)
+                self.send(:"#{key}=", value)
+              else
+                self[key] = value
+              end
+            end
+          end
+
           def default_id_value(attrs)
             unless attrs.nil?
               provided_keys = attrs.keys.map { |k| k.to_s }
@@ -278,68 +294,29 @@ module MongoMapper
             end
           end
 
-          def read_key(name)
-            if key = keys[name]
-              var_name = "@#{name}"
-              value = key.get(instance_variable_get(var_name))
+          def read_key(key_name)
+            if key = keys[key_name]
+              value = key.get(instance_variable_get(:"@#{key_name}"))
               set_parent_document(key, value)
-              instance_variable_set(var_name, value)
+              instance_variable_set(:"@#{key_name}", value)
             else
-              raise KeyNotFound, "Could not find key: #{name.inspect}"
+              raise KeyNotFound, "Could not find key: #{key_name.inspect}"
             end
           end
 
           def read_key_before_typecast(name)
-            instance_variable_get("@#{name}_before_typecast")
+            instance_variable_get(:"@#{name}_before_typecast")
           end
 
           def write_key(name, value)
-            key = keys[name]
-
+            key = keys[name.to_s]
             set_parent_document(key, value)
-            instance_variable_set "@#{name}_before_typecast", value
-            instance_variable_set "@#{name}", key.set(value)
+            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?
-            if default_value.respond_to?(:call)
-              return default_value.call
-            else
-              return default_value
-            end
-          end
-
-          type.from_mongo(value)
-        end
-
-        def set(value)
-          type.to_mongo(value)
-        end
-      end
     end
   end
 end

data/lib/mongo_mapper/plugins/keys/key.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Keys
+      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[: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?
+            if default_value.respond_to?(:call)
+              return default_value.call
+            else
+              return default_value
+            end
+          end
+
+          type.from_mongo(value)
+        end
+
+        def set(value)
+          type.to_mongo(value).tap do |values|
+            if options[:typecast].present?
+              values.map! { |v| typecast_class.to_mongo(v) }
+            end
+          end
+        end
+        
+        private
+          def typecast_class
+            options[:typecast].constantize
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/logger.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Logger

data/lib/mongo_mapper/plugins/modifiers.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Modifiers
@@ -14,7 +15,11 @@ module MongoMapper
         end
 
         def set(*args)
-          modifier_update('$set', args)
+          criteria, updates = criteria_and_keys_from_args(args)
+          updates.each do |key, value|
+            updates[key] = keys[key].set(value) if key?(key)
+          end
+          collection.update(criteria, {'$set' => updates}, :multi => true)
         end
 
         def unset(*args)
@@ -25,7 +30,7 @@ module MongoMapper
             criteria = {:id => ids}
           end
 
-          criteria  = to_criteria(criteria)
+          criteria  = query(criteria).criteria.to_hash
           modifiers = keys.inject({}) { |hash, key| hash[key] = 1; hash }
           collection.update(criteria, {'$unset' => modifiers}, :multi => true)
         end
@@ -57,14 +62,14 @@ module MongoMapper
 
         private
           def modifier_update(modifier, args)
-            criteria, keys = criteria_and_keys_from_args(args)
-            collection.update(criteria, {modifier => keys}, :multi => true)
+            criteria, updates = criteria_and_keys_from_args(args)
+            collection.update(criteria, {modifier => updates}, :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]
+            [query(criteria).criteria.to_hash, keys]
           end
       end
 

data/lib/mongo_mapper/plugins/pagination.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Pagination

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

@@ -1,9 +1,10 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Pagination
       class Proxy
         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,11 +51,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/persistence.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Persistence

data/lib/mongo_mapper/plugins/protected.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Protected

data/lib/mongo_mapper/plugins/rails.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Rails

data/lib/mongo_mapper/plugins/serialization.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require 'active_support/json'
 
 module MongoMapper
@@ -6,7 +7,7 @@ module MongoMapper
       def self.configure(model)
         model.class_eval { cattr_accessor :include_root_in_json, :instance_writer => true }
       end
-      
+
       module InstanceMethods
         def to_xml(options = {}, &block)
           options[:dasherize] = false unless options.has_key?(:dasherize)
@@ -49,7 +50,7 @@ module MongoMapper
             }
           end
           # End rip
-          
+
           options.delete(:only) if options[:only].nil? or options[:only].empty?
 
           hash.each do |key, value|
@@ -63,7 +64,7 @@ module MongoMapper
               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

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Timestamps
@@ -8,7 +9,7 @@ module MongoMapper
           class_eval { before_save :update_timestamps }
         end
       end
-      
+
       module InstanceMethods
         def update_timestamps
           now = Time.now.utc

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Userstamps

data/lib/mongo_mapper/plugins/validations.rb

@@ -1,16 +1,17 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Validations
       def self.configure(model)
         model.class_eval { include Validatable }
       end
-      
+
       module DocumentMacros
         def validates_uniqueness_of(*args)
           add_validations(args, MongoMapper::Plugins::Validations::ValidatesUniquenessOf)
         end
       end
-      
+
       class ValidatesUniquenessOf < Validatable::ValidationBase
         option :scope, :case_sensitive
         default :case_sensitive => true

data/lib/mongo_mapper/query.rb

@@ -1,143 +1,24 @@
+# encoding: UTF-8
 module MongoMapper
-  # IMPORTANT
-  # This class is private to MongoMapper and should not be considered part of MongoMapper's public API.
-  #
   class Query
-    OptionKeys = [:fields, :select, :skip, :offset, :limit, :sort, :order]
-
-    attr_reader :model
-
-    def initialize(model, options)
+    def initialize(model, options={})
       raise ArgumentError, "Options must be a hash" unless options.is_a?(Hash)
-      @model, @options, @conditions, @original_options = model, {}, {}, options
-      separate_options_and_conditions
+      @model, @options, @conditions = model, {}, {}
+      query.update(options)
       add_sci_condition
     end
 
-    def criteria
-      to_criteria(@conditions)
-    end
-
-    def options
-      fields = @options[:fields] || @options[:select]
-      skip   = @options[:skip]   || @options[:offset] || 0
-      limit  = @options[:limit]  || 0
-      sort   = @options[:sort]   || normalized_sort(@options[:order])
-
-      {:fields => to_fields(fields), :skip => skip.to_i, :limit => limit.to_i, :sort => sort}
-    end
-
-    def to_a
-      [criteria, options]
-    end
-
     private
-      def separate_options_and_conditions
-        @original_options.each_pair do |key, value|
-          key = key.respond_to?(:to_sym) ? key.to_sym : key
-
-          if OptionKeys.include?(key)
-            @options[key] = value
-          elsif key == :conditions
-            @conditions.update(value)
-          else
-            @conditions[key] = value
-          end
-        end
+      def method_missing(method, *args, &block)
+        query.send(method, *args, &block)
       end
 
-      # adds _type single collection inheritance scope for models that need it
-      def add_sci_condition
-        @conditions[:_type] = model.to_s if model.single_collection_inherited?
+      def query
+        @query ||= Plucky::Query.new(@model.collection).object_ids(@model.object_id_keys)
       end
 
-      def modifier?(field)
-        field.to_s =~ /^\$/
-      end
-
-      def symbol_operator?(object)
-        object.respond_to?(:field, :operator)
-      end
-
-      def to_criteria(conditions, parent_key=nil)
-        criteria = {}
-
-        conditions.each_pair do |key, value|
-          key = normalized_key(key)
-
-          if model.object_id_key?(key)
-            case value
-              when String
-                value = ObjectId.to_mongo(value)
-              when Array
-                value.map! { |id| ObjectId.to_mongo(id) }
-            end
-          end
-
-          if symbol_operator?(key)
-            key, value = normalized_key(key.field), {"$#{key.operator}" => value}
-          end
-
-          criteria[key] = normalized_value(criteria, key, value)
-        end
-
-        criteria
-      end
-
-      def to_fields(keys)
-        return keys if keys.is_a?(Hash)
-        return nil  if keys.blank?
-
-        if keys.respond_to?(:flatten, :compact)
-          keys.flatten.compact
-        else
-          keys.split(',').map { |key| key.strip }
-        end
-      end
-
-      def to_order(key, direction=nil)
-        [normalized_key(key).to_s, normalized_direction(direction)]
-      end
-
-      def normalized_key(key)
-        key.to_s == 'id' ? :_id : key
-      end
-
-      # TODO: this is getting heavy enough to move to a class
-      def normalized_value(criteria, key, value)
-        case value
-          when Array, Set
-            modifier?(key) ? value.to_a : {'$in' => value.to_a}
-          when Hash
-            if criteria[key].kind_of?(Hash)
-              criteria[key].dup.merge(to_criteria(value, key))
-            else
-              to_criteria(value, key)
-            end
-          when Time
-            value.utc
-          else
-            value
-        end
-      end
-
-      def normalized_direction(direction)
-        direction ||= 'asc'
-        direction.downcase == 'asc' ? Mongo::ASCENDING : Mongo::DESCENDING
-      end
-
-      def normalized_sort(sort)
-        return if sort.blank?
-
-        if sort.respond_to?(:all?) && sort.all? { |s| symbol_operator?(s) }
-          sort.map { |s| to_order(s.field, s.operator) }
-        elsif symbol_operator?(sort)
-          [to_order(sort.field, sort.operator)]
-        else
-          sort.split(',').map do |str|
-            to_order(*str.strip.split(' '))
-          end
-        end
+      def add_sci_condition
+        query[:_type] = @model.to_s if @model.single_collection_inherited?
       end
   end
 end