dm-mongo-adapter 0.2.0.pre3 → 0.6.0

data/lib/mongo_adapter/adapter.rb

@@ -1,6 +1,9 @@
 module DataMapper
   module Mongo
     class Adapter < DataMapper::Adapters::AbstractAdapter
+      include DataMapper::Mongo::Aggregates
+      include Migrations
+
       class ConnectionError < StandardError; end
 
       # Persists one or more new resources
@@ -37,7 +40,7 @@ module DataMapper
       # @api semipublic
       def read(query)
         with_collection(query.model) do |collection|
-          Query.new(collection, query).read
+          load_retrieved_fields!(Query.new(collection, query).read, query.model)
         end
       end
 
@@ -117,7 +120,25 @@ module DataMapper
       #
       # @api private
       def key(resource)
-        resource.model.key(name).map{ |key| [key.field, key.value(resource.__send__(key.name))] }.to_hash
+        DataMapper::Ext::Array.to_hash(resource.model.key(name).map do |key| 
+          [ key.field, key.dump(resource.__send__(key.name)) ]
+        end)
+      end
+
+      # TODO: document
+      def load_retrieved_fields!(fields, model)
+        fields.each do |attributes|
+          if discriminator = model.properties.discriminator
+            attributes[discriminator.field] = Class.from_mongo(attributes[discriminator.field])
+          end
+
+          attributes.each do |key, value|
+            next if discriminator && key == discriminator
+            attributes[key] = load_field_value(value)
+          end
+        end
+
+        fields
       end
 
       # Retrieves all of a records attributes and returns them as a Hash.
@@ -142,7 +163,9 @@ module DataMapper
             attributes_from_properties_hash(record)
           end
 
-        attributes.except('_id') unless attributes.nil?
+        attributes.delete('_id') unless attributes.nil?
+
+        attributes
       end
 
       # TODO: document
@@ -152,27 +175,7 @@ module DataMapper
         model = record.model
 
         model.properties.each do |property|
-          name = property.name
-          if model.public_method_defined?(name)
-            value = property.get(record)
-            
-            attributes[property.field] = property.custom? ?
-              property.type.dump(value, property) : value
-          end
-        end
-
-        if model.respond_to?(:embedments)
-          model.embedments.each do |name, embedment|
-            if model.public_method_defined?(name)
-              value = record.__send__(name)
-
-              if embedment.kind_of?(Embedments::OneToMany::Relationship)
-                attributes[embedment.storage_name] = value.map{ |resource| attributes_as_fields(resource) }
-              else
-                attributes[name] = attributes_as_fields(value)
-              end
-            end
-          end
+          attributes[property.field] = dump_field_value(property.dump(property.get(record)))
         end
 
         attributes
@@ -183,17 +186,24 @@ module DataMapper
         attributes = {}
 
         record.each do |key, value|
-          case key
-            when DataMapper::Property
-              attributes[key.field] = key.custom? ? key.type.dump(value, key) : value
-            when Embedments::Relationship
-              attributes[key.storage_name] = attributes_as_fields(value)
-            end
+          attributes[key.field] = dump_field_value(key.dump(value))
         end
 
         attributes
       end
 
+      # TODO: document
+      def dump_field_value(value)
+        return nil if value.nil?
+        value.class.to_mongo(value)
+      end
+
+      # TODO: document
+      def load_field_value(value)
+        return nil if value.nil?
+        value.class.from_mongo(value)
+      end
+
       # Runs the given block within the context of a Mongo collection.
       #
       # @param [Model] model
@@ -226,11 +236,14 @@ module DataMapper
         unless defined?(@database)
           @database = connection.db(@options[:database])
 
-          if @options[:username] and not @database.authenticate(
-              @options[:username], @options[:password])
-            raise ConnectionError,
-              'MongoDB did not recognize the given username and/or ' \
-              'password; see the server logs for more information'
+          if @options[:username]
+            begin
+              @database.authenticate(@options[:username], @options[:password])
+            rescue ::Mongo::AuthenticationError
+              raise ConnectionError,
+                'MongoDB did not recognize the given username and/or ' \
+                'password; see the server logs for more information'
+            end
           end
         end
 
@@ -246,7 +259,7 @@ module DataMapper
       #
       # @api semipublic
       def connection
-        @connection ||= ::Mongo::Connection.new(*@options.values_at(:host, :port))
+        @connection ||= ::Mongo::Connection.new(@options[:host], @options[:port], :slave_ok => true)
       end
     end # Adapter
   end # Mongo

