dm-core 0.9.2 → 0.9.3

data/lib/dm-core/property.rb

@@ -61,9 +61,9 @@ module DataMapper
   #
   #  class Post
   #   include DataMapper::Resource
-  #    property :title,  String,                  :accessor => :private
+  #    property :title,  String, :accessor => :private
   #      # Both reader and writer are private
-  #    property :body,   Text, :accessor => :protected
+  #    property :body,   Text,   :accessor => :protected
   #      # Both reader and writer are protected
   #  end
   #
@@ -243,7 +243,7 @@ module DataMapper
     # NOTE: PLEASE update PROPERTY_OPTIONS in DataMapper::Type when updating
     # them here
     PROPERTY_OPTIONS = [
-      :public, :protected, :private, :accessor, :reader, :writer,
+      :accessor, :reader, :writer,
       :lazy, :default, :nullable, :key, :serial, :field, :size, :length,
       :format, :index, :unique_index, :check, :ordinal, :auto_validation,
       :validates, :unique, :track, :precision, :scale
@@ -264,7 +264,8 @@ module DataMapper
       Time,
       Object,
       Class,
-      DataMapper::Types::Discriminator
+      DataMapper::Types::Discriminator,
+      DataMapper::Types::Serial
     ]
 
     IMMUTABLE_TYPES = [ TrueClass, Float, Integer, BigDecimal]
@@ -273,7 +274,8 @@ module DataMapper
 
     DEFAULT_LENGTH    = 50
     DEFAULT_PRECISION = 10
-    DEFAULT_SCALE     = 0
+    DEFAULT_SCALE_BIGDECIMAL = 0
+    DEFAULT_SCALE_FLOAT = nil
 
     attr_reader :primitive, :model, :name, :instance_variable_name,
       :type, :reader_visibility, :writer_visibility, :getter, :options,
@@ -284,18 +286,14 @@ module DataMapper
     # @return <String> name of field in data-store
     # -
     # @api semi-public
-    def field(*args)
-      @options.fetch(:field, repository(*args).adapter.field_naming_convention.call(name))
+    def field(repository_name = nil)
+      @field || fields[repository_name || model.repository_name]
     end
 
     def unique
       @unique ||= @options.fetch(:unique, @serial || @key || false)
     end
 
-    def repository(*args)
-      @model.repository(*args)
-    end
-
     def hash
       if @custom && !@bound
         @type.bind(self)
@@ -336,7 +334,6 @@ module DataMapper
       @lazy
     end
 
-
     # Returns whether or not the property is a key or a part of a key
     #
     # @return <TrueClass, FalseClass> whether the property is a key or a part of
@@ -377,17 +374,7 @@ module DataMapper
     def get(resource)
       new_record = resource.new_record?
 
-      unless new_record || resource.attribute_loaded?(name)
-        # TODO: refactor this section
-        contexts = if lazy?
-          name
-        else
-          model.properties(resource.repository.name).reject do |property|
-            property.lazy? || resource.attribute_loaded?(property.name)
-          end
-        end
-        resource.send(:lazy_load, contexts)
-      end
+      lazy_load(resource) unless new_record || resource.attribute_loaded?(name)
 
       value = get!(resource)
 
@@ -416,6 +403,7 @@ module DataMapper
     #-
     # @api private
     def set(resource, value)
+      lazy_load(resource) unless resource.new_record? || resource.attribute_loaded?(name)
       new_value = typecast(value)
       old_value = get!(resource)
 
@@ -432,6 +420,21 @@ module DataMapper
       resource.instance_variable_set(instance_variable_name, value)
     end
 
+    # Loads lazy columns when get or set is called.
+    #-
+    # @api private
+    def lazy_load(resource)
+      # TODO: refactor this section
+      contexts = if lazy?
+        name
+      else
+        model.properties(resource.repository.name).reject do |property|
+          property.lazy? || resource.attribute_loaded?(property.name)
+        end
+      end
+      resource.send(:lazy_load, contexts)
+    end
+
     # typecasts values into a primitive
     #
     # @return <TrueClass, String, Float, Integer, BigDecimal, DateTime, Date, Time
@@ -439,17 +442,37 @@ module DataMapper
     #-
     # @api private
     def typecast(value)
-      return value if value.kind_of?(type) || value.nil?
+      return type.typecast(value, self) if type.respond_to?(:typecast)
+      return value if value.kind_of?(primitive) || value.nil?
       begin
