dm-core 1.0.2 → 1.1.0.rc1

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

@@ -19,9 +19,7 @@ module DataMapper
       #
       # @api private
       def typecast_to_primitive(value)
-        if value.respond_to?(:to_datetime)
-          value.to_datetime
-        elsif value.respond_to?(:to_mash)
+        if value.respond_to?(:to_mash)
           typecast_hash_to_datetime(value)
         else
           ::DateTime.parse(value.to_s)

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

@@ -7,17 +7,21 @@ module DataMapper
 
       protected
 
-      def initialize(model, name, options = {}, type = nil)
+      def initialize(model, name, options = {})
         super
 
-        unless @scale.nil?
-          unless @scale >= 0
-            raise ArgumentError, "scale must be equal to or greater than 0, but was #{@scale.inspect}"
+        [ :scale, :precision ].each do |key|
+          unless options.key?(key)
+            warn "options[#{key.inspect}] should be set for #{self.class}, defaulting to #{send(key).inspect}"
           end
+        end
 
-          unless @precision >= @scale
-            raise ArgumentError, "precision must be equal to or greater than scale, but was #{@precision.inspect} and scale was #{scale_inspect}"
-          end
+        unless @scale >= 0
+          raise ArgumentError, "scale must be equal to or greater than 0, but was #{@scale.inspect}"
+        end
+
+        unless @precision >= @scale
+          raise ArgumentError, "precision must be equal to or greater than scale, but was #{@precision.inspect} and scale was #{@scale.inspect}"
         end
       end
 

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

@@ -8,9 +8,9 @@ module DataMapper
       protected
 
       # @api semipublic
-      def initialize(model, name, options = {}, type = nil)
+      def initialize(model, name, options = {})
         if options.key?(:serial) && !kind_of?(Serial)
-          warn "Integer #{name} with explicit :serial option is deprecated, use Serial instead (#{caller[2]})"
+          raise "Integer #{name} with explicit :serial option is deprecated, use Serial instead (#{caller[2]})"
         end
         super
       end

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

@@ -6,12 +6,12 @@ module DataMapper
 
       #
       # Provides transparent access to the Properties defined in
-      # {Property}. It also provides access to the legacy {Types} namespace.
+      # {Property}.
       #
       # @param [Symbol] name
       #   The name of the property to lookup.
       #
-      # @return [Property, Type]
+      # @return [Property]
       #   The property with the given name.
       #
       # @raise [NameError]
@@ -22,20 +22,7 @@ module DataMapper
       # @since 1.0.1
       #
       def const_missing(name)
-        if const = Property.find_class(name)
-          return const
-        end
-
-        # only check within DataMapper::Types, if it was loaded.
-        if DataMapper.const_defined?(:Types)
-          if DataMapper::Types.const_defined?(name)
-            type = DataMapper::Types.const_get(name)
-
-            return type if type < DataMapper::Type
-          end
-        end
-
-        super
+        Property.find_class(name.to_s) || super
       end
     end
   end

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

@@ -15,10 +15,10 @@ module DataMapper
 
       protected
 
-      def initialize(model, name, options = {}, type = nil)
+      def initialize(model, name, options = {})
         super
 
-        if [ BigDecimal, ::Float ].include?(@primitive)
+        if @primitive == BigDecimal || @primitive == ::Float
           @precision = @options.fetch(:precision, DEFAULT_PRECISION)
           @scale     = @options.fetch(:scale,     self.class::DEFAULT_SCALE)
 
@@ -27,7 +27,7 @@ module DataMapper
           end
         end
 
-        if (@options.keys & [ :min, :max ]).any?
+        if @options.key?(:min) || @options.key?(:max)
           @min = @options.fetch(:min, DEFAULT_NUMERIC_MIN)
           @max = @options.fetch(:max, DEFAULT_NUMERIC_MAX)
 

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

@@ -5,21 +5,12 @@ module DataMapper
 
       # @api semipublic
       def dump(value)
-        return value if value.nil?
-
-        if @type
-          @type.dump(value, self)
-        else
-          [ Marshal.dump(value) ].pack('m')
-        end
+        return if value.nil?
+        [ Marshal.dump(value) ].pack('m')
       end
 
       # @api semipublic
       def load(value)
-        if @type
-          return @type.load(value, self)
-        end
-
         case value
           when ::String
             Marshal.load(value.unpack('m').first)

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

@@ -27,7 +27,7 @@ module DataMapper
 
       protected
 