data/lib/mongo_adapter/conditions.rb

@@ -70,7 +70,6 @@ module DataMapper
       # Comparisons not current supported are:
       #
       #   * $nin with range
-      #   * negated regexp comparison (see: http://jira.mongodb.org/browse/SERVER-251)
       #
       # @param [DataMapper::Query::Conditions::AbstractOperation, DataMapper::Query::Conditions::AbstractComparison] operand
       #   An operation to be made suitable for use with Mongo
@@ -82,10 +81,6 @@ module DataMapper
         case operand
         when OrOperation
           true
-        when RegexpComparison
-          if operand.negated?
-            true
-          end
         when InclusionComparison
           if operand.negated?
             true

data/lib/mongo_adapter/migrations.rb

@@ -1,26 +1,8 @@
-module DataMapper
-  module Migrations
-    module SingletonMethods
-      private
-      
-      def repository_execute(method, repository_name)
-        DataMapper::Model.descendants.each do |model|
-          model.send(method, repository_name || model.default_repository_name) unless model == DataMapper::Mongo::EmbeddedResource
-        end
-      end
-    end
-  end
+require 'dm-migrations/auto_migration'
 
+module DataMapper
   module Mongo
     module Migrations
-      def self.included(base)  
-        DataMapper.extend(DataMapper::Migrations::SingletonMethods)
- 
-        [ :Repository, :Model ].each do |name|
-          DataMapper.const_get(name).send(:include, DataMapper::Migrations.const_get(name))
-        end
-      end
-
       def storage_exists?(storage_name)
         database.collections.map(&:name).include?(storage_name)
       end
@@ -38,8 +20,20 @@ module DataMapper
         database.drop_collection(model.storage_name)
       end
 
-     end
+      module Model
+        def auto_migrate!(repository_name = self.repository_name)
+          adapter = repository(repository_name).adapter
+
+          return unless adapter.kind_of?(Mongo::Adapter)
+
+          adapter.destroy_model_storage(self)
+          adapter.create_model_storage(self)
+        end
+
+        def auto_upgrade!(repository_name = self.repository_name)
+          # noop
+        end
+      end
+    end
   end
 end
-
-DataMapper::Mongo.send(:include, DataMapper::Mongo::Migrations)

data/lib/mongo_adapter/model.rb

@@ -1,85 +1,14 @@
 module DataMapper
   module Mongo
     module Model
-      def self.extended(model)
-        model.extend Embedment
-      end
-
-      # Defines a Property on the Resource
-      #
-      # Overrides the property method in dm-core so as to automatically map
-      # Array and Hash types to EmbeddedArray and EmbeddedHash respectively.
-      #
-      # @param [Symbol] name
-      #   the name for which to call this property
-      # @param [Type] type
-      #   the type to define this property ass
-      # @param [Hash(Symbol => String)] options
-      #   a hash of available options
-      #
-      # @return [Property]
-      #   the created Property
-      #
-      # @api public
-      def property(name, type, options = {})
-        if Array == type
-          type = DataMapper::Mongo::Types::EmbeddedArray
-        elsif Hash == type
-          type = DataMapper::Mongo::Types::EmbeddedHash
-        elsif DateTime == type
-          type = DataMapper::Mongo::Types::DateTime
-        elsif Date == type
-          type = DataMapper::Mongo::Types::Date
-        end
-
-        super(name, type, options)
-      end
-
-      # Loads an instance of this Model, taking into account IdentityMap
-      # lookup, inheritance columns(s) and Property typecasting. Also loads
-      # the embedments on the Resource.
-      #
-      # @param [Enumerable<Object>] records
-      #   An Array of Resource or Hashes to load a Resource with
-      # @param [DataMapper::Query] query
-      #   The query used to load the Resource
-      #
-      # @return [Resource]
-      #   The loaded Resource instance
-      #
-      # @overrides DataMapper::Model#load
-      #
-      # @api semipublic
-      def load(records, query)
-        if discriminator = properties(query.repository.name).discriminator
-          records.each do |record|
-            discriminator_key   = discriminator.name.to_s
-            discriminator_value = discriminator.type.load(record[discriminator_key], discriminator)
-
-            record[discriminator_key] = discriminator_value
-          end
-        end
-
-        resources = super
-
-        # Load embedded resources
-        resources.each_with_index do |resource, index|
-          resource.model.embedments.each do |name, relationship|
-            unless (targets = records[index][name.to_s]).blank?
-              relationship.set(resource, targets, true)
-            end
-          end
-        end
-
-        resources
-      end
+      include Migrations::Model
 
       private
 
       # @api private
       def const_missing(name)