-        if    type == TrueClass  then %w[ true 1 t ].include?(value.to_s.downcase)
-        elsif type == String     then value.to_s
-        elsif type == Float      then value.to_f
-        elsif type == Integer    then value.to_i
-        elsif type == BigDecimal then BigDecimal(value.to_s)
-        elsif type == DateTime   then typecast_to_datetime(value)
-        elsif type == Date       then typecast_to_date(value)
-        elsif type == Time       then typecast_to_time(value)
-        elsif type == Class      then self.class.find_const(value)
+        if    primitive == TrueClass  then %w[ true 1 t ].include?(value.to_s.downcase)
+        elsif primitive == String     then value.to_s
+        elsif primitive == Float      then value.to_f
+        elsif primitive == Integer
+          # The simplest possible implementation, i.e. value.to_i, is not
+          # desirable because "junk".to_i gives "0". We want nil instead,
+          # because this makes it clear that the typecast failed.
+          #
+          # After benchmarking, we preferred the current implementation over
+          # these two alternatives:
+          # * Integer(value) rescue nil
+          # * Integer(value_to_s =~ /(\d+)/ ? $1 : value_to_s) rescue nil
+          value_to_i = value.to_i
+          if value_to_i == 0 && value != '0'
+            value_to_s = value.to_s
+            begin
+              Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
+            rescue ArgumentError
+              nil
+            end
+          else
+            value_to_i
+          end
+        elsif primitive == BigDecimal then BigDecimal(value.to_s)
+        elsif primitive == DateTime   then typecast_to_datetime(value)
+        elsif primitive == Date       then typecast_to_date(value)
+        elsif primitive == Time       then typecast_to_time(value)
+        elsif primitive == Class      then self.class.find_const(value)
         else
           value
         end
@@ -503,6 +526,7 @@ module DataMapper
       @primitive = @options.fetch(:primitive, @type.respond_to?(:primitive) ? @type.primitive : @type)
 
       @getter       = TrueClass == @primitive ? "#{@name}?".to_sym : @name
+      @field        = @options.fetch(:field,        nil)
       @serial       = @options.fetch(:serial,       false)
       @key          = @options.fetch(:key,          @serial || false)
       @default      = @options.fetch(:default,      nil)
@@ -524,18 +548,23 @@ module DataMapper
         @length = @options.fetch(:length, @options.fetch(:size, DEFAULT_LENGTH))
       elsif BigDecimal == @primitive || Float == @primitive
         @precision = @options.fetch(:precision, DEFAULT_PRECISION)
-        @scale     = @options.fetch(:scale,     DEFAULT_SCALE)
+        
+        default_scale = (Float == @primitive) ? DEFAULT_SCALE_FLOAT : DEFAULT_SCALE_BIGDECIMAL
+        @scale     = @options.fetch(:scale, default_scale)
+        # @scale     = @options.fetch(:scale, DEFAULT_SCALE_BIGDECIMAL)
 
         unless @precision > 0
           raise ArgumentError, "precision must be greater than 0, but was #{@precision.inspect}"
         end
 
-        unless @scale >= 0
-          raise ArgumentError, "scale must be equal to or greater than 0, but was #{@scale.inspect}"
-        end
+        if (BigDecimal == @primitive) || (Float == @primitive && !@scale.nil?)
+          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}"
+          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
       end
 
@@ -545,11 +574,13 @@ module DataMapper
       @model.property_serialization_setup(self) if @model.respond_to?(:property_serialization_setup)
     end
 
+    def fields
+      @fields ||= Hash.new { |h,k| h[k] = repository(k).adapter.field_naming_convention.call(self.name) }
+    end
+
     def determine_visibility # :nodoc:
       @reader_visibility = @options[:reader] || @options[:accessor] || :public
       @writer_visibility = @options[:writer] || @options[:accessor] || :public
-      @writer_visibility = :protected if @options[:protected]
-      @writer_visibility = :private   if @options[:private]
 
       unless VISIBILITY_OPTIONS.include?(@reader_visibility) && VISIBILITY_OPTIONS.include?(@writer_visibility)
         raise ArgumentError, 'property visibility must be :public, :protected, or :private', caller(2)

data/lib/dm-core/property_set.rb