-      def initialize(model, name, options = {}, type = nil)
+      def initialize(model, name, options = {})
         super
         @length = @options.fetch(:length, DEFAULT_LENGTH)
       end

data/lib/dm-core/property_set.rb

@@ -1,58 +1,52 @@
+require 'dm-core/support/subject_set'
+
 module DataMapper
   # Set of Property objects, used to associate
   # queries with set of fields it performed over,
   # to represent composite keys (esp. for associations)
   # and so on.
-  class PropertySet < Array
-    extend Deprecate
-
-    deprecate :has_property?, :named?
-    deprecate :slice,         :values_at
-    deprecate :add,           :<<
+  class PropertySet < SubjectSet
+    include Enumerable
 
-    # @api semipublic
-    def [](name)
-      @properties[name]
+    def <<(property)
+      clear_cache
+      super
     end
 
-    alias_method :superclass_slice, :[]=
-    private :superclass_slice
-
+    # Make sure that entry is part of this PropertySet
+    #
+    # @param [#to_s] name
+    # @param [#name] entry
+    #
+    # @return [#name]
+    #   the entry that is now part of this PropertySet
+    #
     # @api semipublic
-    def []=(name, property)
-      self << property
+    def []=(name, entry)
+      warn "#{self.class}#[]= is deprecated. Use #{self.class}#<< instead: #{caller.first}"
+      raise "#{entry.class} is not added with the correct name" unless name && name.to_s == entry.name.to_s
+      self << entry
+      entry
     end
 
-    # @api semipublic
-    def named?(name)
-      @properties.key?(name.to_sym)
+    def |(other)
+      self.class.new(to_a | other.to_a)
     end
 
-    # @api semipublic
-    def values_at(*names)
-      @properties.values_at(*names)
+    def &(other)
+      self.class.new(to_a & other.to_a)
     end
 
-    # @api semipublic
-    def <<(property)
-      found = named?(property.name)
-      add_property(property)
-
-      if found
-        superclass_slice(index(property), property)
-      else
-        super
-      end
+    def -(other)
+      self.class.new(to_a - other.to_a)
     end
 
-    # @api semipublic
-    def include?(property)
-      named?(property.name)
+    def +(other)
+      self.class.new(to_a + other.to_a)
     end
 
-    # @api semipublic
-    def index(property)
-      each_index { |index| break index if at(index).name == property.name }
+    def ==(other)
+      to_a == other.to_a
     end
 
     # TODO: make PropertySet#reject return a PropertySet instance
@@ -68,7 +62,7 @@ module DataMapper
 
     # @api semipublic
     def discriminator
-      @discriminator ||= detect { |property| property.kind_of?(Property::Discriminator) || property.type == Types::Discriminator }
+      @discriminator ||= detect { |property| property.kind_of?(Property::Discriminator) }
     end
 
     # @api semipublic
@@ -153,25 +147,11 @@ module DataMapper
       map { |property| [ property.field, property ] }.to_hash
     end
 
-    private
-
-    # @api semipublic
-    def initialize(*)
-      super
-      @properties = map { |property| [ property.name, property ] }.to_mash
+    def inspect
+      to_a.inspect
     end
 
-    # @api private
-    def initialize_copy(*)
-      super
-      @properties = @properties.dup
-    end
-
-    # @api private
-    def add_property(property)
-      clear_cache
-      @properties[property.name] = property
-    end
+    private
 
     # @api private
     def clear_cache

data/lib/dm-core/query.rb

@@ -486,10 +486,10 @@ module DataMapper
     #
     # @api semipublic
     def filter_records(records)
-      records = records.uniq if unique?
-      records = match_records(records)
-      records = sort_records(records)
-      records = limit_records(records)
+      records = records.uniq           if unique?
+      records = match_records(records) if conditions
+      records = sort_records(records)  if order
+      records = limit_records(records) if limit || offset > 0
       records
     end
 
@@ -504,7 +504,6 @@ module DataMapper
     # @api semipublic
     def match_records(records)
       conditions = self.conditions
-      return records if conditions.nil?
       records.select { |record| conditions.matches?(record) }
     end
 
@@ -530,7 +529,7 @@ module DataMapper
     # Limits a set of records by the offset and/or limit
     #
     # @param [Enumerable] records
-    #   A list of Recrods to sort
+    #   A list of records to sort
     #
     # @return [Enumerable]
     #   The offset & limited records
@@ -788,22 +787,26 @@ module DataMapper
 
       model = self.model
 