-        if DataMapper::Mongo::Types.const_defined?(name)
-          DataMapper::Mongo::Types.const_get(name)
+        if DataMapper::Mongo::Property.const_defined?(name)
+          DataMapper::Mongo::Property.const_get(name)
         else
           super
         end

data/lib/mongo_adapter/modifier.rb

@@ -35,7 +35,7 @@ module DataMapper
       # @api public
       def unset(*args)
         new_args = {}
-        
+
         args.each do |arg|
           new_args[arg] = 1
         end

data/lib/mongo_adapter/property/array.rb

@@ -0,0 +1,10 @@
+module DataMapper
+  module Mongo
+    class Property
+      class Array < DataMapper::Property::Object
+        include DataMapper::Property::PassThroughLoadDump
+        primitive ::Array
+      end
+    end # Property
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/property/db_ref.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  module Mongo
+    class Property
+      # Database references are references from one document (object) to
+      # another within a database. A database reference is a standard embedded
+      # object: this is a MongoDB convention, not a special type.
+      #
+      # The DBRef is made available via your model as a String.
+      #
+      # @see http://www.mongodb.org/display/DOCS/DB+Ref
+      #
+      # @api public
+      class DBRef < DataMapper::Mongo::Property::ObjectId
+      end # DBRef
+    end # Property
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/property/hash.rb

@@ -0,0 +1,27 @@
+module DataMapper
+  module Mongo
+    class Property
+      class Hash < DataMapper::Property::Object
+        include DataMapper::Property::PassThroughLoadDump
+        primitive ::Hash
+
+        # @api semipublic
+        def load(value)
+          typecast_to_primitive(value)
+        end
+
+        # @api semipublic
+        def typecast_to_primitive(value)
+          case value
+          when NilClass
+            nil
+          when ::Hash
+            DataMapper::Ext::Hash.to_mash(value).symbolize_keys
+          when ::Array
+            value.empty? ? {} : {value.first.to_sym => value.last}
+          end
+        end
+      end #Array
+    end # Property
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/property/object_id.rb

@@ -0,0 +1,47 @@
+module DataMapper
+  module Mongo
+    class Property
+      # Each object (document) stored in Mongo DB has an _id field as its
+      # first attribute.  This is an object id.  It must be unique for each
+      # member of a collection (this is enforced if the collection has an _id
+      # index, which is the case by default).
+      #
+      # The database will assign an _id if an object being inserted into a
+      # collection does not have one.
+      #
+      # The _id may be of any type as long as it is a unique value.
+      #
+      # @see http://www.mongodb.org/display/DOCS/Object+IDs
+      #
+      # @api public
+      class ObjectId < DataMapper::Property::Object
+        include DataMapper::Property::PassThroughLoadDump
+
+        primitive ::BSON::ObjectId
+        key true
+        field "_id"
+        required false
+
+        # Returns the ObjectId as a string
+        #
+        # @return [String]
+        #
+        # @api semipublic
+        def typecast_to_primitive(value)
+          case value
+          when ::String
+            ::BSON::ObjectId.from_string(value)
+          else
+            raise ArgumentError.new('+value+ must String')
+          end
+        end
+
+        # @api semipublic
+        def valid?(value, negated = false)
+          value.nil? || primitive?(value)
+        end
+
+      end # ObjectId
+    end # Property
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/query.rb

@@ -3,7 +3,7 @@ module DataMapper
     # This class is responsible for taking Query instances from DataMapper and
     # formatting the query such that it can be performed by the Mongo library.
     class Query
-      include Extlib::Assertions
+      include DataMapper::Assertions
       include DataMapper::Query::Conditions
 
       # Creates a new Query instance
@@ -42,7 +42,7 @@ module DataMapper
 
         # TODO: atm ruby driver doesn't support count with statements,
         #        that's why we use find and size here as a tmp workaround
-        if @statements.blank?
+        if @statements.keys.empty?
           [@collection.count]
         else
           [find.size]
@@ -68,7 +68,7 @@ module DataMapper
           end
         end
 
-        if operators.blank?
+        if operators.empty?
           initial  = {}
           reduce   = JavaScript::Reduce.new.to_s
           finalize = nil
@@ -81,9 +81,14 @@ module DataMapper
 
           keys = keys - initial.keys
         end
