dm-mongo-adapter 0.2.0.pre1

data/lib/mongo_adapter/embedded_resource.rb

@@ -0,0 +1,134 @@
+module DataMapper
+  module Mongo
+    module EmbeddedResource
+      # Raised when trying to save an EmbeddedResource which doesn't have a
+      # parent set.
+      class MissingParentError < StandardError; end
+
+      include Types
+      include DataMapper::Resource
+
+      def self.included(base)
+        base.extend(DataMapper::Mongo::EmbeddedModel)
+      end
+
+      # @api public
+      alias_method :model, :class
+
+      # Returns the resource to which this EmbeddedResource belongs.
+      #
+      # @return [DataMapper::Mongo::Resource]
+      #   The parent
+      #
+      # @api public
+      attr_reader :parent
+
+      # Gets all the attributes of the EmbeddedResource instance
+      #
+      # @param [Symbol] key_on
+      #   Use this attribute of the Property as keys.
+      #   defaults to :name. :field is useful for adapters
+      #   :property or nil use the actual Property object.
+      #
+      # @return [Hash]
+      #   All the attributes
+      #
+      # @overrides DataMapper::Resource#attributes
+      #
+      # @api public
+      def attributes(key_on=:name)
+        attributes = {}
+
+        fields.each do |property|
+          if model.public_method_defined?(name = property.name)
+            key = case key_on
+            when :name  then name
+            when :field then property.field
+            else             property
+            end
+
+            attributes[key] = __send__(name)
+          end
+        end
+
+        attributes
+      end
+
+      # Sets the resource to which this EmbeddedResource belongs
+      #
+      # @param [DataMapper::Mongo::Resource] resource
+      #   The new parent resource
+      #
+      # @api public
+      def parent=(resource)
+        @parent = resource
+      end
+
+      # Returns whether this resource (or rather, it's parent) has been saved
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def saved?
+        parent && parent.saved?
+      end
+
+      # Returns whether this resource (or rather, it's parent) is unsaved
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def new?
+        !parent? || parent.new?
+      end
+
+      # Returns if the EmbeddedResource has a parent set
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def parent?
+        !parent.nil?
+      end
+
+      # Saves the EmbeddedResource by saving the parent
+      #
+      # @return [Boolean]
+      #   Returns true if the resource was successfully saved, false
+      #   otherwise
+      #
+      # @raise [MissingParentError]
+      #   Raises a MissingParentError if a parent has not been set
+      #
+      # @api public
+      def save
+        if parent?
+          if parent.save
+            original_attributes.clear
+            true
+          end
+        else
+          raise MissingParentError, 'EmbeddedResource needs a parent to be ' \
+                                    'set before it can be saved'
+        end
+      end
+
+      # Checks if the resource has unsaved changes
+      #
+      # @return [Boolean]
+      #  True if resource may be persisted
+      #
+      # @api public
+      def dirty_self?
+        if original_attributes.any?
+          true
+        elsif new?
+          properties.any? { |property| property.default? }
+        else
+          false
+        end
+      end
+
+    end # EmbeddedResource
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/embedments/one_to_many.rb