-      fields.each do |field|
-        inspect = field.inspect
+      valid_properties = model.properties
+
+      model.descendants.each do |descendant|
+        valid_properties += descendant.properties
+      end
 
+      fields.each do |field|
         case field
           when Symbol, String
-            unless @properties.named?(field)
-              raise ArgumentError, "+options[:fields]+ entry #{inspect} does not map to a property in #{model}"
+            unless valid_properties.named?(field)
+              raise ArgumentError, "+options[:fields]+ entry #{field.inspect} does not map to a property in #{model}"
             end
 
           when Property
-            unless @properties.include?(field)
+            unless valid_properties.include?(field)
               raise ArgumentError, "+options[:field]+ entry #{field.name.inspect} does not map to a property in #{model}"
             end
 
           else
-            raise ArgumentError, "+options[:fields]+ entry #{inspect} of an unsupported object #{field.class}"
+            raise ArgumentError, "+options[:fields]+ entry #{field.inspect} of an unsupported object #{field.class}"
         end
       end
     end
@@ -820,12 +823,10 @@ module DataMapper
       end
 
       links.each do |link|
-        inspect = link.inspect
-
         case link
           when Symbol, String
-            unless @relationships.key?(link.to_sym)
-              raise ArgumentError, "+options[:links]+ entry #{inspect} does not map to a relationship in #{model}"
+            unless @relationships.named?(link.to_sym)
+              raise ArgumentError, "+options[:links]+ entry #{link.inspect} does not map to a relationship in #{model}"
             end
 
           when Associations::Relationship
@@ -835,7 +836,7 @@ module DataMapper
             #end
 
           else
-            raise ArgumentError, "+options[:links]+ entry #{inspect} of an unsupported object #{link.class}"
+            raise ArgumentError, "+options[:links]+ entry #{link.inspect} of an unsupported object #{link.class}"
         end
       end
     end
@@ -850,19 +851,29 @@ module DataMapper
       case conditions
         when Hash
           conditions.each do |subject, bind_value|
-            inspect = subject.inspect
-
             case subject
               when Symbol, ::String
-                unless subject.to_s.include?('.') || @properties.named?(subject) || @relationships.key?(subject)
-                  raise ArgumentError, "condition #{inspect} does not map to a property or relationship in #{model}"
+                original = subject
+                subject  = subject.to_s
+
+                if subject.include?('.')
+                  unless @relationships.named?(subject[0, subject.index('.')])
+                    raise ArgumentError, "condition #{original.inspect} does not map to a relationship in #{model}"
+                  end
+                elsif !@properties.named?(subject) && !@relationships.named?(subject)
+                  raise ArgumentError, "condition #{original.inspect} does not map to a property or relationship in #{model}"
+                end
+
+              when Property
+                unless @properties.include?(subject)
+                  raise ArgumentError, "condition #{subject.name.inspect} does not map to a property in #{model}, but belongs to #{subject.model}"
                 end
 
               when Operator
                 operator = subject.operator
 
-                unless (Conditions::Comparison.slugs | [ :not ]).include?(operator)
-                  raise ArgumentError, "condition #{inspect} used an invalid operator #{operator}"
+                unless Conditions::Comparison.slugs.include?(operator) || operator == :not
+                  raise ArgumentError, "condition #{subject.inspect} used an invalid operator #{operator}"
                 end
 
                 assert_valid_conditions(subject.target => bind_value)
@@ -870,15 +881,14 @@ module DataMapper
               when Path
                 assert_valid_links(subject.relationships)
 
-              when Associations::Relationship, Property
-                # TODO: validate that it belongs to the current model, or to any
-                # model in the links
-                #unless @properties.include?(subject)
-                #  raise ArgumentError, "condition #{subject.name.inspect} does not map to a property in #{model}"
+              when Associations::Relationship
+                # TODO: validate that it belongs to the current model
+                #unless subject.source_model.equal?(model)
+                #  raise ArgumentError, "condition #{subject.name.inspect} is not a valid relationship for #{model}, it's source model was #{subject.source_model}"
                 #end
 
               else
-                raise ArgumentError, "condition #{inspect} of an unsupported object #{subject.class}"
+                raise ArgumentError, "condition #{subject.inspect} of an unsupported object #{subject.class}"
             end
           end
 
@@ -938,30 +948,27 @@ module DataMapper
       model = self.model
 
       order.each do |order_entry|
-        inspect = order_entry.inspect
-
         case order_entry
           when Symbol, String
             unless @properties.named?(order_entry)