@@ -4,10 +4,12 @@ module DataMapper
     include Enumerable
 
     def [](name)
-      @property_for[name]
+      @property_for[name] || raise(ArgumentError, "Unknown property '#{name}'", caller)
     end
 
-    alias has_property? []
+    def has_property?(name)
+      !!@property_for[name]
+    end
 
     def slice(*names)
       @property_for.values_at(*names)
@@ -44,13 +46,15 @@ module DataMapper
 
     def indexes
       index_hash = {}
-      each { |property| parse_index(property.index, property.field.to_s, index_hash) }
+      repository_name = repository.name
+      each { |property| parse_index(property.index, property.field(repository_name), index_hash) }
       index_hash
     end
 
     def unique_indexes
       index_hash = {}
-      each { |property| parse_index(property.unique_index, property.field.to_s, index_hash) }
+      repository_name = repository.name
+      each { |property| parse_index(property.unique_index, property.field(repository_name), index_hash) }
       index_hash
     end
 
@@ -108,16 +112,6 @@ module DataMapper
       '#<PropertySet:{' + map { |property| property.inspect }.join(',') + '}>'
     end
 
-    def dup(target = nil)
-      return super() unless target
-
-      properties = map do |property|
-        Property.new(target || property.model, property.name, property.type, property.options.dup)
-      end
-
-      self.class.new(properties)
-    end
-
     private
 
     def initialize(properties = [])

data/lib/dm-core/query.rb

@@ -3,10 +3,10 @@ module DataMapper
     include Assertions
 
     OPTIONS = [
-      :reload, :offset, :limit, :order, :add_reversed, :fields, :links, :includes, :conditions
+      :reload, :offset, :limit, :order, :add_reversed, :fields, :links, :includes, :conditions, :unique
     ]
 
-    attr_reader :repository, :model, *OPTIONS - [ :reload ]
+    attr_reader :repository, :model, *OPTIONS - [ :reload, :unique ]
     attr_writer :add_reversed
     alias add_reversed? add_reversed
 
@@ -14,6 +14,10 @@ module DataMapper
       @reload
     end
 
+    def unique?
+      @unique
+    end
+
     def reverse
       dup.reverse!
     end
@@ -42,6 +46,7 @@ module DataMapper
 
       # only overwrite the attributes with non-default values
       @reload       = other.reload?       unless other.reload?       == false
+      @unique       = other.unique?       unless other.unique?       == false
       @offset       = other.offset        unless other.offset        == 0
       @limit        = other.limit         unless other.limit         == nil
       @order        = other.order         unless other.order         == model.default_order
@@ -67,6 +72,7 @@ module DataMapper
       #   return hash == other.hash
       @model        == other.model         &&
       @reload       == other.reload?       &&
+      @unique       == other.unique?       &&
       @offset       == other.offset        &&
       @limit        == other.limit         &&
       @order        == other.order         &&  # order is significant, so do not sort this
@@ -136,6 +142,7 @@ module DataMapper
         [ :limit,      limit           ],
         [ :offset,     offset          ],
         [ :reload,     reload?         ],
+        [ :unique,     unique?         ],
       ]
 
       "#<#{self.class.name} #{attrs.map { |(k,v)| "@#{k}=#{v.inspect}" } * ' '}>"
@@ -157,6 +164,7 @@ module DataMapper
 
       @model        = model                               # must be Class that includes DM::Resource
       @reload       = options.fetch :reload,       false  # must be true or false
+      @unique       = options.fetch :unique,       false  # must be true or false
       @offset       = options.fetch :offset,       0      # must be an Integer greater than or equal to 0
       @limit        = options.fetch :limit,        nil    # must be an Integer greater than or equal to 1
       @order        = options.fetch :order,        model.default_order   # must be an Array of Symbol, DM::Query::Direction or DM::Property
@@ -214,18 +222,20 @@ module DataMapper
       options.each do |key, value|
         case key
           when DataMapper::Query::Operator
-            options[key] = properties[key.target].type.dump(value, properties[key.target]) if !properties[key.target].nil? && properties[key.target].custom?
+            options[key] = properties[key.target].type.dump(value, properties[key.target]) if properties.has_property?(key.target) && properties[key.target].custom?
           when Symbol, String
