dm-mongo-adapter 0.2.0.pre1

data/lib/mongo_adapter/adapter.rb

@@ -0,0 +1,255 @@
+module DataMapper
+  module Mongo
+    class Adapter < DataMapper::Adapters::AbstractAdapter
+      class ConnectionError < StandardError; end
+
+      # Persists one or more new resources
+      #
+      # @example
+      #   adapter.create(collection)  # => 1
+      #
+      # @param [Enumerable<Resource>] resources
+      #   The list of resources (model instances) to create
+      #
+      # @return [Integer]
+      #   The number of records that were actually saved into the data-store
+      #
+      # @api semipublic
+      def create(resources)
+        resources.map do |resource|
+          with_collection(resource.model) do |collection|
+            resource.model.key.set(resource, [collection.insert(attributes_as_fields(resource))])
+          end
+        end.size
+      end
+
+      # Reads one or many resources from a datastore
+      #
+      # @example
+      #   adapter.read(query)  # => [ { 'name' => 'Dan Kubb' } ]
+      #
+      # @param [Query] query
+      #   The query to match resources in the datastore
+      #
+      # @return [Enumerable<Hash>]
+      #   An array of hashes to become resources
+      #
+      # @api semipublic
+      def read(query)
+        with_collection(query.model) do |collection|
+          Query.new(collection, query).read
+        end
+      end
+
+      # Updates one or many existing resources
+      #
+      # @example
+      #   adapter.update(attributes, collection)  # => 1
+      #
+      # @param [Hash(Property => Object)] attributes
+      #   Hash of attribute values to set, keyed by Property
+      # @param [Collection] resources
+      #   Collection of records to be updated
+      #
+      # @return [Integer]
+      #   The number of records updated
+      #
+      # @api semipublic
+      def update(attributes, resources)
+        with_collection(resources.query.model) do |collection|
+          resources.each do |resource|
+            collection.update(key(resource),
+              attributes_as_fields(resource).merge(attributes_as_fields(attributes)))
+          end.size
+        end
+      end
+
+      # Deletes one or many existing resources
+      #
+      # @example
+      #   adapter.delete(collection)  # => 1
+      #
+      # @param [Collection] resources
+      #   Collection of records to be deleted
+      #
+      # @return [Integer]
+      #   The number of records deleted
+      #
+      # @api semipublic
+      def delete(resources)
+        with_collection(resources.query.model) do |collection|
+          resources.each do |resource|
+            collection.remove(key(resource))
+          end.size
+        end
+      end
+
+      # TODO: document
+      # @api semipublic
+      def execute(resources, document, options={})
+        resources.map do |resource|
+          with_collection(resource.model) do |collection|
+            collection.update(key(resource), document, options)
+          end
+        end.size
+      end
+
+      private
+
+      def initialize(name, options = {})
+        # When giving a repository URI rather than a hash, the database name
+        # is :path, with a leading slash.
+        if options[:path] && options[:database].nil?
+          options[:database] = options[:path].sub(/^\//, '')
+        end
+
+        super
+      end
+
+      # Retrieves the key for a given resource as a hash.
+      #
+      # @param [Resource] resource
+      #   The resource whose key is to be retrieved
+      #
+      # @return [Hash{Symbol => Object}]
+      #   Returns a hash where each hash key/value corresponds to a key name
+      #   and value on the resource.
+      #
+      # @api private
+      def key(resource)
+        resource.model.key(name).map{ |key| [key.field, key.value(resource.__send__(key.name))] }.to_hash
+      end
+
+      # Retrieves all of a records attributes and returns them as a Hash.
+      #
+      # The resulting hash can then be used with the Mongo library for
+      # inserting new -- and updating existing -- documents in the database.
+      #
+      # @param [Resource, Hash] record
+      #   A DataMapper resource, or a hash containing fields and values.
+      #
+      # @return [Hash]
+      #   Returns a hash containing the values for each of the fields in the
+      #   given resource as raw (dumped) values suitable for use with the
+      #   Mongo library.
+      #
+      # @api private
+      def attributes_as_fields(record)
+        attributes = case record
+          when DataMapper::Resource
+            attributes_from_resource(record)
+          when Hash
+            attributes_from_properties_hash(record)
+          end
+
+        attributes.except('_id') unless attributes.nil?
+      end
+
+      # TODO: document
+      def attributes_from_resource(record)
+        attributes = {}
+
+        model = record.model
+
+        model.properties.each do |property|
+          name = property.name
+          if model.public_method_defined?(name)
+            value = record.__send__(name)
+            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[name] = value.map{ |resource| attributes_as_fields(resource) }
+              else
+                attributes[name] = attributes_as_fields(value)
+              end
+            end
+          end
+        end
+
+        attributes
+      end
+
+      # TODO: document
+      def attributes_from_properties_hash(record)
+        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.name] = attributes_as_fields(value)
+            end
+        end
+
+        attributes
+      end
+
+      # Runs the given block within the context of a Mongo collection.
+      #
+      # @param [Model] model
+      #   The model whose collection is to be scoped.
+      #
+      # @yieldparam [Mongo::Collection]
+      #   The Mongo::Collection instance for the given model
+      #
+      # @api private
+      def with_collection(model)
+        begin
+          yield database.collection(model.storage_name(name))
+        rescue Exception => exception
+          DataMapper.logger.error(exception.to_s)
+          raise exception
+        end
+      end
+
+      # Returns the Mongo::DB instance for this process.
+      #
+      # @return [Mongo::DB]
+      #
+      # @raise [ConnectionError]
+      #   If the database requires you to authenticate, and the given username
+      #   or password was not correct, a ConnectionError exception will be
+      #   raised.
+      #
+      # @api semipublic
+      def database
+        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'
+          end
+        end
+
+        @database
+      end
+
+      # Returns the Mongo::Connection instance for this process
+      #
+      # @todo Reconnect if the connection has timed out, or if the process has
+      #       been forked.
+      #
+      # @return [Mongo::Connection]
+      #
+      # @api semipublic
+      def connection
+        @connection ||= ::Mongo::Connection.new(*@options.values_at(:host, :port))
+      end
+    end # Adapter
+  end # Mongo
+
+  Adapters::MongoAdapter = DataMapper::Mongo::Adapter
+  Adapters.const_added(:MongoAdapter)
+end # DataMapper

