djsun-mongomapper 0.3.5.5 → 0.4.1.2

data/lib/mongomapper/finder_options.rb

@@ -1,85 +1,85 @@
-module MongoMapper
-  class FinderOptions
-    attr_reader :options
-    
-    def self.to_mongo_criteria(conditions, parent_key=nil)
-      criteria = {}
-      conditions.each_pair do |field, value|
-        case value
-          when Array
-            operator_present = field.to_s =~ /^\$/            
-            criteria[field] = if operator_present
-                                value
-                              else
-                                {'$in' => value}
-                              end
-          when Hash
-            criteria[field] = to_mongo_criteria(value, field)
-          else            
-            criteria[field] = value
-        end
-      end
-      
-      criteria
-    end
-        
-    def self.to_mongo_options(options)
-      options = options.dup
-      {
-        :fields => to_mongo_fields(options.delete(:fields) || options.delete(:select)),
-        :offset => (options.delete(:offset) || 0).to_i,
-        :limit  => (options.delete(:limit) || 0).to_i,
-        :sort   => options.delete(:sort) || to_mongo_sort(options.delete(:order))
-      }
-    end
-    
-    def initialize(options)
-      raise ArgumentError, "FinderOptions must be a hash" unless options.is_a?(Hash)
-      @options = options.symbolize_keys
-      @conditions = @options.delete(:conditions) || {}
-    end
-    
-    def criteria
-      self.class.to_mongo_criteria(@conditions)
-    end
-    
-    def options
-      self.class.to_mongo_options(@options)
-    end
-    
-    def to_a
-      [criteria, options]
-    end
-    
-    private
-      def self.to_mongo_fields(fields)
-        return if fields.blank?
-      
-        if fields.is_a?(String)
-          fields.split(',').map { |field| field.strip }
-        else
-          fields.flatten.compact
-        end
-      end
-    
-      def self.to_mongo_sort(sort)
-        return if sort.blank?
-        pieces = sort.split(',')
-        pairs  = pieces.map { |s| to_mongo_sort_piece(s) }
-      
-        hash = OrderedHash.new
-        pairs.each do |pair|
-          field, sort_direction = pair
-          hash[field] = sort_direction
-        end
-        hash.symbolize_keys
-      end
-    
-      def self.to_mongo_sort_piece(str)
-        field, direction = str.strip.split(' ')
-        direction ||= 'ASC'
-        direction = direction.upcase == 'ASC' ? 1 : -1
-        [field, direction]
-      end
-  end
+module MongoMapper
+  class FinderOptions
+    attr_reader :options
+    
+    def self.to_mongo_criteria(conditions, parent_key=nil)
+      criteria = {}
+      conditions.each_pair do |field, value|
+        case value
+          when Array
+            operator_present = field.to_s =~ /^\$/            
+            criteria[field] = if operator_present
+                                value
+                              else
+                                {'$in' => value}
+                              end
+          when Hash
+            criteria[field] = to_mongo_criteria(value, field)
+          else            
+            criteria[field] = value
+        end
+      end
+      
+      criteria
+    end
+        
+    def self.to_mongo_options(options)
+      options = options.dup
+      {
+        :fields => to_mongo_fields(options.delete(:fields) || options.delete(:select)),
+        :skip   => (options.delete(:skip) || 0).to_i,
+        :limit  => (options.delete(:limit) || 0).to_i,
+        :sort   => options.delete(:sort) || to_mongo_sort(options.delete(:order))
+      }
+    end
+    
+    def initialize(options)
+      raise ArgumentError, "FinderOptions must be a hash" unless options.is_a?(Hash)
+      @options = options.symbolize_keys
+      @conditions = @options.delete(:conditions) || {}
+    end
+    
+    def criteria
+      self.class.to_mongo_criteria(@conditions)
+    end
+    
+    def options
+      self.class.to_mongo_options(@options)
+    end
+    
+    def to_a
+      [criteria, options]
+    end
+    
+    private
+      def self.to_mongo_fields(fields)
+        return if fields.blank?
+      
+        if fields.is_a?(String)
+          fields.split(',').map { |field| field.strip }
+        else
+          fields.flatten.compact
+        end
+      end
+    
+      def self.to_mongo_sort(sort)
+        return if sort.blank?
+        pieces = sort.split(',')
+        pairs  = pieces.map { |s| to_mongo_sort_piece(s) }
+      
+        hash = OrderedHash.new
+        pairs.each do |pair|
+          field, sort_direction = pair
+          hash[field] = sort_direction
+        end
+        hash.symbolize_keys
+      end
+    
+      def self.to_mongo_sort_piece(str)
+        field, direction = str.strip.split(' ')
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [field, direction]
+      end
+  end
 end

