mongomodel 0.5.5 → 0.5.6

data/lib/mongomodel/support/configuration.rb

@@ -16,42 +16,42 @@ module MongoModel
     def initialize(options)
       @options = DEFAULTS.merge(options).stringify_keys
     end
-    
+
     def host
       options['host']
     end
-    
+
     def port
       options['port']
     end
-    
+
     def database
       options['database']
     end
-    
+
     def username
       options['username']
     end
-    
+
     def password
       options['password']
     end
-    
+
     def replicas
       options['replicas'] || []
     end
-    
+
     def establish_connection
       @database = connection.db(database)
       @database.authenticate(username, password) if username.present?
       @database
     end
-    
+
     def use_database(database)
       options['database'] = database
       establish_connection
     end
-    
+
     def connection
       if replicas.any?
         @connection ||= Mongo::MongoReplicaSetClient.new(replicas, connection_options)
@@ -59,11 +59,11 @@ module MongoModel
         @connection ||= Mongo::MongoClient.new(host, port, connection_options)
       end
     end
-    
+
     def connection_options
       options.except('host', 'port', 'database', 'username', 'password', 'replicas').symbolize_keys
     end
-    
+
     def self.defaults
       new({})
     end

data/lib/mongomodel/support/core_extensions.rb

@@ -4,7 +4,7 @@ class Symbol
   [:lt, :lte, :gt, :gte, :ne, :in, :nin, :mod, :all, :size, :exists, :near].each do |operator|
     define_method(operator) { MongoModel::MongoOperator.new(self, operator) } unless method_defined?(operator)
   end
-  
+
   define_method(:asc) { MongoModel::MongoOrder::Clause.new(self, :ascending) } unless method_defined?(:asc)
   define_method(:desc) { MongoModel::MongoOrder::Clause.new(self, :descending) } unless method_defined?(:desc)
 end

data/lib/mongomodel/support/dynamic_finder.rb

@@ -3,13 +3,13 @@ module MongoModel
     def initialize(scope, attribute_names, finder=:first, bang=false)
       @scope, @attribute_names, @finder, @bang = scope, attribute_names, finder, bang
     end
-    
+
     def execute(*args)
       options = args.extract_options!
       conditions = build_conditions(args)
-      
+
       result = @scope.where(conditions).send(instantiator? ? :first : @finder)
-      
+
       if result.nil?
         if bang?
           raise DocumentNotFound, "Couldn't find #{@scope.klass.to_s} with #{conditions.inspect}"
@@ -17,22 +17,22 @@ module MongoModel
           return @scope.send(@finder, conditions)
         end
       end
-      
+
       result
     end
-    
+
     def bang?
       @bang
     end
-    
+
     def instantiator?
       @finder == :new || @finder == :create
     end
-    
+
     def self.match(scope, method)
       finder = :first
       bang = false
-      
+
       case method.to_s
       when /^find_(all_by|last_by|by)_([_a-zA-Z]\w*)$/
         finder = :last if $1 == 'last_by'
@@ -47,21 +47,21 @@ module MongoModel
       else
         return nil
       end
-      
+
       names = names.split('_and_')
       if names.all? { |n| scope.klass.properties.include?(n.to_sym) }
         new(scope, names, finder, bang)
       end
     end
-  
+
   private
     def build_conditions(args)
       result = {}
-      
+
       @attribute_names.zip(args) do |attribute, value|
         result[attribute.to_sym] = value
       end
-      
+
       result
     end
   end

data/lib/mongomodel/support/exceptions.rb

@@ -1,8 +1,8 @@
 module MongoModel
   class DocumentNotFound < StandardError; end
-  
+
   class DocumentNotSaved < StandardError; end
-  
+
   # Raised by <tt>save!</tt> and <tt>create!</tt> when the document is invalid.  Use the
   # +document+ method to retrieve the document which did not validate.
   #   begin
@@ -12,16 +12,16 @@ module MongoModel
   #   end
   class DocumentInvalid < DocumentNotSaved
     attr_reader :document
-    
+
     def initialize(document)
       @document = document
-      
+
       errors = @document.errors.full_messages.join(I18n.t('support.array.words_connector', :default => ', '))
       super(I18n.t('mongomodel.errors.messages.document_invalid', :errors => errors))
     end
   end
-  
+
   class AssociationTypeMismatch < StandardError; end
