dm-mongo-adapter 0.2.0.pre1

data/lib/mongo_adapter/migrations.rb

@@ -0,0 +1,45 @@
+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
+
+  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
+
+      def create_model_storage(model)
+        return false if storage_exists?(model.storage_name)
+        database.create_collection(model.storage_name)
+      end
+
+      def upgrade_model_storage(model)
+        create_model_storage(model)
+      end
+
+      def destroy_model_storage(model)
+        database.drop_collection(model.storage_name)
+      end
+
+     end
+  end
+end
+
+DataMapper::Mongo.send(:include, DataMapper::Mongo::Migrations)

data/lib/mongo_adapter/model.rb

@@ -0,0 +1,89 @@
+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
+
+      private
+
+      # @api private
+      def const_missing(name)
+        if DataMapper::Mongo::Types.const_defined?(name)
+          DataMapper::Mongo::Types.const_get(name)
+        else
+          super
+        end
+      end
+    end # Model
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/model/embedment.rb

@@ -0,0 +1,215 @@
+module DataMapper
+  module Mongo
+    module Model
+      # Embedment extends Mongo-based resources to allow resources to be
+      # embedded within a document, while providing relationship-like `has 1`
+      # and `has n` functionality.
+      #
+      # @example
+      #   class User
+      #     include DataMapper::Mongo::Resource
+      #
+      #     property :id,   ObjectID
+      #     property :name, String
+      #
+      #     embeds n, :addresses, :model => Address
+      #   end
+      #
+      #   class Address
+      #     include DataMapper::Mongo::EmbeddedResource
+      #
+      #     property :street,    String
+      #     property :post_code, String
+      #   end
+      #
+      module Embedment
+        extend Chainable
+
+        # Options which cannot be used on Embedments.
+        ILLEGAL_OPTS = [:through, :remote_name, :via, :inverse, :parent_key]
+
+        # @api private
+        def self.extended(model)
+          model.instance_variable_set(:@embedments, {})
+        end
+
+        chainable do
+          # @api private
+          def inherited(model)
+            model.instance_variable_set(:@embedments, {})
+
+            @embedments.each { |name, embedment| model.embedments[name] ||= embedment }
+
+            super
+          end
+        end
+
+        chainable do
+          # @api public
+          def method_missing(method, *args, &block)
+            if respond_to?(:embedments) && embedment = embedments[method]
+              return embedment
+            end
+
+            super
+          end
+        end
+
+        # Returns the embedments on this model
+        #
+        # @return [Hash]
+        #   Embedments on this model, where each hash key is the embedment
+        #   name, and each value is the Embedments::Relationship instance.
+        #
+        # @api semipublic
+        def embedments
+          @embedments ||= {}
+        end
+
+        # A short-hand, clear syntax for defining one-to-one and one-to-many
+        # embedments -- where an embedded resource is held within the parent
+        # document in the database.
+        #
+        # @example
+        #   embed 1,    :friend         # one friend
+        #   embed n,    :friends        # many friends
+        #   embed 1..3, :friends        # many friends (at least 1, at most 3)
+        #   embed 3,    :friends        # many friends (exactly 3)
+        #   embed 1,    :friend, 'User' # one friend with the class User
+        #
+        # @param cardinality [Integer, Range, Infinity]
+        #   Cardinality that defines the embedment type and constraints
+        # @param name [Symbol]
+        #   The name that the embedment will be referenced by
+        # @param model [Model, #to_str]
+        #   The target model of the embedment
+        # @param opts [Hash]
+        #   An options hash
+        #
+        # @option :model[Model, String] The name of the class to associate
+        #   with, if omitted then the model class name is assumed to match the
+        #   (optional) third parameter, or the embedment name.
+        #
+        # @return [Embedment::Relationship]
+        #   The embedment that was created to reflect either a one-to-one or
+        #   one-to-many embedment.
+        #
+        # @raise [ArgumentError]
+        #   If the cardinality was not understood. Should be a Integer, Range
+        #   or Infinity(n)
+        #
+        # @api public
+        def embeds(cardinality, name, *args)
+          assert_kind_of 'cardinality', cardinality, Integer, Range, Infinity.class
+          assert_kind_of 'name',        name,        Symbol
+
+          model   = extract_model(args)
+          options = extract_options(args)
+
+          min, max = extract_min_max(cardinality)
+          options.update(:min => min, :max => max)
+
+          assert_valid_options(options)
+
+          if options.key?(:model) && model
+            raise ArgumentError, 'should not specify options[:model] if passing the model in the third argument'
+          end
+
+          model ||= options.delete(:model)
+
+          klass = if max > 1
+            Embedments::OneToMany::Relationship
+          else
+            Embedments::OneToOne::Relationship
+          end
+
+          embedment = embedments[name] = klass.new(name, model, self, options)
+
+          descendants.each do |descendant|
+            descendant.embedments[name] ||= embedment
+          end
+
+          create_embedment_reader(embedment)
+          create_embedment_writer(embedment)
+
+          embedment
+        end
+
+        # @todo Investigate as a candidate for removal.
+        #   Added 26ae98e1 as an equivelent of belongs_to but _probably_ isn't
+        #   of much use in embedded resources (since it would be perfectly
+        #   acceptable for an embedment to be used in multiple models). My
+        #   opinion is that embedments should always be declared from the
+        #   parent side (DM::M::Resource), rather the child side
+        #   (DM::M::EmbeddedResource).
+        #
+        #   ~antw
+        #
+        # @api public
+        def embedded_in(name, *args)
+          return NotImplementedError
+        end
+
+        def assert_valid_options(options)
+          ILLEGAL_OPTS.each do |option|
+            raise ArgumentError, "+options[:#{option}]+ should not be " \
+              "specified on a relationship" if options.key?(option)
+          end
+
+          super
+        end
+
+        # Dynamically defines a reader method
+        #
+        # Creates a public method matching the name of the embedment which can
+        # be used to access the embedded resource(s).
+        #
+        # @param [Embedment::Relationship] embedment
+        #   The embedment for which a reader should be created
+        #
+        # @api private
+        def create_embedment_reader(embedment)
+          name        = embedment.name
+          reader_name = name.to_s
+
+          return if resource_method_defined?(reader_name)
+
+          reader_visibility = embedment.reader_visibility
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            #{reader_visibility}                               # public
+            def #{reader_name}(query = nil)                    # def author(query = nil)
+              embedments[#{name.inspect}].get(self, query)     #   embedment[:author].get(self, query)
+            end                                                # end
+          RUBY
+        end
+
+        # Dynamically defines a writer method
+        #
+        # Creates a public method matching the name of the embedment which can
+        # be used to set the embedded resource(s).
+        #
+        # @param [Embedment::Relationship] embedment
+        #   The embedment for which a writer should be created
+        #
+        # @api private
+        def create_embedment_writer(embedment)
+          name        = embedment.name
+          writer_name = "#{name}="
+
+          return if resource_method_defined?(writer_name)
+
+          writer_visibility = embedment.writer_visibility
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            #{writer_visibility}                                # public
+            def #{writer_name}(target)                          # def author=(target)
+              embedments[#{name.inspect}].set(self, target)      #   embedment[:author].set(self, target)
+            end                                                 # end
+          RUBY
+        end
+      end
+
+    end # Model
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/modifier.rb

@@ -0,0 +1,85 @@
+module DataMapper
+  module Mongo
+    module Modifier
+      # TODO: document
+      # @api public
+      def increment(property, value)
+        attribute_set(property, attribute_get(property) + value)
+
+        if modifier(:inc, property => value)
+          original_attributes.clear
+        end
+      end
+
+      # TODO: document
+      # @api public
+      def decrement(property, value)
+        attribute_set(property, attribute_get(property) - value)
+
+        if modifier(:inc, property => -value.abs)
+          original_attributes.clear
+        end
+      end
+
+      # TODO: document
+      # @api public
+      def set(args)
+        modifier(:set, args)
+
+        args.keys.each do |key|
+          attribute_set(key, args[key])
+        end
+      end
+
+      # TODO: document
+      # @api public
+      def unset(*args)
+        new_args = {}
+        
+        args.each do |arg|
+          new_args[arg] = 1
+        end
+
+        modifier(:unset, new_args)
+      end
+
+      # TODO: document
+      # @api public
+      def push
+
+      end
+
+      # TODO: document
+      # @api public
+      def push_all
+
+      end
+
+      # TODO: document
+      # @api public
+      def pop
+
+      end
+
+      # TODO: document
+      # @api public
+      def pull
+
+      end
+
+      # TODO: document
+      # @api public
+      def pull_all
+
+      end
+
+      private
+
+      # TODO: document
+      # @api private
+      def modifier(operation, properties)
+        repository.adapter.execute([self], "$#{operation}" => properties)
+      end
+    end
+  end
+end

data/lib/mongo_adapter/query.rb

@@ -0,0 +1,252 @@
+module DataMapper
+  module Mongo
+    # 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::Query::Conditions
+
+      # Creates a new Query instance
+      #
+      # @param [Mongo::Collection] collection
+      # @param [DataMapper::Query] query
+      #
+      # @api semipublic
+      def initialize(collection, query)
+        assert_kind_of 'collection', collection, ::Mongo::Collection
+        assert_kind_of 'query', query, DataMapper::Query
+
+        @collection = collection
+        @query      = query
+        @statements = {}
+        @conditions = Conditions.new(query.conditions)
+      end
+
+      # Applies the query to the collection
+      #
+      # Reads the query options, fetches the resources matching the query
+      # statements and filters according to the conditions.
+      #
+      # @return [Mongo::Collection]
+      #
+      # @api semipublic
+      def read
+        setup_conditions_and_options
+        find
+      end
+
+      # TODO: document
+      # @api semipublic
+      def count
+        setup_conditions_and_options
+
+        # 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?
+          [@collection.count]
+        else
+          [find.size]
+        end
+      end
+
+      # TODO: document
+      # @api semipublic
+      def group
+        setup_conditions_and_options
+
+        property_names = []
+        operators = []
+        keys = []
+
+        @query.fields.each do |field|
+          if field.kind_of?(DataMapper::Query::Operator)
+            operators << field
+            property_names << field.target.name
+          else
+            keys << field.name
+            property_names << field.name
+          end
+        end
+
+        if operators.blank?
+          initial  = {}
+          reduce   = JavaScript::Reduce.new.to_s
+          finalize = nil
+        else
+          js_operation = JavaScript::Operation.new(operators)
+
+          initial  = js_operation.initial
+          reduce   = js_operation.reduce
+          finalize = js_operation.finalize
+
+          keys = keys - initial.keys
+        end
+        
+        @collection.group(keys, @statements, initial, reduce, true, finalize).map do |records|
+          records.to_mash.symbolize_keys.only(*property_names)
+        end
+      end
+
+      private
+
+      # TODO: document
+      # @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?
+
+        conditions_statement(@query.conditions)
+      end
+
+      # TODO: document
+      # @api private
+      def find
+        @conditions.filter_collection!(@collection.find(@statements, @options).to_a)
+      end
+
+      # Takes a condition and returns a Mongo-compatible hash
+      #
+      # @param [DataMapper::Query::Conditions::AbstractOperation, DataMapper::Query::Conditions::AbstractComparison] operation
+      #   An operation to be made suitable for use with Mongo
+      # @param [Boolean] affirmative
+      #   Are we looking for resources which match the condition (true), or
+      #   those which do not match (false)
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def conditions_statement(conditions, affirmative = true)
+        case conditions
+        when AbstractOperation  then operation_statement(conditions, affirmative)
+        when AbstractComparison then comparison_statement(conditions, affirmative)
+        end
+      end
+
+      # Takes a Operation condition and returns a Mongo-compatible hash
+      #
+      # @param [DataMapper::Query::Conditions::Operation] operation
+      #   An operation to be made suitable for use with Mongo
+      # @param [Boolean] affirmative
+      #   Are we looking for resources which match the condition (true), or
+      #   those which do not match (false)
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def operation_statement(operation, affirmative = true)
+        case operation
+        when NotOperation then conditions_statement(operation.first, !affirmative)
+        when AndOperation then operation.each{|op| conditions_statement(op, affirmative)}
+        when OrOperation  then operation.each{|op| conditions_statement(op, affirmative)}
+        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.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
+      #   An comparison to be made suitable for use with Mongo
+      # @param [Boolean] affirmative
+      #   Are we looking for resources which match the condition (true), or
+      #   those which do not match (false)
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def comparison_statement(comparison, affirmative = true)
+        if comparison.relationship?
+          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
+
+        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
+
+        operator.is_a?(Hash) ?
+          (@statements[field.to_sym] ||= {}).merge!(operator) : @statements[field.to_sym] = operator
+      end
+
+      # Creates Mongo's equivalent of an IN() condition
+      #
+      # @param [DataMapper::Query::Conditions::Comparison] comparison
+      #   An comparison to be made suitable for use with Mongo
+      # @param [Object] value
+      #   The value to match against.
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def inclusion_comparison_operator(comparison, value)
+        if value.kind_of?(Range)
+          {'$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
+          value
+        else
+          {'$in'  => value}
+        end
+      end
+
+      # Constructs a sort statement which can be used by the Mongo library
+      #
+      # Mongo::Collection#find requires that sort statements consist of an
+      # array where each element is another array containing the field name
+      # and the sort order.
+      #
+      # @param [Enumerable<DataMapper::Query::Direction>]
+      #
+      # @return [Array<Array>]
+      #
+      # @api private
+      def sort_statement(conditions)
+        conditions.inject([]) do |sort_arr, condition|
+          sort_arr << [condition.target.field, condition.operator == :asc ? 'ascending' : 'descending']
+        end
+      end
+
+    end # Query
+  end # Mongo
+end # DataMapper