-            options[key] = properties[key].type.dump(value, properties[key]) if !properties[key].nil? && properties[key].custom?
+            options[key] = properties[key].type.dump(value, properties[key]) if properties.has_property?(key) && properties[key].custom?
         end
       end
     end
 
     # validate the options
     def assert_valid_options(options)
-      # validate the reload option
-      if options.has_key?(:reload) && options[:reload] != true && options[:reload] != false
-        raise ArgumentError, "+options[:reload]+ must be true or false, but was #{options[:reload].inspect}", caller(2)
+      # validate the reload option and unique option
+      ([ :reload, :unique ] & options.keys).each do |attribute|
+        if options[attribute] != true && options[attribute] != false
+          raise ArgumentError, "+options[:#{attribute}]+ must be true or false, but was #{options[attribute].inspect}", caller(2)
+        end
       end
 
       # validate the offset and limit options
@@ -248,7 +258,17 @@ module DataMapper
         assert_kind_of "options[:#{attribute}]", value, Array
 
         if value.empty?
-          raise ArgumentError, "+options[:#{attribute}]+ cannot be empty", caller(2)
+          if attribute == :fields
+            if options[:unique] == false
+              raise ArgumentError, '+options[:fields]+ cannot be empty if +options[:unique] is false', caller(2)
+            end
+          elsif attribute == :order
+            if options[:fields] && options[:fields].any? { |p| !p.kind_of?(Operator) }
+              raise ArgumentError, '+options[:order]+ cannot be empty if +options[:fields] contains a non-operator', caller(2)
+            end
+          else
+            raise ArgumentError, "+options[:#{attribute}]+ cannot be empty", caller(2)
+          end
         end
       end
 
@@ -318,9 +338,10 @@ module DataMapper
     # normalize fields to DM::Property
     def normalize_fields(fields)
       # TODO: return a PropertySet
+      # TODO: raise an exception if the property is not available in the repository
       fields.map do |field|
         case field
-          when Property
+          when Property, Operator
             # TODO: if the Property's model doesn't match
             # self.model, append the property's model to @links
             # eg:
@@ -527,6 +548,8 @@ module DataMapper
       end
 
       def ==(other)
+        return true if super
+        return false unless other.kind_of?(self.class)
         @operator == other.operator && @target == other.target
       end
 
@@ -542,6 +565,8 @@ module DataMapper
 
     class Path
       include Assertions
+			
+			%w[ id type ].each { |m| undef_method m }
 
       attr_reader :relationships, :model, :property, :operator
 

data/lib/dm-core/resource.rb

@@ -2,6 +2,8 @@ require 'set'
 
 module DataMapper
   module Resource
+    include Assertions
+
     ##
     #
     # Appends a module for inclusion into the model class after
@@ -22,12 +24,10 @@ module DataMapper
       extra_inclusions.concat inclusions
       true
     end
-    
+
     def self.extra_inclusions
       @extra_inclusions ||= []
     end
-    
-    include Assertions
 
     # When Resource is included in a class this method makes sure
     # it gets all the methods
@@ -334,11 +334,7 @@ module DataMapper
     # --
     # @api public
     def loaded_attributes
-      names = []
-      properties.each do |property|
-        names << property.name if attribute_loaded?(property.name)
-      end
-      names
+      properties.map{|p| p.name if attribute_loaded?(p.name)}.compact
     end
 
     # set of original values of properties
@@ -471,7 +467,9 @@ module DataMapper
     # --
     # @api public
     def attributes
-      properties.map{|p| [p.name,send(p.getter)] if p.reader_visibility == :public}.compact.to_hash
+      properties.map do |p|
+        [p.name, send(p.getter)] if p.reader_visibility == :public
+      end.compact.to_hash
     end
 
     # Mass assign of attributes
@@ -485,9 +483,11 @@ module DataMapper
       values_hash.each_pair do |k,v|
         setter = "#{k.to_s.sub(/\?\z/, '')}="
 
-        # use the attribute mutator if it is public to set the value
-        next unless respond_to?(setter, false)
-        send(setter, v)
+        if respond_to?(setter)
+          send(setter, v)
+        else
+          raise NameError, "#{setter} is not a public property"
+        end
       end
     end
 
@@ -585,7 +585,7 @@ module DataMapper
     end
 
     def lazy_load(name)
-      reload_attributes(*properties.lazy_load_context(name))
+      reload_attributes(*properties.lazy_load_context(name) - loaded_attributes)
     end
 
     def child_associations