dm-mongo-adapter 0.2.0.pre3 → 0.6.0

data/lib/mongo_adapter/model/embedment.rb

@@ -1,215 +0,0 @@
-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/types/date.rb

@@ -1,24 +0,0 @@
-module DataMapper
-  module Mongo
-    module Types
-      class Date < DataMapper::Type
-        primitive ::Time
-
-        def self.load(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

@@ -1,28 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

data/lib/mongo_adapter/types/object_id.rb

@@ -1,72 +0,0 @@
-module DataMapper
-  module Mongo
-    module Types
-      # 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::Type
-        primitive ::Object
-        key true
-        field "_id"
-        required false
-
-        # Returns the ObjectID as a string; suitable for use in a Resource
-        #
-        # @return [String]
-        #
-        # @api public
-        def self.load(value, property)
-          typecast(value, property)
-        end
-
-        # Returns the ObjectID 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 or ObjectID')
-          end
-        end
-
-        # Returns the ObjectID 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 or ObjectID')
-          end
-        end
-
-      end # ObjectID
-    end # Types
-  end # Mongo
-end # DataMapper

data/lib/mongo_adapter/types/objects.rb

@@ -1,31 +0,0 @@
-module DataMapper
-  module Mongo
-    module Types
-      class EmbeddedArray < DataMapper::Type
-        primitive Object
-      end
-
-      class EmbeddedHash < DataMapper::Type
-        primitive Object
-
-        # @api public
-        def self.load(value, property)
-          typecast(value, property)
-        end
-
-        # @api semipublic
-        def self.typecast(value, property)
-          case value
-          when NilClass
-            nil
-          when Hash
-            value.to_mash.symbolize_keys
-          when Array
-            value.empty? ? Mash.new : [value].to_mash.symbolize_keys
-          end
-        end
-      end #EmbeddedHash
-
-    end # Types
-  end # Mongo
-end # DataMapper