mongomodel 0.2.20 → 0.3.0

data/lib/mongomodel/railties/controller_runtime.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext/module/attr_internal'
+
+module MongoModel
+  module Railties
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+    protected
+      attr_internal :db_runtime
+
+      def cleanup_view_runtime
+        db_rt_before_render = MongoModel::LogSubscriber.reset_runtime
+        runtime = super
+        db_rt_after_render = MongoModel::LogSubscriber.reset_runtime
+        self.db_runtime = db_rt_before_render + db_rt_after_render
+        runtime - db_rt_after_render
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:db_runtime] = db_runtime
+      end
+
+      module ClassMethods
+        def log_process_action(payload)
+          messages, db_runtime = super, payload[:db_runtime]
+          messages << ("MongoModel: %.1fms" % db_runtime.to_f) if db_runtime
+          messages
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/support/collection.rb

@@ -31,7 +31,7 @@ module MongoModel
       super(convert_for_add(value))
     end
     
-    def build (value)
+    def build(value={})
       value = convert(value)
       self << value
       value

data/lib/mongomodel/support/configuration.rb

@@ -57,8 +57,7 @@ module MongoModel
       'port'      => 27017,
       'database'  => 'mongomodel-default',
       'pool_size' => 5,
-      'timeout'   => 5,
-      'logger'    => MongoModel.logger
+      'timeout'   => 5
     }
     
     def self.defaults

data/lib/mongomodel/support/instrumented_collection.rb

@@ -0,0 +1,122 @@
+# MongoModel::InstrumentedCursor & MongoModel::InstrumentedCollection are wrappers
+# around Mongo::Cursor & Mongo::Collection respectively to add in support for
+# ActiveSupport notifications.
+#
+# They are primarily used in MongoModel to implement logging.
+module MongoModel
+  class InstrumentedCursor
+    attr_reader :cursor
+    
+    def initialize(cursor)
+      @cursor = cursor
+    end
+    
+    def to_a
+      instrument(query_description) do
+        cursor.to_a
+      end
+    end
+    
+    def count
+      instrument("count(#{cursor.selector.inspect})") do
+        cursor.count
+      end
+    end
+  
+  private
+    def method_missing(method, *args, &block)
+      cursor.send(method, *args, &block)
+    end
+    
+    def query_description
+      "find(#{cursor.selector.inspect}, #{cursor.fields ? cursor.fields.inspect : '{}'})" +
+      "#{cursor.skip != 0 ? ('.skip(' + cursor.skip.to_s + ')') : ''}#{cursor.limit != 0 ? ('.limit(' + cursor.limit.to_s + ')') : ''}" +
+      "#{cursor.order ? ('.sort(' + cursor.order.inspect + ')') : ''}"
+    end
+    
+    def instrument(query, &block)
+      ActiveSupport::Notifications.instrument("query.mongomodel", :collection => cursor.collection.name, :query => query, &block)
+    end
+  end
+  
+  class InstrumentedCollection
+    attr_reader :collection
+    
+    def initialize(collection)
+      @collection = collection
+    end
+    
+    def ==(other)
+      case other
+      when self.class
+        collection == other.collection
+      else
+        collection == other
+      end
+    end
+    
+    def find(selector={}, options={})
+      cursor = InstrumentedCursor.new(collection.find(selector, options))
+      
+      if block_given?
+        yield cursor
+        cursor.close
+        nil
+      else
+        cursor
+      end
+    end
+    
+    def save(doc, options={})
+      if doc.has_key?(:_id) || doc.has_key?('_id')
+        selector = { '_id' => doc[:_id] || doc['_id'] }
+        instrument("update(#{selector.inspect}, #{doc.inspect})") do
+          collection.save(doc, options)
+        end
+      else
+        instrument("insert(#{doc})") do
+          collection.insert(doc, options)
+        end
+      end
+    end
+    
+    def remove(selector={}, options={})
+      instrument("remove(#{selector.inspect})") do
+        collection.remove(selector, options)
+      end
+    end
+    
+    def update(selector, document, options={})
+      instrument("update(#{selector.inspect}, #{document.inspect})") do
+        collection.update(selector, document, options)
+      end
+    end
+    
+    def create_index(spec, options={})
+      instrument("create_index(#{spec.inspect})") do
+        collection.create_index(spec, options)
+      end
+    end
+    
+    def group(key, condition, initial, reduce, finalize=nil)
+      instrument("group(#{key.inspect}, #{condition.inspect})") do
+        collection.group(key, condition, initial, reduce, finalize)
+      end
+    end
+    
+    def distinct(key, query=nil)
+      instrument("distinct(#{key.inspect}#{query.present? ? ', ' + query.inspect : ''})") do
+        collection.distinct(key, query)
+      end
+    end
+  
+  private
+    def method_missing(method, *args, &block)
+      collection.send(method, *args, &block)
+    end
+    
+    def instrument(query, &block)
+      ActiveSupport::Notifications.instrument("query.mongomodel", :collection => collection.name, :query => query, &block)
+    end
+  end
+end