data/lib/mongomapper/key.rb

@@ -1,76 +1,32 @@
-module MongoMapper
-  class Key
-    # DateTime and Date are currently not supported by mongo's bson so just use Time
-    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash]
-
-    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 set(value)
-      typecast(value)
-    end
-
-    def native?
-      @native ||= NativeTypes.include?(type) || type.nil?
-    end
-
-    def embedded_document?
-      type.respond_to?(:embeddable?) && type.embeddable?
-    end
-
-    def get(value)
-      return default_value if value.nil? && !default_value.nil?
-      if type == Array
-        value || []
-      elsif type == Hash
-        HashWithIndifferentAccess.new(value || {})
-      else
-        value
-      end
-    end
-
-    private
-      def typecast(value)
-        return value if type.nil?
-        return HashWithIndifferentAccess.new(value) if value.is_a?(Hash) && type == Hash
-        return value.utc if type == Time && value.kind_of?(type)
-        return value if value.kind_of?(type) || value.nil?
-        begin
-          if    type == String    then value.to_s
-          elsif type == Float     then value.to_f
-          elsif type == Array     then value.to_a
-          elsif type == Time      then Time.parse(value.to_s).utc
-          elsif type == Boolean   then Boolean.mm_typecast(value)
-          elsif type == Integer
-            # ganked from datamapper
-            value_to_i = value.to_i
-            if value_to_i == 0
-              value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
-            else
-              value_to_i
-            end
-          elsif embedded_document?
-            typecast_embedded_document(value)
-          else
-            value
-          end
-        rescue
-          value
-        end
-      end
-
-      def typecast_embedded_document(value)
-        value.is_a?(type) ? value : type.new(value)
-      end
-  end
-end
+module MongoMapper
+  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 set(value)
+      type.to_mongo(value)
+    end
+
+    def embeddable?
+      type.respond_to?(:embeddable?) && type.embeddable? ? true : false
+    end
+
+    def get(value)
+      if value.nil? && !default_value.nil?
+        return default_value
+      end
+      
+      type.from_mongo(value)
+    end
+  end
+end

data/lib/mongomapper/rails_compatibility/document.rb

@@ -1,15 +1,15 @@
-module MongoMapper
-  module RailsCompatibility
-    module Document
-      def self.included(model)
-        model.class_eval do
-          alias_method :new_record?, :new?
-        end
-      end
-
-      def to_param
-        id
-      end
-    end
-  end
+module MongoMapper
+  module RailsCompatibility
+    module Document
+      def self.included(model)
+        model.class_eval do
+          alias_method :new_record?, :new?
+        end
+      end
+            
+      def to_param
+        id
+      end
+    end
+  end
 end

data/lib/mongomapper/rails_compatibility/embedded_document.rb

@@ -1,25 +1,27 @@
-module MongoMapper
-  module RailsCompatibility
-    module EmbeddedDocument
-      def self.included(model)
-        model.class_eval do
-          extend ClassMethods
-        end
-
-        class << model
-          alias has_many many
-        end
-      end
-
-      module ClassMethods
-        def column_names
-          keys.keys
-        end
-      end
-
-      def to_param
-        raise "Missing to_param method in #{self.class}. You should implement it to return the unique identifier of this embedded document within a document."
-      end
-    end
-  end
+module MongoMapper
+  module RailsCompatibility
+    module EmbeddedDocument
+      def self.included(model)
+        model.class_eval do
+          extend ClassMethods
+          
+          alias_method :new_record?, :new?
+        end
+
+        class << model
+          alias has_many many
+        end
+      end
+
+      module ClassMethods
+        def column_names
+          keys.keys
+        end
+      end
+
+      def to_param
+        raise "Missing to_param method in #{self.class}. You should implement it to return the unique identifier of this embedded document within a document."
+      end
+    end
+  end
 end

