mongo_mapper-unstable 2010.1.6 → 2010.1.12

data/lib/mongo_mapper/plugins/keys.rb

@@ -0,0 +1,295 @@
+module MongoMapper
+  module Plugins
+    module Keys
+      module ClassMethods
+        def inherited(descendant)
+          descendant.instance_variable_set(:@keys, keys.dup)
+          super
+        end
+
+        def keys
+          @keys ||= HashWithIndifferentAccess.new
+        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
+        end
+
+        def using_object_id?
+          object_id_key?(:_id)
+        end
+
+        def object_id_key?(name)
+          key = keys[name.to_s]
+          key && key.type == ObjectId
+        end
+
+        def to_mongo(instance)
+          return nil if instance.nil?
+          instance.to_mongo
+        end
+
+        def from_mongo(value)
+          return nil if value.nil?
+          value.is_a?(self) ? value : load(value)
+        end
+
+        def load(attrs)
+          begin
+            klass = attrs['_type'].present? ? attrs['_type'].constantize : self
+            doc = klass.new(attrs)
+            doc.instance_variable_set("@new", false)
+            doc
+          rescue NameError
+            doc = new(attrs)
+            doc.instance_variable_set("@new", false)
+            doc
+          end
+        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
+
+            if module_defined
+              const_get 'MongoMapperKeys'
+            else
+              const_set 'MongoMapperKeys', Module.new
+            end
+          end
+
+          def create_accessors_for(key)
+            accessors_module.module_eval <<-end_eval
+              def #{key.name}
+                read_key(:#{key.name})
+              end
+
+              def #{key.name}_before_typecast
+                read_key_before_typecast(:#{key.name})
+              end
+
+              def #{key.name}=(value)
+                write_key(:#{key.name}, value)
+              end
+
+              def #{key.name}?
+                read_key(:#{key.name}).present?
+              end
+            end_eval
+
+            include accessors_module
+          end
+
+          def create_key_in_descendants(*args)
+            return if descendants.blank?
+            descendants.each { |descendant| descendant.key(*args) }
+          end
+
+          def create_indexes_for(key)
+            ensure_index key.name if key.options[:index] && !key.embeddable?
+          end
+
+          def create_validations_for(key)
+            attribute = key.name.to_sym
+
+            if key.options[:required]
+              validates_presence_of(attribute)
+            end
+
+            if key.options[:unique]
+              validates_uniqueness_of(attribute)
+            end
+
+            if key.options[:numeric]
+              number_options = key.type == Integer ? {:only_integer => true} : {}
+              validates_numericality_of(attribute, number_options)
+            end
+
+            if key.options[:format]
+              validates_format_of(attribute, :with => key.options[:format])
+            end
+
+            if key.options[:length]
+              length_options = case key.options[:length]
+              when Integer
+                {:minimum => 0, :maximum => key.options[:length]}
+              when Range
+                {:within => key.options[:length]}
+              when Hash
+                key.options[:length]
+              end
+              validates_length_of(attribute, length_options)
+            end
+          end
+      end
+      
+      module InstanceMethods
+        def self.included(model)
+          model.key :_id, ObjectId
+        end
+        
+        def initialize(attrs={})
+          unless attrs.nil?
+            provided_keys = attrs.keys.map { |k| k.to_s }
+            unless provided_keys.include?('_id') || provided_keys.include?('id')
+              write_key :_id, Mongo::ObjectID.new
+            end
+          end
+          
+          @new = true
+          self._type = self.class.name if respond_to?(:_type=)
+          self.attributes = attrs
+        end
+        
+        def new?
+          @new
+        end
+        
+        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)
+            else
+              self[name.to_s] = value
+            end
+          end
+        end
+
+        def attributes
+          attrs = HashWithIndifferentAccess.new
+
+          keys.each_pair do |name, key|
+            value = key.set(self[key.name])
+            attrs[name] = value
+          end
+
+          embedded_associations.each do |association|
+            if documents = instance_variable_get(association.ivar)
+              attrs[association.name] = documents.map { |document| document.to_mongo }
+            end
+          end
+
+          attrs
+        end
+        alias :to_mongo :attributes
+        
+        def id
+          _id
+        end
+        
+        def id=(value)
+          if self.class.using_object_id?
+            value = MongoMapper.normalize_object_id(value)
+          end
+
+          self[:_id] = value
+        end
+
+        def [](name)
+          read_key(name)
+        end
+
+        def []=(name, value)
+          ensure_key_exists(name)
+          write_key(name, value)
+        end
+
+        # @api public
+        def keys
+          self.class.keys
+        end
+
+        # @api private?
+        def key_names
+          keys.keys
+        end
+
+        # @api private?
+        def non_embedded_keys
+          keys.values.select { |key| !key.embeddable? }
+        end
+
+        # @api private?
+        def embedded_keys
+          keys.values.select { |key| key.embeddable? }
+        end
+
+        private
+          def ensure_key_exists(name)
+            self.class.key(name) unless respond_to?("#{name}=")
+          end
+
+          def read_key(name)
+            if key = keys[name]
+              var_name = "@#{name}"
+              value = key.get(instance_variable_get(var_name))
+              instance_variable_set(var_name, value)
+            else
+              raise KeyNotFound, "Could not find key: #{name.inspect}"
+            end
+          end
+
+          def read_key_before_typecast(name)
+            instance_variable_get("@#{name}_before_typecast")
+          end
+
+          def write_key(name, value)
+            key = keys[name]
+            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?
+            return default_value
+          end
+
+          type.from_mongo(value)
+        end
+
+        def set(value)
+          type.to_mongo(value)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/logger.rb

@@ -0,0 +1,17 @@
+module MongoMapper
+  module Plugins
+    module Logger
+      module ClassMethods
+        def logger
+          MongoMapper.logger
+        end
+      end
+
+      module InstanceMethods
+        def logger
+          self.class.logger
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/pagination.rb

@@ -0,0 +1,85 @@
+module MongoMapper
+  module Plugins
+    module Pagination
+      module ClassMethods
+        def per_page
+          25
+        end
+        
+        def paginate(options)
+          per_page      = options.delete(:per_page) || self.per_page
+          page          = options.delete(:page)
+          total_entries = count(options)
+          pagination    = Pagination::PaginationProxy.new(total_entries, page, per_page)
+
+          options.merge!(:limit => pagination.limit, :skip => pagination.skip)
+          pagination.subject = find_every(options)
+          pagination
+        end
+      end
+      
+      class PaginationProxy
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+        attr_accessor :subject
+        attr_reader :total_entries, :per_page, :current_page
+        alias limit per_page
+
+        def initialize(total_entries, current_page, per_page=nil)
+          @total_entries    = total_entries.to_i
+          self.per_page     = per_page
+          self.current_page = current_page
+        end
+
+        def total_pages
+          (total_entries / per_page.to_f).ceil
+        end
+
+        def out_of_bounds?
+          current_page > total_pages
+        end
+
+        def previous_page
+          current_page > 1 ? (current_page - 1) : nil
+        end
+
+        def next_page
+          current_page < total_pages ? (current_page + 1) : nil
+        end
+
+        def skip
+          (current_page - 1) * per_page
+        end
+        alias offset skip # for will paginate support
+
+        def send(method, *args, &block)
+          if respond_to?(method)
+            super
+          else
+            subject.send(method, *args, &block)
+          end
+        end
+
+        def ===(other)
+          other === subject
+        end
+
+        def method_missing(name, *args, &block)
+          @subject.send(name, *args, &block)
+        end
+
+        private
+          def per_page=(value)
+            value = 25 if value.blank?
+            @per_page = value.to_i
+          end
+
+          def current_page=(value)
+            value = value.to_i
+            value = 1 if value < 1
+            @current_page = value
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/rails.rb

@@ -0,0 +1,45 @@
+module MongoMapper
+  module Plugins
+    module Rails
+      module InstanceMethods
+        def to_param
+          id.to_s
+        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
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -0,0 +1,109 @@
+require 'active_support/json'
+
+module MongoMapper
+  module Plugins
+    module Serialization
+      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
+          end
+        end
+
+        def serializable_names
+          serializable_key_names + serializable_method_names
+        end
+
+        def serializable_record
+          returning(serializable_record = {}) do
+            serializable_names.each { |name| serializable_record[name] = @record.send(name) }
+          end
+        end
+
+        def serialize
+          # overwrite to implement
+        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
+
+        module ClassMethods
+          def json_class_name
+            @json_class_name ||= name.demodulize.underscore.inspect
+          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
+        end
+
+        def from_json(json)
+          self.attributes = ActiveSupport::JSON.decode(json)
+          self
+        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
+      
+      module InstanceMethods
+        def self.included(model)
+          model.class_eval do
+            include Json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/validations.rb

@@ -0,0 +1,48 @@
+module MongoMapper
+  module Plugins
+    module Validations
+      module InstanceMethods
+        def self.included(model)
+          model.class_eval { include Validatable }
+        end
+      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
+
+        def valid?(instance)
+          value = instance[attribute]
+          return true if allow_blank && value.blank?
+          return true if allow_nil && value.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
+        end
+
+        def message(instance)
+          super || "has already been taken"
+        end
+
+        def scope_conditions(instance)
+          return {} unless scope
+          Array(scope).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+
+        def where_conditions(instance)
+          conditions = {}
+          conditions[attribute] = /#{instance[attribute].to_s}/i unless case_sensitive
+          conditions
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins.rb

@@ -0,0 +1,19 @@
+module MongoMapper
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+    
+    def plugin(mod)
+      if mod.const_defined?(:ClassMethods)
+        extend mod::ClassMethods
+      end
+      
+      if mod.const_defined?(:InstanceMethods)
+        include mod::InstanceMethods
+      end
+      
+      plugins << mod
+    end
+  end
+end

data/lib/mongo_mapper/support.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 class Array
   def self.to_mongo(value)
     value = value.respond_to?(:lines) ? value.lines : value
@@ -26,11 +24,18 @@ class Binary
 end
 
 class Boolean
+  BOOLEAN_MAPPING = {
+    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 => false
+  }
+  
   def self.to_mongo(value)
     if value.is_a?(Boolean)
       value
     else
-      ['true', 't', '1'].include?(value.to_s.downcase)
+      v = BOOLEAN_MAPPING[value]
+      v = value.to_s.downcase == 'true' if v.nil? # Check all mixed case spellings for true
+      v
     end
   end
 
@@ -41,8 +46,12 @@ end
 
 class Date
   def self.to_mongo(value)
-    date = Date.parse(value.to_s)
-    Time.utc(date.year, date.month, date.day)
+    if value.nil? || value == ''
+      nil
+    else
+      date = value.is_a?(Date) || value.is_a?(Time) ? value : Date.parse(value.to_s)
+      Time.utc(date.year, date.month, date.day)
+    end
   rescue
     nil
   end
@@ -71,7 +80,7 @@ end
 class Integer
   def self.to_mongo(value)
     value_to_i = value.to_i
-    if value_to_i == 0
+    if value_to_i == 0 && value != value_to_i
       value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
     else
       value_to_i
@@ -154,15 +163,26 @@ class String
   end
 end
 
-class Symbol
-  %w{gt lt gte lte ne in nin mod size where exists}.each do |operator|
-    define_method operator do
-      MongoMapper::FinderOperator.new(self, "$#{operator}")
-    end
+class SymbolOperator
+  def initialize(field, operator, options={})
+    @field, @operator = field, operator
+  end unless method_defined?(:initialize)
+  
+  def to_mm_criteria(value)
+    {MongoMapper::FinderOptions.normalized_field(@field) => {"$#{@operator}" => value}}
   end
   
-  def asc;  MongoMapper::OrderOperator.new(self, 'asc') end
-  def desc; MongoMapper::OrderOperator.new(self, 'desc') end
+  def to_mm_order
+    [@field.to_s, MongoMapper::FinderOptions.normalized_order_direction(@operator)]
+  end
+end
+
+class Symbol
+  %w(gt lt gte lte ne in nin mod 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
@@ -170,8 +190,9 @@ class Time
     if value.nil? || value == ''
       nil
     else
-      time = MongoMapper.time_class.parse(value.to_s)
-      time && time.utc
+      time = value.is_a?(Time) ? value : MongoMapper.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
     end
   end