dm-core 1.0.0 → 1.0.1

data/lib/dm-core/collection.rb

@@ -65,9 +65,9 @@ module DataMapper
     # @return [self]
     #
     # @api public
-    def reload(other_query = nil)
+    def reload(other_query = Undefined)
       query = self.query
-      query = other_query.nil? ? query.dup : query.merge(other_query)
+      query = other_query.equal?(Undefined) ? query.dup : query.merge(other_query)
 
       # make sure the Identity Map contains all the existing resources
       identity_map = repository.identity_map(model)
@@ -214,10 +214,8 @@ module DataMapper
     #   Collection scoped by +query+
     #
     # @api public
-    def all(query = nil)
-      # TODO: update this not to accept a nil value, and instead either
-      # accept a Hash/Query and nothing else
-      if query.nil? || (query.kind_of?(Hash) && query.empty?)
+    def all(query = Undefined)
+      if query.equal?(Undefined) || (query.kind_of?(Hash) && query.empty?)
         dup
       else
         # TODO: if there is no order parameter, and the Collection is not loaded

data/lib/dm-core/model.rb

@@ -35,7 +35,7 @@ module DataMapper
         warn "Passing in +storage_name+ to #{name}.new is deprecated (#{caller[0]})"
         model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def self.default_storage_name
-            #{ActiveSupport::Inflector.classify(storage_name).inspect}.freeze
+            #{DataMapper::Inflector.classify(storage_name).inspect}.freeze
           end
         RUBY
       end
@@ -75,7 +75,9 @@ module DataMapper
     #   Set containing the descendant classes
     #
     # @api semipublic
-    attr_reader :descendants
+    def descendants
+      @descendants ||= DescendantSet.new
+    end
 
     # Return if Resource#save should raise an exception on save failures (globally)
     #
@@ -203,35 +205,29 @@ module DataMapper
     end
 
     # @api private
-    def self.extended(model)
-      descendants = self.descendants
+    def self.extended(descendant)
+      descendants << descendant
 
-      descendants << model
+      descendant.instance_variable_set(:@valid,         false)
+      descendant.instance_variable_set(:@base_model,    descendant)
+      descendant.instance_variable_set(:@storage_names, {})
+      descendant.instance_variable_set(:@default_order, {})
 
-      model.instance_variable_set(:@valid,         false)
-      model.instance_variable_set(:@base_model,    model)
-      model.instance_variable_set(:@storage_names, {})
-      model.instance_variable_set(:@default_order, {})
-      model.instance_variable_set(:@descendants,   descendants.class.new(model, descendants))
+      descendant.extend(Chainable)
 
-      model.extend(Chainable)
-
-      extra_extensions.each { |mod| model.extend(mod)         }
-      extra_inclusions.each { |mod| model.send(:include, mod) }
+      extra_extensions.each { |mod| descendant.extend(mod)         }
+      extra_inclusions.each { |mod| descendant.send(:include, mod) }
     end
 
     # @api private
     chainable do
-      def inherited(model)
-        descendants = self.descendants
-
-        descendants << model
+      def inherited(descendant)
+        descendants << descendant
 
-        model.instance_variable_set(:@valid,         false)
-        model.instance_variable_set(:@base_model,    base_model)
-        model.instance_variable_set(:@storage_names, @storage_names.dup)
-        model.instance_variable_set(:@default_order, @default_order.dup)
-        model.instance_variable_set(:@descendants,   descendants.class.new(model, descendants))
+        descendant.instance_variable_set(:@valid,         false)
+        descendant.instance_variable_set(:@base_model,    base_model)
+        descendant.instance_variable_set(:@storage_names, @storage_names.dup)
+        descendant.instance_variable_set(:@default_order, @default_order.dup)
       end
     end
 
@@ -250,7 +246,7 @@ module DataMapper
     # the names of the storage receptacles for this resource across all repositories
     #
     # @return [Hash(Symbol => String)]
-    #   All available names of storage recepticles
+    #   All available names of storage receptacles
     #
     # @api public
     def storage_names
@@ -339,10 +335,8 @@ module DataMapper
     # @see Collection
     #
     # @api public
-    def all(query = nil)
-      # TODO: update this not to accept a nil value, and instead either
-      # accept a Hash/Query and nothing else
-      if query.nil? || (query.kind_of?(Hash) && query.empty?)
+    def all(query = Undefined)
+      if query.equal?(Undefined) || (query.kind_of?(Hash) && query.empty?)
         # TODO: after adding Enumerable methods to Model, try to return self here
         new_collection(self.query.dup)
       else
@@ -726,10 +720,6 @@ module DataMapper
         self
       elsif name == :Resource
         Resource
