dm-core 1.0.2 → 1.1.0.rc1

data/lib/dm-core/model/relationship.rb

@@ -1,6 +1,8 @@
 # TODO: update Model#respond_to? to return true if method_method missing
 # would handle the message
 
+require 'dm-core/relationship_set'
+
 module DataMapper
   module Model
     module Relationship
@@ -31,7 +33,7 @@ module DataMapper
 
           @relationships.each do |repository_name, relationships|
             model_relationships = model.relationships(repository_name)
-            relationships.each { |name, relationship| model_relationships[name] ||= relationship }
+            relationships.each { |relationship| model_relationships << relationship }
           end
 
           super
@@ -42,7 +44,7 @@ module DataMapper
       #
       # @param [Symbol] repository_name
       #   Name of the repository for which relationships set is returned
-      # @return [Mash]  relationships set for given repository
+      # @return [RelationshipSet]  relationships set for given repository
       #
       # @api semipublic
       def relationships(repository_name = default_repository_name)
@@ -53,7 +55,7 @@ module DataMapper
         default_repository_name = self.default_repository_name
 
         @relationships[repository_name] ||= if repository_name == default_repository_name
-          Mash.new
+          RelationshipSet.new
         else
           relationships(default_repository_name).dup
         end
@@ -124,10 +126,12 @@ module DataMapper
           Associations::OneToOne::Relationship
         end
 
-        relationship = relationships(repository_name)[name] = klass.new(name, model, self, options)
+        relationship = klass.new(name, model, self, options)
+
+        relationships(repository_name) << relationship
 
         descendants.each do |descendant|
-          descendant.relationships(repository_name)[name] ||= relationship
+          descendant.relationships(repository_name) << relationship
         end
 
         create_relationship_reader(relationship)
@@ -161,16 +165,13 @@ module DataMapper
         options    = extract_options(args)
 
         if options.key?(:through)
-          warn "#{model_name}#belongs_to with :through is deprecated, use 'has 1, :#{name}, #{options.inspect}' in #{model_name} instead (#{caller[0]})"
-          return has(1, name, model, options)
+          raise "#{model_name}#belongs_to with :through is deprecated, use 'has 1, :#{name}, #{options.inspect}' in #{model_name} instead (#{caller.first})"
+        elsif options.key?(:model) && model
+          raise ArgumentError, 'should not specify options[:model] if passing the model in the third argument'
         end
 
         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)
 
         repository_name = repository.name
@@ -179,10 +180,12 @@ module DataMapper
         options[:child_repository_name]  = repository_name
         options[:parent_repository_name] = options.delete(:repository)
 
-        relationship = relationships(repository_name)[name] = Associations::ManyToOne::Relationship.new(name, self, model, options)
+        relationship = Associations::ManyToOne::Relationship.new(name, self, model, options)
+
+        relationships(repository_name) << relationship
 
         descendants.each do |descendant|
-          descendant.relationships(repository_name)[name] ||= relationship
+          descendant.relationships(repository_name) << relationship
         end
 
         create_relationship_reader(relationship)
@@ -253,8 +256,6 @@ module DataMapper
         # TODO: update to match Query#assert_valid_options
         #   - perform options normalization elsewhere
 
-        caller_method = caller[1]
-
         if options.key?(:min) && options.key?(:max)
           min = options[:min]
           max = options[:max]
@@ -278,15 +279,9 @@ module DataMapper
         end
 
         if options.key?(:class_name)
-          options[:class_name] = options[:class_name].to_str
-          warn "+options[:class_name]+ is deprecated, use :model instead (#{caller_method})"
-          options[:model] = options.delete(:class_name)
-        end
-
-        if options.key?(:remote_name)
-          options[:remote_name] = options[:remote_name].to_sym
-          warn "+options[:remote_name]+ is deprecated, use :via instead (#{caller_method})"
-          options[:via] = options.delete(:remote_name)
+          raise "+options[:class_name]+ is deprecated, use :model instead (#{caller[1]})"
+        elsif options.key?(:remote_name)
+          raise "+options[:remote_name]+ is deprecated, use :via instead (#{caller[1]})"
         end
 
         if options.key?(:through)
@@ -313,6 +308,20 @@ module DataMapper
         end
       end
 