data/lib/mongomodel/support/mongo_options.rb

@@ -28,15 +28,29 @@ module MongoModel
       (options[:conditions] || {}).each do |k, v|
         if k.is_a?(MongoOperator)
           key = k.field
-          value = k.to_mongo_selector(v)
         else
           key = k
-          value = v
         end
         
-        property = @model.properties[key]
+        if property = @model.properties[key]
+          key = property.as
+          
+          if k.is_a?(MongoOperator)
+            value = k.to_mongo_selector(v.is_a?(Array) ? v.map { |i| property.to_mongo(property.cast(i)) } : property.to_mongo(property.cast(v)))
+          else
+            value = property.to_mongo(property.cast(v))
+          end
+        else
+          converter = Types.converter_for(value.class)
+          
+          if k.is_a?(MongoOperator)
+            value = k.to_mongo_selector(converter.to_mongo(v))
+          else
+            value = converter.to_mongo(v)
+          end
+        end
         
-        result[property ? property.as : key] = value
+        result[key] = value
       end
       
       result

data/lib/mongomodel/support/reference.rb

@@ -1,14 +1,56 @@
 module MongoModel
-  class Reference < String
+  class Reference
+    attr_reader :id
+    
+    def initialize(id)
+      @id = id
+    end
+    
+    def to_s
+      id.to_s
+    end
+    
+    def hash
+      id.hash
+    end
+    
+    def as_json(*)
+      to_s
+    end
+    
+    def blank?
+      id.blank?
+    end
+    
+    def eql?(other)
+      case other
+      when Reference
+        id.to_s == other.id.to_s
+      else
+        id.to_s == other.to_s
+      end
+    end
+    alias_method :==, :eql?
+    
+    def to_mongo
+      id.blank? ? nil : id
+    end
+    
     def self.cast(value)
-      value = value.to_s if value.respond_to?(:to_s)
-      
       case value
-      when "", nil
-        nil
-      else
+      when BSON::ObjectId
         new(value)
+      else
+        if BSON::ObjectId.legal?(value.to_s)
+          new(BSON::ObjectId(value.to_s))
+        else
+          new(value.to_s)
+        end
       end
     end
+    
+    def self.from_mongo(value)
+      cast(value)
+    end
   end
 end

data/lib/mongomodel/support/scope.rb

@@ -8,11 +8,12 @@ module MongoModel
     autoload :SpawnMethods,   'mongomodel/support/scope/spawn_methods'
     autoload :QueryMethods,   'mongomodel/support/scope/query_methods'
     autoload :FinderMethods,  'mongomodel/support/scope/finder_methods'
+    autoload :LoadMethods,    'mongomodel/support/scope/load_methods'
     autoload :DynamicFinders, 'mongomodel/support/scope/dynamic_finders'
     autoload :Pagination,     'mongomodel/support/scope/pagination'
     autoload :Batches,        'mongomodel/support/scope/batches'
     
-    include Batches, Pagination, DynamicFinders, FinderMethods, QueryMethods, SpawnMethods
+    include Batches, Pagination, DynamicFinders, LoadMethods, FinderMethods, QueryMethods, SpawnMethods
     
     delegate :inspect, :as_json, :to => :to_a
     
@@ -76,7 +77,7 @@ module MongoModel
     
     def delete_all
       selector = MongoOptions.new(klass, :conditions => finder_conditions).selector
-      collection.remove(selector)
+      collection.remove(selector, {})
       reset
     end
     
@@ -179,7 +180,11 @@ module MongoModel
     end
     
     def _find_and_instantiate
-      _find.to_a.map { |doc| klass.from_mongo(doc) }
+      _find.to_a.map { |doc|
+        klass.from_mongo(doc).tap { |instance|
+          on_load_proc.call(instance) if on_load_proc
+        }
+      }
     end
     
     def finder_conditions