-      elsif DataMapper::Property.const_defined?(name)
-        DataMapper::Property.const_get(name)
-      elsif DataMapper::Types.const_defined?(name)
-        DataMapper::Types.const_get(name)
       else
         super
       end

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

@@ -7,7 +7,7 @@
 module DataMapper
   module Model
     module Property
-      Model.append_extensions self
+      Model.append_extensions self, DataMapper::Property::Lookup
 
       extend Chainable
 
@@ -60,28 +60,13 @@ module DataMapper
 
         # if the type can be found within Property then
         # use that class rather than the primitive
-        type_name = type.name
-        unless type_name.blank?
-          type_name = ActiveSupport::Inflector.demodulize(type_name)
-
-          if DataMapper::Property.const_defined?(type_name)
-            type = DataMapper::Property.find_const(type_name)
-          elsif DataMapper::Types.const_defined?(type_name)
-            type = DataMapper::Types.find_const(type_name)
-          end
-        end
+        klass = DataMapper::Property.determine_class(type)
 
-        unless type < DataMapper::Property || type < DataMapper::Type
+        unless klass
           raise ArgumentError, "+type+ was #{type.inspect}, which is not a supported type"
         end
 
-        klass = if type < DataMapper::Property
-          type
-        else
-          DataMapper::Property.find_const(ActiveSupport::Inflector.demodulize(type.primitive.name))
-        end
-
-        property = klass.new(self, name, options, type)
+        property = klass.new(self, name, options, type < DataMapper::Type ? type : nil)
 
         repository_name = self.repository_name
         properties      = properties(repository_name)
@@ -187,7 +172,7 @@ module DataMapper
 
       # @api private
       def properties_with_subclasses(repository_name = default_repository_name)
-        properties = PropertySet.new
+        properties = properties(repository_name).dup
 
         descendants.each do |model|
           model.properties(repository_name).each do |property|
@@ -223,22 +208,20 @@ module DataMapper
         reader_visibility      = property.reader_visibility
         instance_variable_name = property.instance_variable_name
 