@@ -0,0 +1,139 @@
+module DataMapper
+  module Mongo
+    module Embedments
+      module OneToMany
+        class Relationship < Embedments::Relationship
+          # Loads and returns embedment target for given source
+          #
+          # @param [DataMapper::Mongo::Resource] source
+          #   The resource whose relationship value is to be retrieved.
+          #
+          # @return [DataMapper::Collection]
+          #
+          # @api semipublic
+          def get(source, other_query = nil)
+            assert_kind_of 'source', source, source_model
+
+            unless loaded?(source)
+              set!(source, collection_for(source, other_query))
+            end
+
+            get!(source)
+          end
+
+          # Sets and returns association target for given source
+          #
+          # @param [DataMapper::Mongo::Resource] source
+          #   The parent resource whose target is to be set.
+          # @param [DataMapper::Mongo::EmbeddedResource] targets
+          #   The embedded resources to be set to the relationship
+          # @param [Boolean] loading
+          #   Do the attributes have to be loaded before being set? Setting
+          #   this to true will typecase the attributes, and set the
+          #   original_values on the resource.
+          #
+          # @api semipublic
+          def set(source, targets, loading=false)
+            assert_kind_of 'source',  source,  source_model
+            assert_kind_of 'targets', targets, Array
+
+            targets = targets.map do |target|
+              case target
+              when Hash
+                load_target(source, target)
+              when DataMapper::Mongo::EmbeddedResource
+                target.parent = source
+                target
+              else
+                raise ArgumentError, 'one-to-many embedment requires an ' \
+                                     'EmbeddedResource or a hash'
+              end
+            end
+
+            set_original_attributes(source, targets) unless loading
+
+            unless loaded?(source)
+              set!(source, collection_for(source))
+            end
+
+            get!(source).replace(targets)
+          end
+
+          private
+
+          # Creates a new collection instance for the source resources.
+          #
+          # @param [DataMapper::Mongo::Resource] source
+          #   The resources to be wrapped in a Collection.
+          #
+          # @return [DataMapper::Collection]
+          #
+          # @api private
+          def collection_for(source, other_query=nil)
+            Collection.new(source, target_model)
+          end
+        end
+
+        # Extends Array to ensure that each EmbeddedResource has it's +parent+
+        # attribute set.
+        class Collection < Array
+          # Returns the resource to which this collection belongs
+          #
+          # @return [DataMapper::Mongo::Resource]
+          #   The resource to which the contained EmbeddedResource instances
+          #   belong.
+          #
+          # @api semipublic
+          attr_reader :source
+
+          # @api semipublic
+          attr_reader :target_model
+
+          # Creates a new Collection instance
+          #
+          # @param [DataMapper::Mongo::Resource] source
+          #   The resource to which the contained EmbeddedResource instances
+          #   belong.
+          #
+          # @api semipublic
+          def initialize(source, target_model)
+            @source = source
+            @target_model = target_model
+          end
+
+          # Adds a new embedded resource to the collection
+          #
+          # @param [DataMapper::Mongo::EmbeddedResource] resource
+          #   The embedded resource to be added.
+          #
+          # @api public
+          def <<(resource)
+            resource.parent = source
+            super(resource)
+          end
+
+          # TODO: document
+          # @api public
+          def dirty?
+            any? { |resource| resource.dirty? }
+          end
+
+          # TODO: document
+          # @api public
+          def save
+            source.save
+          end
+
+          # TODO: document
+          # @api public
+          def new(attributes={})
+            resource = target_model.new(attributes)
+            self. << resource
+            resource
+          end
+        end
+
+      end # OneToMany
+    end # Embedments
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/embedments/one_to_one.rb

@@ -0,0 +1,53 @@
+module DataMapper
+  module Mongo
+    module Embedments
+      module OneToOne
+        class Relationship < Embedments::Relationship
+          # Loads and returns embedment target for given source
+          #
+          # Returns a new instance of the target model if there isn't one set.
+          #
+          # @param [DataMapper::Mongo::Resource] source
+          #   The resource whose relationship value is to be retrieved.
+          #
+          # @return [DataMapper::Mongo::Resource]
+          #
+          # @api semipublic
+          def get(source, other_query = nil)
+            get!(source)
+          end
+
+          # Sets and returns association target for given source
+          #
+          # @param [DataMapper::Mongo::Resource] source
+          #   The resource whose target is to be set.
+          # @param [DataMapper::Mongo::EmbeddedResource] target
+          #   The value to be set to the target
+          # @param [Boolean] loading
+          #   Do the attributes have to be loaded before being set? Setting
+          #   this to true will typecase the attributes, and set the
+          #   original_values on the resource.
+          #
+          # @api semipublic
+          def set(source, target, loading=false)
+            assert_kind_of 'source', source, source_model
+            assert_kind_of 'target', target, target_model, Hash, NilClass
+
+            unless target.nil?
+              if target.kind_of?(Hash)
+                target = load_target(source, target, loading)
+              else
+                target.parent = source
+              end
+
+              set_original_attributes(source, target) unless loading
+            end
+
+            set!(source, target)
+          end
+
+        end # Relationship
+      end # OneToOne
+    end # Embedments
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/embedments/relationship.rb