data/lib/mongomapper/support.rb

@@ -1,30 +1,157 @@
-class BasicObject #:nodoc:
-  instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|instance_eval|proxy_|^object_id$)/ }
-end unless defined?(BasicObject)
-
-class Boolean
-  def self.mm_typecast(value)
-    ['true', 't', '1'].include?(value.to_s.downcase)
-  end
-end
-
-class Object
-  # The hidden singleton lurks behind everyone
-  def metaclass
-    class << self; self end
-  end
-
-  def meta_eval(&blk)
-    metaclass.instance_eval(&blk)
-  end
-
-  # Adds methods to a metaclass
-  def meta_def(name, &blk)
-    meta_eval { define_method(name, &blk) }
-  end
-
-  # Defines an instance method within a class
-  def class_def(name, &blk)
-    class_eval { define_method(name, &blk) }
-  end
+class BasicObject #:nodoc:
+  instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|^methods$|instance_eval|proxy_|^object_id$)/ }
+end unless defined?(BasicObject)
+
+class Array
+  def self.to_mongo(value)
+    value.to_a
+  end
+  
+  def self.from_mongo(value)
+    value || []
+  end
+end
+
+class Binary
+  def self.to_mongo(value)
+    if value.is_a?(ByteBuffer)
+      value
+    else
+      ByteBuffer.new(value)
+    end
+  end
+  
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class Boolean
+  def self.to_mongo(value)
+    if value.is_a?(Boolean)
+      value
+    else
+      ['true', 't', '1'].include?(value.to_s.downcase)
+    end
+  end
+  
+  def self.from_mongo(value)
+    !!value
+  end
+end
+
+class Date
+  def self.to_mongo(value)
+    date = Date.parse(value.to_s)
+    Time.utc(date.year, date.month, date.day)
+  rescue
+    nil
+  end
+  
+  def self.from_mongo(value)
+    value.to_date if value.present?
+  end
+end
+
+class Float
+  def self.to_mongo(value)
+    value.to_f
+  end
+end
+
+class Hash
+  def self.from_mongo(value)
+    HashWithIndifferentAccess.new(value || {})
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+class Integer
+  def self.to_mongo(value)
+    value_to_i = value.to_i
+    if value_to_i == 0
+      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
+    else
+      value_to_i
+    end
+  end
+end
+
+class NilClass
+  def to_mongo(value)
+    value
+  end
+  
+  def from_mongo(value)
+    value
+  end
+end
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass
+    class << self; self end
+  end
+
+  def meta_eval(&blk)
+    metaclass.instance_eval(&blk)
+  end
+
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method(name, &blk) }
+  end
+
+  # Defines an instance method within a class
+  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
+end
+
+class String
+  def self.to_mongo(value)
+    value.nil? ? nil : value.to_s
+  end
+  
+  def self.from_mongo(value)
+    value.present? ? value : nil
+  end
+end
+
+class Time
+  def self.to_mongo(value)
+    to_utc_time(value)
+  end
+  
+  def self.from_mongo(value)
+    if Time.respond_to?(:zone) && Time.zone && value.present?
+      value.in_time_zone(Time.zone)
+    else
+      value
+    end
+  end
+  
+  def self.to_utc_time(value)
+    to_local_time(value).try(:utc)
+  end
+  
+  # make sure we have a time and that it is local
+  def self.to_local_time(value)
+    if Time.respond_to?(:zone) && Time.zone
+      Time.zone.parse(value.to_s)
+    else
+      Time.parse(value.to_s)
+    end
+  end
 end