-        unless reserved_method?(name)
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            chainable do
-              #{reader_visibility}
-              def #{name}
-                return #{instance_variable_name} if defined?(#{instance_variable_name})
-                property = properties[#{name.inspect}]
-                #{instance_variable_name} = property ? persisted_state.get(property) : nil
-              end
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          chainable do
+            #{reader_visibility}
+            def #{name}
+              return #{instance_variable_name} if defined?(#{instance_variable_name})
+              property = properties[#{name.inspect}]
+              #{instance_variable_name} = property ? persisted_state.get(property) : nil
             end
-          RUBY
-        end
+          end
+        RUBY
 
         boolean_reader_name = "#{name}?"
 
-        if property.kind_of?(DataMapper::Property::Boolean) && !reserved_method?(boolean_reader_name)
+        if property.kind_of?(DataMapper::Property::Boolean)
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             chainable do
               #{reader_visibility}
@@ -259,8 +242,6 @@ module DataMapper
 
         writer_name = "#{name}="
 
-        return if reserved_method?(writer_name)
-
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           chainable do
             #{writer_visibility}
@@ -273,11 +254,6 @@ module DataMapper
         RUBY
       end
 
-      # @api private
-      def reserved_method?(name)
-        method_defined?(name) && !%w[ id type ].include?(name)
-      end
-
       chainable do
         # @api public
         def method_missing(method, *args, &block)

data/lib/dm-core/property.rb

@@ -292,7 +292,7 @@ module DataMapper
       # @api semipublic
       def load(value)
         unless value.nil?
-          value = @type.load(value, self) if @type
+          value = type.load(value, self) if type
           typecast(value)
         else
           value
@@ -307,8 +307,8 @@ module DataMapper
       #
       # @api semipublic
       def dump(value)
-        if @type
-          @type.dump(value, self)
+        if type
+          type.dump(value, self)
         else
           value
         end
@@ -354,9 +354,53 @@ module DataMapper
       :default, :repository_name, :allow_nil, :allow_blank, :required
 
     class << self
+      extend Deprecate
+
+      deprecate :all_descendants, :descendants
+
+      # @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
+
+        klass
+      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
+      end
+
       # @api public
       def descendants
-        @descendants ||= []
+        @descendants ||= DescendantSet.new
+      end
+
+      # @api private
+      def inherited(descendant)
+        descendants << descendant
+
+        # inherit accepted options
+        descendant.accepted_options.concat(accepted_options)
+
+        # inherit the option values
+        options.each { |key, value| descendant.send(key, value) }
       end
 
       # @api public
@@ -368,20 +412,27 @@ module DataMapper
       def accept_options(*args)
         accepted_options.concat(args)
 
-        # Load Property options
-        accepted_options.each do |property_option|
+        # create methods for each new option
+        args.each do |property_option|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def self.#{property_option}(*args)                                  # def unique(*args)
-              if args.any?                                                 #   if args.any?
-                @#{property_option} = args.first                           #     @unique = args.first
-              else                                                         #   else
-                defined?(@#{property_option}) ? @#{property_option} : nil  #     defined?(@unique) ? @unique : nil
-              end                                                          #   end
-            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|
+                descendant.#{property_option}(value)                 #     descendant.unique(value)
+              end                                                    #   end
+              @#{property_option} = value                            #   @unique = value
+            end                                                      # end
           RUBY
         end
 
-        descendants.each {|descendant| descendant.accept_options(*args)}
+        descendants.each { |descendant| descendant.accepted_options.concat(args) }
+      end
+
+      # @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)
       end
 
       # Gives all the options set on this type
@@ -392,49 +443,14 @@ module DataMapper
       def options
         options = {}
         accepted_options.each do |method|
-          next if !respond_to?(method) || (value = send(method)).nil?
-          options[method] = value
+          value = send(method)
+          options[method] = send(method) unless value.nil?
         end
         options
       end
-
-      # Ruby primitive type to use as basis for this type. See
-      # Property::PRIMITIVES for list of types.
-      #
-      # @param primitive [Class, nil]
-      #   The class for the primitive. If nil is passed in, it returns the
-      #   current primitive
-      #
-      # @return [Class] if the <primitive> param is nil, return the current primitive.
-      #
-      # @api public
-      def primitive(primitive = nil)
-        return @primitive if primitive.nil?
-        @primitive = primitive
-      end
-
-      def nullable(value)
-        # :required is preferable to :allow_nil, but :nullable maps precisely to :allow_nil
-        warn "#nullable is deprecated, use #required instead (#{caller[0]})"
-        allow_nil(value)
-      end
-
-      def inherited(base)
-        descendants << base
-
-        base.primitive primitive
-        base.accept_options(*accepted_options)
-
-        # inherit the options from the parent class
-        base_options = base.options
-
-        options.each do |key, value|
-          base.send(key, value) unless base_options.key?(key)
-        end
-      end
     end
 
-    accept_options *Property::OPTIONS
+    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
@@ -448,11 +464,11 @@ module DataMapper
     # @return [String] name of field in data-store
     #
     # @api semipublic
-    def field(repository_name = nil)
+    def field(repository_name = Undefined)
       self_repository_name = self.repository_name
       klass                = self.class
 
-      if repository_name
+      unless repository_name.equal?(Undefined)
         warn "Passing in +repository_name+ to #{klass}#field is deprecated (#{caller[0]})"
 
         if repository_name != self_repository_name
@@ -516,16 +532,6 @@ module DataMapper
       @unique_index
     end
 
-    # @api public
-    def kind_of?(klass)
-      super || klass == Property
-    end
-
-    # @api public
-    def instance_of?(klass)
-      super || klass == Property
-    end
-
     # Returns whether or not the property is to be lazy-loaded
     #
     # @return [Boolean]
@@ -705,24 +711,6 @@ module DataMapper
       end
     end
 
-    # Returns given value unchanged for core types and
-    # uses +dump+ method of the property type for custom types.
-    #
-    # @param [Object] loaded_value
-    #   the value to be converted into a storeable (ie., primitive) value
-    #
-    # @return [Object]
-    #   the primitive value to be stored in the repository for +val+
-    #
-    # @api semipublic
-    def dump(value)
-      if custom?
-        type.dump(loaded_value, self)
-      else
-        loaded_value
-      end
-    end
-
     # Test the value to see if it is a valid value for this Property
     #
     # @param [Object] loaded_value
@@ -775,9 +763,9 @@ module DataMapper
 
     # @api semipublic
     def initialize(model, name, options = {}, type = nil)
-      options       = options.to_hash.dup
+      options = options.to_hash.dup
 
-      if type && !self.kind_of?(type)
+      if type && !kind_of?(type)
         warn "#{type} < DataMapper::Type is deprecated, use the new DataMapper::Property API instead (#{caller[2]})"
         @type = type
       end
@@ -879,10 +867,10 @@ module DataMapper
     #
     # @api private
     def determine_visibility
-      default_accessor = @options[:accessor] || :public
+      default_accessor = @options.fetch(:accessor, :public)
 
-      @reader_visibility = @options[:reader] || default_accessor
-      @writer_visibility = @options[:writer] || default_accessor
+      @reader_visibility = @options.fetch(:reader, default_accessor)
+      @writer_visibility = @options.fetch(:writer, default_accessor)
     end
   end # class Property
 end