@@ -0,0 +1,258 @@
+module DataMapper
+  module Mongo
+    module Embedments
+      # Base class for embedment relationships. Each type of relationship
+      # (1 to 1, 1 to n) implements a subclass of this class with methods like
+      # get and set overridden.
+      class Relationship
+        include Extlib::Assertions
+
+        # Relationship name
+        #
+        # @example for :parent relationship in
+        #
+        #   class VersionControl::Commit
+        #     # ...
+        #     belongs_to :parent
+        #   end
+        #
+        #   name is :parent
+        #
+        # @api semipublic
+        attr_reader :name
+
+        # Returns the model class used by the parent side of the relationship
+        #
+        # @return [Resource]
+        #   Model for relationship parent
+        #
+        # @api semipublic
+        attr_reader :source_model
+
+        # Options used to set up this relationship
+        #
+        # @example for :author relationship in
+        #
+        #   class VersionControl::Commit
+        #     # ...
+        #
+        #     belongs_to :author, :model => 'Person'
+        #   end
+        #
+        #   options is a hash with a single key, :model
+        #
+        # @api semipublic
+        attr_reader :options
+
+        # The name of the variable used to store the relationship
+        #
+        # @example for :commits relationship in
+        #
+        #   class VersionControl::Branch
+        #     # ...
+        #
+        #     has n, :commits
+        #   end
+        #
+        #   instance variable name for source will be @commits
+        #
+        # @api semipublic
+        attr_reader :instance_variable_name
+
+        # Returns query options for relationship.
+        #
+        # For this base class, always returns query options has been
+        # initialized with. Overridden in subclasses.
+        #
+        # @api private
+        attr_reader :query
+
+        # Returns the visibility for the source accessor
+        #
+        # @return [Symbol]
+        #   the visibility for the accessor added to the source
+        #
+        # @api semipublic
+        attr_reader :reader_visibility
+
+        # Returns the visibility for the source accessor
+        #
+        # @return [Symbol]
+        #   the visibility for the accessor added to the source
+        #
+        # @api semipublic
+        attr_reader :writer_visibility
+
+        # Loads and returns "other end" of the embedment
+        #
+        # Must be implemented in subclasses.
+        #
+        # @api semipublic
+        def get(resource, other_query = nil)
+          raise NotImplementedError, "#{self.class}#get not implemented"
+        end
+
+        # Gets "other end" of the embedment directly
+        #
+        # @api semipublic
+        def get!(resource)
+          resource.instance_variable_get(instance_variable_name)
+        end
+
+        # Sets value of the "other end" of the embedment on given resource
+        #
+        # Must be implemented in subclasses.
+        #
+        # @api semipublic
+        def set(resource, association)
+          raise NotImplementedError, "#{self.class}#set not implemented"
+        end
+
+        # Sets "other end" of the embedment directly.
+        #
+        # @api semipublic
+        def set!(resource, association)
+          resource.instance_variable_set(instance_variable_name, association)
+        end
+
+        # Returns the model class used by the child side of the relationship
+        #
+        # @return [Resource]
+        #   Model for relationship child
+        #
+        # @api semipublic
+        def target_model
+          if defined?(@target_model)
+            @target_model
+          elsif @target_model_name
+            @target_model = (@source_model || Object).find_const(@target_model_name)
+          else
+            raise "No model type defined for relationship #{@name}"
+          end
+        end
+
+        # @api semipublic
+        def set_original_attributes(resource, association)
+          Array(association).each do |association|
+            resource.original_attributes[self] = association.original_attributes if association.dirty?
+          end
+        end
+
+        # Checks if "other end" of the embedment is loaded on given resource
+        #
+        # @api semipublic
+        def loaded?(resource)
+          assert_kind_of 'resource', resource, source_model
+
+          resource.instance_variable_defined?(instance_variable_name)
+        end
+
+        # Creates an instance of the target model with its attributes
+        #
+        # @param [DataMapper::Mongo::Resource] source
+        #   The source model to which the target belongs.
+        # @param [Hash, #to_mash] attributes
+        #   The attributes to be set on the embedded resource.
+        # @param [Boolean] loading
+        #   Do the attributes have to be loaded before being set? Setting
+        #   this to true will typecase the attributes, and set the
+        #   original_values on the resource.
+        #
+        # @return [DataMapper::Mongo::EmbeddedResource]
+        #   The initialized embedded resource instance.
+        #
+        # @api semipublic
+        def load_target(source, attributes, loading=false)
+          target = target_model.allocate
+          target.parent = source
+
+          attributes = attributes.to_mash
+
+          target_model.properties.each do |property|
+            property.send(loading ? :set! : :set, target, attributes[property.field])
+          end
+
+          target
+        end
+
+        # Creates and returns Query instance that represents the embedment
+        #
+        # The returned query can be used to fetch target resource(s)
+        # (ex.: articles) for given target resource (ex.: author).
+        #
+        # @return [DataMapper::Mongo::Query]
+        #
+        # @api semipublic
+        def query_for(source, other_query = nil)
+          Query.new
+        end
+
+        # Creates a hash of attributes for the relationship.
+        #
+        # @api semipublic
+        def value(relationship)
+          relationship.model.properties.map { |property| [property, property.get(relationship)] }.to_hash
+        end
+
+        # Test the resource to see if it is a valid target
+        #
+        # @param [Object] relationship
+        #   The resource or collection to be tested
+        #
+        # @return [Boolean]
+        #   True if the resource is valid
+        #
+        # @api semipublic
+        def valid?(relationship)
+          relationship.kind_of?(target_model)
+        end
+
+        # @api public
+        def method_missing(method, *args, &block)
+          target_model.send(method, args, &block)
+        end
+
+        private
+
+        # Creates a new Relationship instance
+        #
+        # @param [DataMapper::Mongo::EmbeddedModel, String] target_model
+        #   The child side of the relationship.
+        # @param [DataMapper::Mongo::Model] source_model
+        #   The parent side of the relationship.
+        # @param [Hash] options
+        #   Options for customising the relationship.
+        #
+        # @option options [Symbol] :reader_visibility
+        #   The visibility of the reader method created on the source model;
+        #   one of public, protected or private.
+        # @option options [Symbol] :writer_visibility
+        #   The visibility of the writer method created on the source model;
+        #   one of public, protected or private.
+        #
+        def initialize(name, target_model, source_model, options={})
+          if target_model.kind_of?(EmbeddedModel)
+            @target_model = target_model
+          elsif target_model.nil?
+            # No model given, infer it from the name.
+            @target_model_name =
+              Extlib::Inflection.camelize(name.to_s.singular).freeze
+          else
+            # We were likely given a string as the target model -- perhaps
+            # because the user's app hasn't loaded yet; get the constant
+            # later in Relationship#target_model.
+            @target_model_name = target_model.to_str.dup.freeze
+          end
+
+          @name = name
+          @source_model = source_model
+          @instance_variable_name = "@#{@name}".freeze
+          @options = options.dup.freeze
+          @reader_visibility = @options.fetch(:reader_visibility, :public)
+          @writer_visibility = @options.fetch(:writer_visibility, :public)
+        end
+
+      end # Relationship
+    end # Embedments
+  end # Mongo
+end # DataMapper