data/lib/mongomodel/support/scope/finder_methods.rb

@@ -11,10 +11,11 @@ module MongoModel
           when 0
             raise ArgumentError, "At least one id must be specified"
           when 1
-            id = ids.first.to_s
+            id = ids.first
             where(:id => id).first || raise(DocumentNotFound, "Couldn't find document with id: #{id}")
           else
-            docs = where(:id.in => ids.map { |id| id.to_s }).to_a
+            ids = ids.map { |id| Reference.cast(id) }
+            docs = where(:id.in => ids).to_a
             raise DocumentNotFound if docs.size != ids.size
             docs.sort_by { |doc| ids.index(doc.id) }
           end

data/lib/mongomodel/support/scope/load_methods.rb

@@ -0,0 +1,13 @@
+module MongoModel
+  class Scope
+    module LoadMethods
+      attr_accessor :on_load_proc
+      
+      def on_load(&block)
+        new_scope = clone
+        new_scope.on_load_proc = block
+        new_scope
+      end
+    end
+  end
+end

data/lib/mongomodel/support/scope/query_methods.rb

@@ -33,7 +33,7 @@ module MongoModel
       
       def from(value, &block)
         new_scope = clone
-        new_scope.from_value = value.is_a?(String) ? klass.database.collection(value) : value
+        new_scope.from_value = InstrumentedCollection.new(value.is_a?(String) ? klass.database.collection(value) : value)
         new_scope
       end
       

data/lib/mongomodel/support/types.rb

@@ -1,3 +1,4 @@
+require 'rational' unless RUBY_VERSION >= '1.9.2'
 require 'set'
 
 require 'mongomodel/support/types/object'
@@ -12,20 +13,22 @@ require 'mongomodel/support/types/custom'
 require 'mongomodel/support/types/array'
 require 'mongomodel/support/types/set'
 require 'mongomodel/support/types/hash'
+require 'mongomodel/support/types/rational'
 
 module MongoModel
   module Types
     CONVERTERS = {
-      ::String  => Types::String.new,
-      ::Integer => Types::Integer.new,
-      ::Float   => Types::Float.new,
-      ::Boolean => Types::Boolean.new,
-      ::Symbol  => Types::Symbol.new,
-      ::Date    => Types::Date.new,
-      ::Time    => Types::Time.new,
-      ::Array   => Types::Array.new,
-      ::Set     => Types::Set.new,
-      ::Hash    => Types::Hash.new
+      ::String   => Types::String.new,
+      ::Integer  => Types::Integer.new,
+      ::Float    => Types::Float.new,
+      ::Boolean  => Types::Boolean.new,
+      ::Symbol   => Types::Symbol.new,
+      ::Date     => Types::Date.new,
+      ::Time     => Types::Time.new,
+      ::Array    => Types::Array.new,
+      ::Set      => Types::Set.new,
+      ::Hash     => Types::Hash.new,
+      ::Rational => Types::Rational.new
     }
     
     def self.converter_for(type)

data/lib/mongomodel/support/types/array.rb

@@ -4,7 +4,7 @@ module MongoModel
       def to_mongo(array)
         array.map { |i|
           Types.converter_for(i.class).to_mongo(i)
-        }
+        } if array
       end
     end
   end

data/lib/mongomodel/support/types/hash.rb

@@ -7,7 +7,7 @@ module MongoModel
         hash.inject({}) { |result, (k, v)|
           result[k] = Types.converter_for(v.class).to_mongo(v)
           result
-        }
+        } if hash
       end
       
       def from_mongo(hash)

data/lib/mongomodel/support/types/rational.rb

@@ -0,0 +1,42 @@
+module MongoModel
+  module Types
+    class Rational < Object
+      if RUBY_VERSION >= '1.9.2'
+        def cast(value)
+          Rational(value)
+        end
+      else
+        def cast(value)
+          case value
+          when ::Rational
+            value
+          when ::String
+            rational_from_string(value)
+          else
+            Rational(value)
+          end
+        end
+      end
+      
+      def from_mongo(value)
+        rational_from_string(value)
+      end
+      
+      def to_mongo(value)
+        value.to_s
+      end
+    
+    private
+      if RUBY_VERSION >= '1.9.2'
+        def rational_from_string(str)
+          Rational(str)
+        end
+      else
+        def rational_from_string(str)
+          numerator, denominator = str.split("/", 2)
+          Rational(numerator.to_i, (denominator || 1).to_i)
+        end
+      end
+    end
+  end
+end