dm-mongo-adapter 0.2.0.pre1

data/lib/mongo_adapter/query/java_script.rb

@@ -0,0 +1,145 @@
+module DataMapper
+  module Mongo
+    class Query
+      # TODO: document
+      module JavaScript
+        class Operation
+          attr_reader :initial
+
+          # TODO: document
+          # @api semipublic
+          def initialize(fields)
+            @initial = {}
+            @reduce  = Reduce.new(fields)
+
+            if @reduce.operations.values.include?(:avg)
+              @finalize = Finalize.new(fields.select{ |field| field.operator == :avg })
+            end
+
+            fields.each do |field|
+              field_name = field.target.name
+
+              @initial[field_name] = 0
+
+              if field.operator == :avg
+                @initial["#{field_name}_count"] = 0
+              end
+            end
+          end
+
+          # TODO: document
+          # @api semipublic
+          def reduce
+            @reduce.create
+          end
+
+          # TODO: document
+          # @api semipublic
+          def finalize
+            @finalize ? @finalize.create : nil
+          end
+        end
+
+        class Function
+          attr_reader :operations
+
+          # TODO: document
+          # @api semipublic
+          def initialize(fields=[])
+            @operations = {}
+
+            fields.each do |field|
+              @operations[field.target.name] = field.operator
+            end
+          end
+
+          # TODO: document
+          # @api public
+          def to_s
+            create
+          end
+
+          # TODO: document
+          # @api semipublic
+          def create(*args, &block)
+            @function ||= "function(#{args.join(', ')}) { #{yield.flatten.join(';') if block_given?} }"
+          end
+        end
+
+        class Reduce < Function
+          # TODO: document
+          # @api semipublic
+          def create
+            super('doc', 'out') do
+              @operations.map do |field, operation|
+                send(operation, field)
+              end
+            end
+          end
+
+          private
+
+          # TODO: document
+          # @api private
+          def count(field)
+            "out.#{field}++"
+          end
+
+          # TODO: document
+          # @api private
+          def min(field)
+            <<-JS
+              if (doc.#{field} < doc.#{field} || out.#{field} == 0) {
+                out.#{field} = doc.#{field};
+              }
+            JS
+          end
+
+          # TODO: document
+          # @api private
+          def max(field)
+            <<-JS
+              if (doc.#{field} > out.#{field}) {
+                out.#{field} = doc.#{field};
+              }
+            JS
+          end
+
+          # TODO: document
+          # @api private
+          def sum(field)
+            <<-JS
+              out.#{field} += doc.#{field}
+            JS
+          end
+
+          # TODO: document
+          # @api private
+          def avg(field)
+            [sum(field), count("#{field}_count")]
+          end
+        end
+
+        class Finalize < Function
+          # TODO: document
+          # @api semipublic
+          def create
+            super('out') do
+              @operations.map do |field, operation|
+                send(operation, field)
+              end
+            end
+          end
+
+          private
+
+          # TODO: document
+          # @api private
+          def avg(field)
+            "out.#{field} = out.#{field} / out.#{field}_count"
+          end
+        end
+      end # JavaScript
+    end # Query
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/resource.rb

@@ -0,0 +1,147 @@
+module DataMapper
+  module Mongo
+    # Used in preference over DataMapper::Resource to add MongoDB-specific
+    # functionality to models.
+    module Resource
+      def self.included(model)
+        model.send(:include, DataMapper::Resource)
+        model.send(:include, ResourceMethods)
+        model.send(:include, Modifier)
+
+        # Needs to be after the inclusion of DM::Resource so as to overwrite
+        # methods added by DM::Model.
+        model.extend(Model)
+      end
+
+      module ResourceMethods
+        # monkey patching based on this: http://github.com/datamapper/dm-core/commit/3332db6c25ab9cea9ba58ce62a9ad3038303baa1
+        # TODO: remove once dm-core 0.10.3 is released
+        def eager_load(properties)
+          unless properties.empty? || key.nil? || collection.nil?
+            collection.reload(:fields => properties)
+          end
+
+          self
+        end
+
+        # Assign values to multiple attributes in one call (mass assignment)
+        #
+        # Overrides attributes= in dm-core so as to permit assignments to
+        # embedments.
+        #
+        # @param [Hash] attributes
+        #   names and values of attributes to assign
+        #
+        # @return [Hash]
+        #   names and values of attributes assigned
+        #
+        # @api public
+        def attributes=(attributes)
+          attributes.each do |name, value|
+            name.set(self, value) if name.kind_of?(Embedments::Relationship)
+          end
+
+          super(attributes)
+        end
+
+        # Checks if the resource, or embedded documents, have unsaved changes
+        #
+        # @return [Boolean]
+        #  True if resource may be persisted
+        #
+        # @overrides DataMapper::Resource#dirty?
+        #
+        # @api public
+        def dirty?
+          super || run_once(true) { dirty_embedments? }
+        end
+
+        # Checks if any embedded documents have unsaved changes
+        #
+        # @return [Boolean]
+        #   True if any embedded documents can be persisted
+        #
+        # @api private
+        def dirty_embedments?
+          embedments.values.any? do |embedment|
+            embedment.loaded?(self) && case embedment
+            when Embedments::OneToOne::Relationship  then embedment.get!(self).dirty?
+            when Embedments::OneToMany::Relationship then embedment.get!(self).any? { |r| r.dirty? }
+            else false
+            end
+          end
+        end
+
+        # Hash of attributes that have unsaved changes
+        #
+        # @return [Hash]
+        #   attributes that have unsaved changes
+        #
+        # @overrides DataMapper::Resource#dirty_attributes
+        #
+        # @api semipublic
+        def dirty_attributes
+          embedded_attributes = {}
+
+          each_embedment do |name, target|
+            case (embedment = embedments[name])
+            when Embedments::OneToMany::Relationship
+              target.each do |resource|
+                if resource.dirty?
+                  embedded_attributes[embedment] ||= []
+                  embedded_attributes[embedment] << resource.dirty_attributes
+                end
+              end
+            when Embedments::OneToOne::Relationship
+              # Relationship target is a single resource.
+              if target.dirty?
+                embedded_attributes[embedment] = target.dirty_attributes
+              end
+            end
+          end
+
+          super.merge(embedded_attributes)
+        end
+
+        # Saves the resource and it's embedments
+        #
+        # @return [Boolean]
+        #   True if the resource was successfully saved
+        #
+        # @overrides DataMapper::Resource#save_self
+        #
+        # @api semipublic
+        def save_self(safe = true)
+          super && embedments.values.each do |e|
+            e.loaded?(self) && Array(e.get!(self)).each { |r| r.original_attributes.clear }
+          end
+        end
+
+        private
+
+        # The embedments (relationships to embedded objects) on this model
+        #
+        # @return [Hash<Symbol,Embedments::Relationship>]
+        #
+        # @api private
+        def embedments
+          model.embedments
+        end
+
+        # Iterates through each loaded embedment, yielding the name and value
+        #
+        # @yieldparam [Symbol]
+        #   The name of the embedment
+        # @yieldparam [Mongo::Collection]
+        #   The embedded resource, or collection of embedded resources
+        #
+        # @api private
+        def each_embedment
+          embedments.each { |name, embedment|
+            embedment.loaded?(self) && yield(name, embedment.get!(self)) }
+        end
+      end # ResourceMethods
+
+    end # Resource
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/types/date.rb