-              raise ArgumentError, "+options[:order]+ entry #{inspect} does not map to a property in #{model}"
+              raise ArgumentError, "+options[:order]+ entry #{order_entry.inspect} does not map to a property in #{model}"
             end
 
-          when Property
-            unless @properties.include?(order_entry)
-              raise ArgumentError, "+options[:order]+ entry #{order_entry.name.inspect} does not map to a property in #{model}"
-            end
+          when Property, Path
+            # Allow any arbitrary property, since it may map to a model
+            # that has been included via the :links option
 
           when Operator, Direction
             operator = order_entry.operator
 
             unless operator == :asc || operator == :desc
-              raise ArgumentError, "+options[:order]+ entry #{inspect} used an invalid operator #{operator}"
+              raise ArgumentError, "+options[:order]+ entry #{order_entry.inspect} used an invalid operator #{operator}"
             end
 
             assert_valid_order([ order_entry.target ], fields)
 
           else
-            raise ArgumentError, "+options[:order]+ entry #{inspect} of an unsupported object #{order_entry.class}"
+            raise ArgumentError, "+options[:order]+ entry #{order_entry.inspect} of an unsupported object #{order_entry.class}"
         end
       end
     end
@@ -1034,9 +1041,10 @@ module DataMapper
     #
     # @api private
     def normalize_options(options = OPTIONS)
-      (options & [ :order, :fields, :links, :unique ]).each do |option|
-        send("normalize_#{option}")
-      end
+      normalize_order  if options.include? :order
+      normalize_fields if options.include? :fields
+      normalize_links  if options.include? :links
+      normalize_unique if options.include? :unique
     end
 
     # Normalize order elements to Query::Direction instances
@@ -1045,8 +1053,6 @@ module DataMapper
     def normalize_order
       return if @order.nil?
 
-      # TODO: should Query::Path objects be permitted?  If so, then it
-      # should probably be normalized to a Direction object
       @order = Array(@order)
       @order = @order.map do |order|
         case order
@@ -1064,6 +1070,10 @@ module DataMapper
 
           when Direction
             order.dup
+
+          when Path
+            Direction.new(order.property)
+
         end
       end
     end
@@ -1113,12 +1123,19 @@ module DataMapper
 
     # Normalize the unique attribute
     #
-    # If any links are present, and the unique attribute was not
-    # explicitly specified, then make sure the query is marked as unique
+    # If any links are present, and the unique attribute was not explicitly
+    # specified, then make sure the query is marked as unique. The exception
+    # to this rule is links where there is known to be 0..1 records on the
+    # the other side, such as belongs_to or a has 1. In this case, there
+    # is no need to explicitly mark the query unique. This in turn allows
+    # sane ordering on fields of the links, since no redundant GROUP BY
+    # clause will be generated.
     #
     # @api private
     def normalize_unique
-      @unique = @links.any? unless @options.key?(:unique)
+      unless @options.key?(:unique)
+        @unique = @links.reject {|x| x.min.between?(0, 1) && x.max == 1 }.any?
+      end
     end
 
     # Append conditions to this Query
@@ -1148,6 +1165,16 @@ module DataMapper
       end
     end
 
+    # @api private
+    def equality_operator_for_type(bind_value)
+      case bind_value
+        when Model, String then :eql
+        when Enumerable    then :in
+        when Regexp        then :regexp
+        else                    :eql
+      end
+    end
+
     # @api private
     def append_property_condition(subject, bind_value, operator)
       negated = operator == :not
@@ -1171,15 +1198,6 @@ module DataMapper
       add_condition(condition)
     end
 
-    def equality_operator_for_type(bind_value)
-      case bind_value
-        when Model, String then :eql
-        when Enumerable    then :in
-        when Regexp        then :regexp
-        else                    :eql
-      end
-    end
-
     # @api private
     def append_symbol_condition(symbol, bind_value, model, operator)
       append_condition(symbol.to_s, bind_value, model, operator)
@@ -1356,7 +1374,18 @@ module DataMapper
     #
     # @api private
     def other_conditions(other, operation)
-      query_conditions(self).send(operation, query_conditions(other))
+      self_conditions = query_conditions(self)
+
+      unless self_conditions.kind_of?(Conditions::Operation)
+        operation_slug = case operation
+                         when :intersection, :difference then :and
+                         when :union                     then :or
+                         end
+
+        self_conditions = Conditions::Operation.new(operation_slug, self_conditions)
+      end
+
+      self_conditions.send(operation, query_conditions(other))
     end
 
     # Extract conditions from a Query