+      # Defines the anonymous module that is used to add relationships.
+      # Using a single module here prevents having a very large number
+      # of anonymous modules, where each property has their own module.
+      # @api private
+      def relationship_module
+        @relationship_module ||= begin
+          mod = Module.new
+          class_eval do
+            include mod
+          end
+          mod
+        end
+      end
+
       # Dynamically defines reader method
       #
       # @api private
@@ -324,18 +333,16 @@ module DataMapper
 
         reader_visibility = relationship.reader_visibility
 
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          chainable do
-            #{reader_visibility}
-            def #{reader_name}(query = nil)
-              # TODO: when no query is passed in, return the results from
-              #       the ivar directly. This will require that the ivar
-              #       actually hold the resource/collection, and in the case
-              #       of 1:1, the underlying collection is hidden in a
-              #       private ivar, and the resource is in a known ivar
-
-              persisted_state.get(relationships[#{name.inspect}], query)
-            end
+        relationship_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{reader_visibility}
+          def #{reader_name}(query = nil)
+            # TODO: when no query is passed in, return the results from
+            #       the ivar directly. This will require that the ivar
+            #       actually hold the resource/collection, and in the case
+            #       of 1:1, the underlying collection is hidden in a
+            #       private ivar, and the resource is in a known ivar
+
+            persisted_state.get(relationships[#{name.inspect}], query)
           end
         RUBY
       end
@@ -351,14 +358,12 @@ module DataMapper
 
         writer_visibility = relationship.writer_visibility
 
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          chainable do
-            #{writer_visibility}
-            def #{writer_name}(target)
-              relationship = relationships[#{name.inspect}]
-              self.persisted_state = persisted_state.set(relationship, target)
-              persisted_state.get(relationship)
-            end
+        relationship_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{writer_visibility}
+          def #{writer_name}(target)
+            relationship = relationships[#{name.inspect}]
+            self.persisted_state = persisted_state.set(relationship, target)
+            persisted_state.get(relationship)
           end
         RUBY
       end

data/lib/dm-core/property.rb

@@ -1,3 +1,6 @@
+require 'dm-core/resource'
+require 'dm-core/query'
+
 module DataMapper
   # = Properties
   # Properties for a model are not derived from a database structure, but
@@ -17,8 +20,7 @@ module DataMapper
   #   developers on your team to take a model-centric view of development.
   # * it provides the ability to use Ruby's access control functions.
   # * and, because DataMapper only cares about properties explicitly defined
-  # in
-  #   your models, DataMapper plays well with legacy databases, and shares
+  #   in your models, DataMapper plays well with legacy databases, and shares
   #   databases easily with other applications.
   #
   # == Declaring Properties
@@ -30,27 +32,23 @@ module DataMapper
   #     include DataMapper::Resource
   #
   #     property :title,   String,  :required => true  # Cannot be null
-  #     property :publish, Boolean, :default => false   # Default value for new records is false
+  #     property :publish, Boolean, :default => false  # Default value for new records is false
   #   end
   #
   # By default, DataMapper supports the following primitive (Ruby) types
-  # also called core types:
+  # also called core properties:
   #
   # * Boolean
-  # * String (default length is 50)
-  # * Text (limit of 65k characters by default)
+  # * Class (datastore primitive is the same as String. Used for Inheritance)
+  # * Date
+  # * DateTime
+  # * Decimal
   # * Float
   # * Integer
-  # * BigDecimal
-  # * DateTime
-  # * Date
-  # * Time
   # * Object (marshalled out during serialization)
-  # * Class (datastore primitive is the same as String. Used for Inheritance)
-  #
-  # Other types are known as custom types.
-  #
-  # For more information about available Types, see DataMapper::Type
+  # * String (default length is 50)
+  # * Text (limit of 65k characters by default)
+  # * Time
   #
   # == Limiting Access
   # Property access control is uses the same terminology Ruby does. Properties
@@ -205,9 +203,8 @@ module DataMapper
   #
   #  end
   #
-  # This functionality is available with the dm-validations gem, part of the
-  # dm-more bundle. For more information about validations, check the
-  # documentation for dm-validations.
+  # This functionality is available with the dm-validations gem. For more information
+  # about validations, check the documentation for dm-validations.
   #
   # == Default Values
   # To set a default for a property, use the <tt>:default</tt> key.  The
@@ -224,7 +221,7 @@ module DataMapper
   # Word of warning.  Don't try to read the value of the property you're setting
   # the default for in the proc.  An infinite loop will ensue.
   #
-  # == Embedded Values
+  # == Embedded Values (not implemented yet)
   # As an alternative to extraneous has_one relationships, consider using an
   # EmbeddedValue.
   #
@@ -248,8 +245,6 @@ module DataMapper
   #
   #  :key                 name of the key associated with this property.
   #
-  #  :serial              if true, field value is auto incrementing
-  #
   #  :field               field in the data-store which the property corresponds to
   #
   #  :length              string field length
@@ -278,6 +273,31 @@ module DataMapper
   #  All other keys you pass to +property+ method are stored and available
   #  as options[:extra_keys].
   #
+  # == Overriding default Property options
+  #
+  # There is the ability to reconfigure a Property and it's subclasses by explicitly
+  # setting a value in the Property, eg:
+  #
+  #   # set all String properties to have a default length of 255
+  #   DataMapper::Property::String.length(255)
+  #
+  #   # set all Boolean properties to not allow nil (force true or false)
+  #   DataMapper::Property::Boolean.allow_nil(false)
+  #
+  #   # set all properties to be required by default
+  #   DataMapper::Property.required(true)
+  #
+  #   # turn off auto-validation for all properties by default
+  #   DataMapper::Property.auto_validation(false)
+  #
+  #   # set all mutator methods to be private by default
+  #   DataMapper::Property.writer(false)
+  #
+  # Please note that this has no effect when a subclass has explicitly
+  # defined it's own option. For example, setting the String length to
+  # 255 will not affect the Text property even though it inherits from
+  # String, because it sets it's own default length to 65535.
+  #
   # == Misc. Notes
   # * Properties declared as strings will default to a length of 50, rather than
   #   255 (typical max varchar column size).  To overload the default, pass
@@ -291,12 +311,8 @@ module DataMapper
     module PassThroughLoadDump
       # @api semipublic
       def load(value)
-        unless value.nil?
-          value = type.load(value, self) if type
-          typecast(value)
-        else
-          value
-        end
+        return if value.nil?
+        typecast(value)
       end
 
       # Stub instance method for dumping
@@ -307,24 +323,15 @@ module DataMapper
       #
       # @api semipublic
       def dump(value)
-        if type
-          type.dump(value, self)
-        else
-          value
-        end
+        value
       end
     end
 
     include DataMapper::Assertions
     include Subject
     extend Chainable
-    extend Deprecate
     extend Equalizer
 
-    deprecate :unique,    :unique?
-    deprecate :nullable?, :allow_nil?
-    deprecate :value,     :dump
-
     equalize :model, :name
 
     PRIMITIVES = [
@@ -349,8 +356,11 @@ module DataMapper
     # Possible :visibility option values
     VISIBILITY_OPTIONS = [ :public, :protected, :private ].to_set.freeze
 
+    # Invalid property names
+    INVALID_NAMES = (Resource.instance_methods + Resource.private_instance_methods + Query::OPTIONS.to_a).map { |name| name.to_s }.freeze
+
     attr_reader :primitive, :model, :name, :instance_variable_name,
-      :type, :reader_visibility, :writer_visibility, :options,
+      :reader_visibility, :writer_visibility, :options,
       :default, :repository_name, :allow_nil, :allow_blank, :required
 
     class << self
@@ -360,30 +370,19 @@ module DataMapper
 
       # @api semipublic
       def determine_class(type)
-        if type < DataMapper::Property::Object
-          return type
-        end
-
-        name  = DataMapper::Inflector.demodulize(type.name)
-        klass = find_class(name)
-
-        if !klass && type < DataMapper::Type
-          klass = find_class(type.primitive.name)
-        end
+        return type if type < DataMapper::Property::Object
+        find_class(DataMapper::Inflector.demodulize(type.name))
+      end
 
-        klass
+      # @api private
+      def demodulized_names
+        @demodulized_names ||= {}
       end
 
       # @api semipublic
       def find_class(name)
-        klass = descendants.detect do |descendant|
-          DataMapper::Inflector.demodulize(descendant.name) == name
-        end
-
-        if !klass && const_defined?(name)
-          klass = const_get(name)
-        end
-
+        klass   = demodulized_names[name]
+        klass ||= const_get(name) if const_defined?(name)
         klass
       end
 
@@ -394,8 +393,28 @@ module DataMapper
 
       # @api private
       def inherited(descendant)
+        # Descendants is a tree rooted in DataMapper::Property that tracks
+        # inheritance.  We pre-calculate each comparison value (demodulized
+        # class name) to achieve a Hash[]-time lookup, rather than walk the
+        # entire descendant tree and calculate names on-demand (expensive,
+        # redundant).
+        #
+        # Since the algorithm relegates property class name lookups to a flat
+        # namespace, we need to ensure properties defined outside of DM don't
+        # override built-ins (Serial, String, etc) by merely defining a property
+        # of a same name.  We avoid this by only ever adding to the lookup
+        # table.  Given that DM loads its own property classes first, we can
+        # assume that their names are "reserved" when added to the table.
+        #
+        # External property authors who want to provide "replacements" for
+        # builtins (e.g. in a non-DM-supported adapter) should follow the
+        # convention of wrapping those properties in a module, and include'ing
+        # the module on the model class directly.  This bypasses the DM-hooked
+        # const_missing lookup that would normally check this table.
         descendants << descendant
 
+        Property.demodulized_names[DataMapper::Inflector.demodulize(descendant.name)] ||= descendant
+
         # inherit accepted options
         descendant.accepted_options.concat(accepted_options)
 
@@ -415,13 +434,15 @@ module DataMapper
         # create methods for each new option
         args.each do |property_option|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def self.#{property_option}(value = Undefined)           # def self.unique(value = Undefined)
-              return @#{property_option} if value.equal?(Undefined)  #   return @unique if value.equal?(Undefined)
-              descendants.each do |descendant|                       #   descendants.each do |descendant|
-                descendant.#{property_option}(value)                 #     descendant.unique(value)
-              end                                                    #   end
-              @#{property_option} = value                            #   @unique = value
-            end                                                      # end
+            def self.#{property_option}(value = Undefined)                         # def self.unique(value = Undefined)
+              return @#{property_option} if value.equal?(Undefined)                #   return @unique if value.equal?(Undefined)
+              descendants.each do |descendant|                                     #   descendants.each do |descendant|
+                unless descendant.instance_variable_defined?(:@#{property_option}) #     unless descendant.instance_variable_defined?(:@unique)
+                  descendant.#{property_option}(value)                             #       descendant.unique(value)
+                end                                                                #     end
+              end                                                                  #   end
+              @#{property_option} = value                                          #   @unique = value
+            end                                                                    # end
           RUBY
         end
 
@@ -431,20 +452,19 @@ module DataMapper
       # @api private
       def nullable(*args)
         # :required is preferable to :allow_nil, but :nullable maps precisely to :allow_nil
-        warn "#nullable is deprecated, use #required instead (#{caller[0]})"
-        allow_nil(*args)
+        raise "#nullable is deprecated, use #required instead (#{caller.first})"
       end
 
-      # Gives all the options set on this type
+      # Gives all the options set on this property
       #
-      # @return [Hash] with all options and their values set on this type
+      # @return [Hash] with all options and their values set on this property
       #
       # @api public
       def options
         options = {}
         accepted_options.each do |method|
           value = send(method)
-          options[method] = send(method) unless value.nil?
+          options[method] = value unless value.nil?
         end
         options
       end
@@ -452,9 +472,9 @@ module DataMapper
 
     accept_options :primitive, *Property::OPTIONS
 
-    # A hook to allow types to extend or modify property it's bound to.
-    # Implementations are not supposed to modify the state of the type class, and
-    # should produce no side-effects on the type class.
+    # A hook to allow properties to extend or modify the model it's bound to.
+    # Implementations are not supposed to modify the state of the property
+    # class, and should produce no side-effects on the property instance.
     def bind
       # no op
     end
@@ -464,21 +484,14 @@ module DataMapper
     # @return [String] name of field in data-store
     #
     # @api semipublic
-    def field(repository_name = Undefined)
-      self_repository_name = self.repository_name
-      klass                = self.class
-
-      unless repository_name.equal?(Undefined)
-        warn "Passing in +repository_name+ to #{klass}#field is deprecated (#{caller[0]})"
-
-        if repository_name != self_repository_name
-          raise ArgumentError, "Mismatching +repository_name+ with #{klass}#repository_name (#{repository_name.inspect} != #{self_repository_name.inspect})"
-        end
+    def field(repository_name = nil)
+      if repository_name
+        raise "Passing in +repository_name+ to #{self.class}#field is deprecated (#{caller.first})"
       end
 
       # defer setting the field with the adapter specific naming
       # conventions until after the adapter has been setup
-      @field ||= model.field_naming_convention(self_repository_name).call(self).freeze
+      @field ||= model.field_naming_convention(self.repository_name).call(self).freeze
     end
 
     # Returns true if property is unique. Serial properties and keys
@@ -492,19 +505,6 @@ module DataMapper
       !!@unique
     end
 
-    # Returns the hash of the property name
-    #
-    # This is necessary to allow comparisons between different properties
-    # in different models, having the same base model
-    #
-    # @return [Integer]
-    #   the property name hash
-    #
-    # @api semipublic
-    def hash
-      name.hash
-    end
-
     # Returns index name if property has index.
     #
     # @return [Boolean, Symbol, Array]
@@ -514,9 +514,7 @@ module DataMapper
     #   returns false if the property does not belong to any indexes
     #
     # @api public
-    def index
-      @index
-    end
+    attr_reader :index
 
     # Returns true if property has unique index. Serial properties and
     # keys are unique by default.
@@ -528,9 +526,7 @@ module DataMapper
     #   returns false if the property does not belong to any indexes
     #
     # @api public
-    def unique_index
-      @unique_index
-    end
+    attr_reader :unique_index
 
     # Returns whether or not the property is to be lazy-loaded
     #
@@ -592,16 +588,6 @@ module DataMapper
       @allow_blank
     end
 
-    # Returns whether or not the property is custom (not provided by dm-core)
-    #
-    # @return [Boolean]
-    #   whether or not the property is custom
-    #
-    # @api public
-    def custom?
-      @custom
-    end
-
     # Standardized reader method for the property
     #
     # @param [Resource] resource
@@ -702,9 +688,7 @@ module DataMapper
 
     # @api semipublic
     def typecast(value)
-      if @type && @type.respond_to?(:typecast)
-        @type.typecast(value, self)
-      elsif value.nil? || primitive?(value)
+      if value.nil? || primitive?(value)
         value
       elsif respond_to?(:typecast_to_primitive)
         typecast_to_primitive(value)
@@ -754,7 +738,7 @@ module DataMapper
     end
 
     chainable do
-      def self.new(model, name, options = {}, type = nil)
+      def self.new(model, name, options = {})
         super
       end
     end
@@ -762,23 +746,16 @@ module DataMapper
     protected
 
     # @api semipublic
-    def initialize(model, name, options = {}, type = nil)
+    def initialize(model, name, options = {})
       options = options.to_hash.dup
 
-      if type && !kind_of?(type)
-        warn "#{type} < DataMapper::Type is deprecated, use the new DataMapper::Property API instead (#{caller[2]})"
-        @type = type
-      end
-
-      reserved_method_names = DataMapper::Resource.instance_methods + DataMapper::Resource.private_instance_methods
-      if reserved_method_names.map { |m| m.to_s }.include?(name.to_s)
-        raise ArgumentError, "+name+ was #{name.inspect}, which cannot be used as a property name since it collides with an existing method"
+      if INVALID_NAMES.include?(name.to_s)
+        raise ArgumentError, "+name+ was #{name.inspect}, which cannot be used as a property name since it collides with an existing method or a query option"
       end
 
       assert_valid_options(options)
 
       predefined_options = self.class.options
-      predefined_options.merge!(@type.options) if @type
 
       @repository_name        = model.repository_name
       @model                  = model
@@ -786,8 +763,7 @@ module DataMapper
       @options                = predefined_options.merge(options).freeze
       @instance_variable_name = "@#{@name}".freeze
 
-      @primitive = self.class.primitive || @type.primitive
-      @custom    = !@type.nil?
+      @primitive = self.class.primitive
       @field     = @options[:field].freeze
       @default   = @options[:default]
 
@@ -803,7 +779,7 @@ module DataMapper
 
       determine_visibility
 
-      @type ? @type.bind(self) : bind
+      bind
     end
 
     # @api private
@@ -831,7 +807,7 @@ module DataMapper
               raise ArgumentError, "options[:#{key}] must be either true or false"
             end
 
-            if key == :required && (keys & [ :allow_nil, :allow_blank ]).size > 0
+            if key == :required && (keys.include?(:allow_nil) || keys.include?(:allow_blank))
               raise ArgumentError, 'options[:required] cannot be mixed with :allow_nil or :allow_blank'
             end