data/lib/mongo_adapter/aggregates.rb

@@ -0,0 +1,21 @@
+module DataMapper
+  module Mongo
+    module Aggregates
+      # TODO: document
+      # @api semipublic
+      def aggregate(query)
+        operator = if query.fields.size == 1 && query.fields.first.target == :all
+          :count
+        else
+          :group
+        end
+
+        with_collection(query.model) do |collection|
+          Query.new(collection, query).send(operator)
+        end
+      end
+    end # class Aggregates
+  end # module Mongo
+
+  Aggregates::MongoAdapter = DataMapper::Mongo::Aggregates
+end # module DataMapper

data/lib/mongo_adapter/conditions.rb

@@ -0,0 +1,100 @@
+module DataMapper
+  module Mongo
+    # Used to filter records from Mongo::Collection according to the
+    # conditions defined in a DataMapper::Query. Warns when attempting to use
+    # operations which aren't supported by MongoDB.
+    class Conditions
+      include DataMapper::Query::Conditions
+
+      # Returns the query operation
+      #
+      # @return [DataMapper::Query::AbstractOperation]
+      #   The operation which will be used to filter the collection.
+      #
+      # @api semipublic
+      attr_reader :operation
+
+      # Creates a new Conditions instance
+      #
+      # @param [DataMapper::Query::AbstractOperation] query_operation
+      #   The top-level operation from DataMapper::Query#conditions
+      #
+      # @api private
+      def initialize(query_operation)
+        @operation = verify_operation(query_operation)
+      end
+
+      # Filters a collection according to the Conditions
+      #
+      # @param [Enumerable<Hash>] collection
+      #   A collection of hashes which correspond to resource values
+      #
+      # @return [Enumerable<Hash>]
+      #   Returns the collection without modification if the condition has no
+      #   operations, otherwise it returns a copy of the collection with only
+      #   the matching records.
+      #
+      # @api private
+      def filter_collection!(collection)
+        @operation.operands.empty? ? collection : collection.delete_if {|record| !@operation.matches?(record)}
+      end
+
+      private
+
+      # Returns a copy of the operation, removing _from the original_ any
+      # operands which are incompatible with MongoDB.
+      #
+      # @param [DataMapper::Query::AbstractOperation] query_operation
+      #   The top-level operation from DataMapper::Query#conditions
+      #
+      # @return [DataMapper::Query::AbstractOperation]
+      #
+      # @api private
+      def verify_operation(query_operation)
+        operation = query_operation.dup.clear
+
+        query_operation.each do |operand|
+          if not_supported?(operand)
+            query_operation.operands.delete(operand)
+            operation << operand
+          elsif operand.kind_of?(AbstractOperation)
+            operation << verify_operation(operand)
+          end
+        end
+
+        operation
+      end
+
+      # Checks if a given operand is supported by MongoDB.
+      #
+      # 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
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def not_supported?(operand)
+        case operand
+        when OrOperation
+          true
+        when RegexpComparison
+          if operand.negated?
+            true
+          end
+        when InclusionComparison
+          if operand.negated?
+            true
+          end
+        else
+          false
+        end
+      end
+
+    end # Conditions
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/embedded_model.rb