@@ -0,0 +1,28 @@
+module DataMapper
+  module Mongo
+    module Types
+      class Date < DataMapper::Type
+        primitive ::Time
+
+        def self.load(value, property)
+          self.typecast(value, property)
+        end
+
+        def self.dump(value, property)
+          self.typecast(value, property)
+        end
+
+        def self.typecast(value, property)
+          case value
+          when ::Date
+            Time.utc(value.year, value.month, value.day)
+          when ::Time
+            ::Date.new(value.year, value.month, value.day)
+          when NilClass, Range
+            value
+          end
+        end
+      end
+    end # Types
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/types/date_time.rb

@@ -0,0 +1,28 @@
+module DataMapper
+  module Mongo
+    module Types
+      class DateTime < DataMapper::Type
+        primitive Time
+
+        def self.load(value, property)
+          self.typecast(value, property)
+        end
+
+        def self.dump(value, property)
+          self.typecast(value, property)
+        end
+
+        def self.typecast(value, property)
+          case value
+          when Time
+            value.to_datetime
+          when ::DateTime
+            value.to_time.utc
+          when NilClass, Range
+            value
+          end
+        end
+      end
+    end # Types
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/types/db_ref.rb

@@ -0,0 +1,65 @@
+module DataMapper
+  module Mongo
+    module Types
+      # 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::Type
+        primitive ::Object
+
+        # Returns the DBRef as a string; suitable for use in a Resource
+        #
+        # @return [String]
+        #
+        # @api public
+        def self.load(value, property)
+          typecast(value, property)
+        end
+
+        # Returns the DBRef as a Mongo ObjectID; suitable to be passed to the
+        # Mongo library
+        #
+        # @return [Mongo::ObjectID] The dumped ID.
+        #
+        # @api public
+        def self.dump(value, property)
+          case value
+          when NilClass
+            nil
+          when String
+            ::Mongo::ObjectID.from_string(value)
+          when ::Mongo::ObjectID
+            value
+          else
+            raise ArgumentError.new('+value+ must be nil, String, ObjectID')
+          end
+        end
+
+        # Returns the DBRef as a string
+        #
+        # @return [String]
+        #
+        # @api semipublic
+        def self.typecast(value, property)
+          case value
+          when NilClass
+            nil
+          when String
+            value
+          when ::Mongo::ObjectID
+            value.to_s
+          else
+            raise ArgumentError.new('+value+ must be nil, String, ObjectID')
+          end
+        end
+
+      end # DBRef
+    end # Types
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/types/discriminator.rb

@@ -0,0 +1,32 @@
+module DataMapper
+  module Mongo
+    module Types
+      class Discriminator < DataMapper::Types::Discriminator
+        primitive String
+        default   lambda { |resource, property| resource.model.to_s }
+        
+        def self.load(value, property)
+          typecast(value, property)
+        end
+
+        def self.dump(value, property)
+          value.name
+        end
+
+        def self.typecast(value, property)
+          if value
+            if value.is_a?(String)
+              Extlib::Inflection.constantize(value)
+            else
+              value
+            end
+          end
+        end
+
+        def self.==(other)
+          other == DataMapper::Types::Discriminator || super
+        end
+      end
+    end
+  end
+end