-        
-        @collection.group(keys, @statements, initial, reduce, true, finalize).map do |records|
-          records.to_mash.symbolize_keys.only(*property_names)
+
+        opts = {
+          :key => keys, :cond => @statements, :initial => initial,
+          :reduce => reduce, :finalize => finalize
+        }
+
+        @collection.group(opts).map do |records|
+          DataMapper::Ext::Hash.to_mash(records).symbolize_keys
         end
       end
 
@@ -93,10 +98,10 @@ module DataMapper
       # @api private
       def setup_conditions_and_options
         @options = {}
-        
+
         @options[:limit] = @query.limit  if @query.limit
         @options[:skip]  = @query.offset if @query.offset
-        @options[:sort]  = sort_statement(@query.order) unless @query.order.empty?
+        @options[:sort]  = sort_statement(@query.order) unless @query.order.nil?
 
         conditions_statement(@query.conditions)
       end
@@ -144,16 +149,6 @@ module DataMapper
         end
       end
 
-      # TODO: document
-      # @api private
-      def comparison_statement_for_embedment(comparison, affirmative = true)
-        embedment = @query.model.embedments.values.detect { |e| e.target_model == comparison.subject.model }
-
-        field = "#{embedment.storage_name}.#{comparison.subject.field}"
-
-       update_statements(comparison, field, affirmative)
-      end
-
       # Takes a Comparison condition and returns a Mongo-compatible hash
       #
       # @param [DataMapper::Query::Conditions::Comparison] comparison
@@ -170,39 +165,41 @@ module DataMapper
           return conditions_statement(comparison.foreign_key_mapping, affirmative)
         end
 
-        if comparison.subject.model && comparison.subject.model < EmbeddedResource
-          return comparison_statement_for_embedment(comparison, affirmative)
-        end
-
         update_statements(comparison, comparison.subject.field, affirmative)
       end
 
       # TODO: document
       # @api private
-      def update_statements(comparison, field, affirmative = true)
-        value = comparison.value
+      def
+        update_statements(comparison, field, affirmative = true)
+        value = if comparison.value.kind_of?(Array)
+                  comparison.value.map { |value| value.class.to_mongo(value) }
+                else
+                  comparison.value.class.to_mongo(comparison.value)
+                end
 
         operator = if affirmative
-          case comparison
-            when EqualToComparison              then value
-            when GreaterThanComparison          then {'$gt'  => value}
-            when LessThanComparison             then {'$lt'  => value}
-            when GreaterThanOrEqualToComparison then {'$gte' => value}
-            when LessThanOrEqualToComparison    then {'$lte' => value}
-            when InclusionComparison            then inclusion_comparison_operator(comparison, value)
-            when RegexpComparison               then value
-            when LikeComparison                 then comparison.send(:expected)
-          else
-            raise NotImplementedError
-          end
-        else
-          case comparison
-            when EqualToComparison              then {'$ne'  => value}
-            when InclusionComparison            then {'$nin' => value}
-          else
-            raise NotImplementedError
-          end
-        end
+                     case comparison
+                     when EqualToComparison              then value
+                     when GreaterThanComparison          then {'$gt'  => value}
+                     when LessThanComparison             then {'$lt'  => value}
+                     when GreaterThanOrEqualToComparison then {'$gte' => value}
+                     when LessThanOrEqualToComparison    then {'$lte' => value}
+                     when InclusionComparison            then inclusion_comparison_operator(comparison, value)
+                     when RegexpComparison               then value
+                     when LikeComparison                 then comparison.send(:expected)
+                     else
+                       raise NotImplementedError
+                     end
+                   else
+                     case comparison
+                     when EqualToComparison              then {'$ne'  => value}
+                     when InclusionComparison            then {'$nin' => value}
+                     when RegexpComparison               then {'$not' => value}
+                     else
+                       raise NotImplementedError
+                     end
+                   end
 
         operator.is_a?(Hash) ?
           (@statements[field.to_sym] ||= {}).merge!(operator) : @statements[field.to_sym] = operator
@@ -223,7 +220,7 @@ module DataMapper
           {'$gte' => value.first, value.exclude_end? ? '$lt' : '$lte' => value.last}
         elsif comparison.kind_of?(InclusionComparison) && value.size == 1
           value.first
-        elsif comparison.subject.type == DataMapper::Mongo::Types::EmbeddedArray
+        elsif comparison.subject.kind_of?(DataMapper::Mongo::Property::Array)
           value
         else
           {'$in'  => value}