-  
+
   class TooManyDocuments < StandardError; end
 end

data/lib/mongomodel/support/instrumented_collection.rb

@@ -6,46 +6,46 @@
 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
@@ -54,10 +54,10 @@ module MongoModel
         collection == other
       end
     end
-    
+
     def find(selector={}, options={})
       cursor = InstrumentedCursor.new(collection.find(selector, options))
-      
+
       if block_given?
         yield cursor
         cursor.close
@@ -66,7 +66,7 @@ module MongoModel
         cursor
       end
     end
-    
+
     def save(doc, options={})
       if doc.has_key?(:_id) || doc.has_key?('_id')
         selector = { '_id' => doc[:_id] || doc['_id'] }
@@ -79,48 +79,48 @@ module MongoModel
         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(options, condition={}, initial={}, reduce=nil, finalize=nil)
       instrument("group(#{options.inspect})") do
         collection.group(options, 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
-    
+
     def map_reduce(map, reduce, options={})
       instrument("map_reduce(#{options.inspect})") do
         collection.map_reduce(map, reduce, options)
       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

data/lib/mongomodel/support/map.rb

@@ -5,30 +5,30 @@ module MongoModel
     module PropertyDefaults
       def property(name, *args, &block) #:nodoc:
         property = super(name, *args, &block)
-        
+
         if property.type <= Map
           property.options[:default] ||= lambda { property.type.new }
         end
-        
+
         property
       end
     end
-    
+
     class_attribute :from
     self.from = String
-    
+
     class_attribute :to
     self.to = Object
-    
+
     HASH_CONVERTER = Types.converter_for(Hash)
-    
+
     class << self
       def [](mapping)
         raise "Exactly one mapping must be specified" unless mapping.keys.size == 1
-        
+
         from = mapping.keys.first
         to   = mapping.values.first
-        
+
         @map_class_cache ||= {}
         @map_class_cache[[from, to]] ||= begin
           map = Class.new(Map)
@@ -37,13 +37,13 @@ module MongoModel
           map
         end
       end
-      
+
       def from_mongo(hash)
         result = new
         hash.each_pair { |k, v| result[from_converter.from_mongo(k)] = instantiate(v) }
         result
       end
-      
+
       def inspect
         if self == Map
           "Map"
@@ -51,15 +51,15 @@ module MongoModel
           "Map[#{from} => #{to}]"
         end
       end
-      
+
       def from_converter
         @from_converter ||= Types.converter_for(from)
       end
-      
+
       def to_converter
         @to_converter ||= Types.converter_for(to)
       end
-      
+
     private
       def instantiate(item)
         if item.is_a?(Hash) && item['_type']
@@ -69,85 +69,85 @@ module MongoModel
         end
       end
     end
-    
+
     def initialize(hash={})
       super()
       update(hash)
     end
-    
+
     def to_mongo
       HASH_CONVERTER.to_mongo(self)
     end
-    
+
     def [](key)
       super(convert_key(key))
     end
-    
+
     def []=(key, value)
       super(convert_key(key), convert_value(value))
     end
-    
+
     def store(key, value)
       super(convert_key(key), convert_value(value))
     end
-    
+
     def delete(key)
       super(convert_key(key))
     end
-    
+
     def fetch(key, *args, &block)
       super(convert_key(key), *args, &block)
     end
-    
+
     def key?(key)
       super(convert_key(key))
     end
-    
+
     alias_method :include?, :key?
     alias_method :has_key?, :key?
     alias_method :member?, :key?
-    
+
     def value?(value)
       super(convert_value(value))
     end
-    
+
     alias_method :has_value?, :value?
-    
+
     def index(value)
       super(convert_value(value))
     end
-    
+
     def key(value)
       super(convert_value(value))
     end
-    
+
     def update(hash)
       hash.each_pair { |k, v| self[k] = v }
       self
     end
-    
+
     def replace(hash)
       clear
       update(hash)
     end
-    
+
     def merge(hash)
       dup.update(super(hash))
     end
-    
+
     def merge!(hash)
       update(merge(hash))
     end
-    
+
     def values_at(*keys)
       super(*keys.map { |k| convert_key(k) })
     end
-  
+
   private
     def convert_key(key)
       self.class.from_converter.cast(key)
     end
-    
+
     def convert_value(value)
       self.class.to_converter.cast(value)
     end