@@ -0,0 +1,187 @@
+module DataMapper
+  module Mongo
+    module EmbeddedModel
+      extend Chainable
+      include DataMapper::Model
+
+      # Creates a new Model class with default_storage_name +storage_name+
+      #
+      # If a block is passed, it will be eval'd in the context of the new Model
+      #
+      # @param [Proc] block
+      #   a block that will be eval'd in the context of the new Model class
+      #
+      # @return [Model]
+      #   the newly created Model class
+      #
+      # @api semipublic
+      def self.new(&block)
+        model = Class.new
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        include DataMapper::Mongo::EmbeddedResource
+
+        def self.name
+          to_s
+        end
+        RUBY
+
+        model.instance_eval(&block) if block
+        model
+      end
+
+      # Methods copied from DataMapper::Model
+
+      # Return all models that extend the Model module
+      #
+      #   class Foo
+      #     include DataMapper::Resource
+      #   end
+      #
+      #   DataMapper::Model.descendants.first   #=> Foo
+      #
+      # @return [DescendantSet]
+      #   Set containing the descendant models
+      #
+      # @api semipublic
+      def self.descendants
+        @descendants ||= DescendantSet.new
+      end
+
+      # Return all models that inherit from a Model
+      #
+      #   class Foo
+      #     include DataMapper::Resource
+      #   end
+      #
+      #   class Bar < Foo
+      #   end
+      #
+      #   Foo.descendants.first   #=> Bar
+      #
+      # @return [Set]
+      #   Set containing the descendant classes
+      #
+      # @api semipublic
+      attr_reader :descendants
+
+      # Appends a module for inclusion into the model class after Resource.
+      #
+      # This is a useful way to extend Resource while still retaining a
+      # self.included method.
+      #
+      # @param [Module] inclusions
+      #   the module that is to be appended to the module after Resource
+      #
+      # @return [Boolean]
+      #   true if the inclusions have been successfully appended to the list
+      #
+      # @api semipublic
+      def self.append_inclusions(*inclusions)
+        extra_inclusions.concat inclusions
+
+        # Add the inclusion to existing descendants
+        descendants.each do |model|
+          inclusions.each { |inclusion| model.send :include, inclusion }
+        end
+
+        true
+      end
+
+      # The current registered extra inclusions
+      #
+      # @return [Set]
+      #
+      # @api private
+      def self.extra_inclusions
+        @extra_inclusions ||= []
+      end
+
+      # Extends the model with this module after Resource has been included.
+      #
+      # This is a useful way to extend Model while still retaining a self.extended method.
+      #
+      # @param [Module] extensions
+      #   List of modules that will extend the model after it is extended by Model
+      #
+      # @return [Boolean]
+      #   whether or not the inclusions have been successfully appended to the list
+      #
+      # @api semipublic
+      def self.append_extensions(*extensions)
+        extra_extensions.concat extensions
+
+        # Add the extension to existing descendants
+        descendants.each do |model|
+          extensions.each { |extension| model.extend(extension) }
+        end
+
+        true
+      end
+
+      # The current registered extra extensions
+      #
+      # @return [Set]
+      #
+      # @api private
+      def self.extra_extensions
+        @extra_extensions ||= []
+      end
+
+      # @api private
+      def self.extended(model)
+        descendants = self.descendants
+
+        descendants << model
+
+        model.instance_variable_set(:@valid,         false)
+        model.instance_variable_set(:@base_model,    model)
+        model.instance_variable_set(:@storage_names, {})
+        model.instance_variable_set(:@default_order, {})
+        model.instance_variable_set(:@descendants,   descendants.class.new(model, descendants))
+
+        extra_extensions.each { |mod| model.extend(mod)         }
+        extra_inclusions.each { |mod| model.send(:include, mod) }
+      end
+
+      # @api private
+      chainable do
+        def inherited(model)
+          descendants = self.descendants
+
+          descendants << model
+
+          model.instance_variable_set(:@valid,         false)
+          model.instance_variable_set(:@base_model,    base_model)
+          model.instance_variable_set(:@storage_names, @storage_names.dup)
+          model.instance_variable_set(:@default_order, @default_order.dup)
+          model.instance_variable_set(:@descendants,   descendants.class.new(model, descendants))
+
+          # TODO: move this into dm-validations
+          if respond_to?(:validators)
+            validators.contexts.each do |context, validators|
+              model.validators.context(context).concat(validators)
+            end
+          end
+        end
+      end
+
+      # end of DataMapper::Model methods
+
+      append_extensions DataMapper::Model::Hook
+      append_extensions DataMapper::Model::Property
+      append_extensions DataMapper::Model::Relationship
+
+      # @overrides DataMapper::Model#assert_valid
+      def assert_valid
+        return if @valid
+        @valid = true
+
+        if properties.empty?
+          raise IncompleteModelError, "#{self.name} must have at least one property to be valid"
+        end
+      end
+
+    end # EmbeddedModel
+  end # Mongo
+end # DataMapper