mongo_mapper 0.7.5 → 0.7.6

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

@@ -0,0 +1,44 @@
+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.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/modifiers.rb

@@ -14,7 +14,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 +29,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 +61,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/proxy.rb

@@ -3,7 +3,7 @@ module MongoMapper
     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 +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/serialization.rb

@@ -6,7 +6,7 @@ module MongoMapper
       def self.configure(model)
         model.class_eval { cattr_accessor :include_root_in_json, :instance_writer => true }
       end
-      
+
       module InstanceMethods
         def as_json options={}
           options ||= {}
@@ -43,7 +43,7 @@ module MongoMapper
             }
           end
           # End rip
-          
+
           options.delete(:only) if options[:only].nil? or options[:only].empty?
 
           hash.each do |key, value|
@@ -57,7 +57,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

@@ -8,7 +8,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/validations.rb

@@ -4,13 +4,13 @@ module MongoMapper
       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,23 @@
 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

data/lib/mongo_mapper/support.rb

@@ -3,7 +3,7 @@ class Array
     value = value.respond_to?(:lines) ? value.lines : value
     value.to_a
   end
-  
+
   def self.from_mongo(value)
     value || []
   end
@@ -28,7 +28,7 @@ class Boolean
     true => true, 'true' => true, 'TRUE' => true, 'True' => true, 't' => true, 'T' => true, '1' => true, 1 => true, 1.0 => true,
     false => false, 'false' => false, 'FALSE' => false, 'False' => false, 'f' => false, 'F' => false, '0' => false, 0 => false, 0.0 => false, nil => nil
   }
-  
+
   def self.to_mongo(value)
     if value.is_a?(Boolean)
       value
@@ -53,7 +53,7 @@ class Date
   rescue
     nil
   end
-  
+
   def self.from_mongo(value)
     value.to_date if value.present?
   end
@@ -61,7 +61,7 @@ end
 
 class Float
   def self.to_mongo(value)
-    value.to_f
+    value.nil? ? nil : value.to_f
   end
 end
 
@@ -69,7 +69,7 @@ class Hash
   def self.from_mongo(value)
     HashWithIndifferentAccess.new(value || {})
   end
-  
+
   def to_mongo
     self
   end
@@ -90,7 +90,7 @@ class NilClass
   def to_mongo(value)
     value
   end
-  
+
   def from_mongo(value)
     value
   end
@@ -115,11 +115,11 @@ class Object
   def class_def(name, &blk)
     class_eval { define_method(name, &blk) }
   end
-  
+
   def self.to_mongo(value)
     value
   end
-  
+
   def self.from_mongo(value)
     value
   end
@@ -127,15 +127,9 @@ end
 
 class ObjectId
   def self.to_mongo(value)
-    if value.blank?
-      nil
-    elsif value.is_a?(BSON::ObjectID)
-      value
-    else
-      BSON::ObjectID.from_string(value.to_s)
-    end
+    Plucky.to_object_id(value)
   end
-  
+
   def self.from_mongo(value)
     value
   end
@@ -145,7 +139,7 @@ class Set
   def self.to_mongo(value)
     value.to_a
   end
-  
+
   def self.from_mongo(value)
     Set.new(value || [])
   end
@@ -155,28 +149,12 @@ class String
   def self.to_mongo(value)
     value.nil? ? nil : value.to_s
   end
-  
+
   def self.from_mongo(value)
     value.nil? ? nil : value.to_s
   end
 end
 
-class SymbolOperator
-  attr_reader :field, :operator
-
-  def initialize(field, operator, options={})
-    @field, @operator = field, operator
-  end unless method_defined?(:initialize)
-end
-
-class Symbol
-  %w(gt lt gte lte ne in nin mod all size where exists asc desc).each do |operator|
-    define_method(operator) do
-      SymbolOperator.new(self, operator)
-    end unless method_defined?(operator)
-  end
-end
-
 class Time
   def self.to_mongo(value)
     if value.nil? || value == ''
@@ -184,11 +162,11 @@ class Time
     else
       time_class = Time.try(:zone).present? ? Time.zone : Time
       time = value.is_a?(Time) ? value : time_class.parse(value.to_s)
-      # Convert time to milliseconds since BSON stores dates with that accurracy, but Ruby uses microseconds
-      Time.at((time.to_f * 1000).round / 1000.0).utc if time
+      # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
+      at(time.to_i).utc if time
     end
   end
-  
+
   def self.from_mongo(value)
     if Time.try(:zone).present? && value.present?
       value.in_time_zone(Time.zone)
@@ -200,11 +178,11 @@ end
 
 class BSON::ObjectID
   alias_method :original_to_json, :to_json
-  
+
   def as_json(options=nil)
     to_s
   end
-  
+
   def to_json(options = nil)
     as_json.to_json
   end