dm-core 0.10.2 → 1.0.0.rc1

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

@@ -0,0 +1,7 @@
+module DataMapper
+  class Property
+    class Binary < String
+      include PassThroughLoadDump
+    end # class Binary
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,35 @@
+module DataMapper
+  class Property
+    class Boolean < Object
+      include PassThroughLoadDump
+
+      primitive ::TrueClass
+
+      def primitive?(value)
+        value == true || value == false
+      end
+
+      # Typecast a value to a true or false
+      #
+      # @param [Integer, #to_str] value
+      #   value to typecast
+      #
+      # @return [Boolean]
+      #   true or false constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        if value.kind_of?(::Integer)
+          return true  if value == 1
+          return false if value == 0
+        elsif value.respond_to?(:to_str)
+          string_value = value.to_str.downcase
+          return true  if %w[ true  1 t ].include?(string_value)
+          return false if %w[ false 0 f ].include?(string_value)
+        end
+
+        value
+      end
+    end # class Boolean
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,24 @@
+module DataMapper
+  class Property
+    class Class < Object
+      include PassThroughLoadDump
+
+      primitive ::Class
+
+      # Typecast a value to a Class
+      #
+      # @param [#to_s] value
+      #   value to typecast
+      #
+      # @return [Class]
+      #   Class constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        model.find_const(value.to_s)
+      rescue NameError
+        value
+      end
+    end # class Class
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,47 @@
+require 'dm-core/property/typecast/time'
+
+module DataMapper
+  class Property
+    class Date < Object
+      include PassThroughLoadDump
+      include Typecast::Time
+
+      primitive ::Date
+
+      # Typecasts an arbitrary value to a Date
+      # Handles both Hashes and Date instances.
+      #
+      # @param [#to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [Date]
+      #   Date constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        if value.respond_to?(:to_date)
+          value.to_date
+        elsif value.respond_to?(:to_mash)
+          typecast_hash_to_date(value)
+        else
+          ::Date.parse(value.to_s)
+        end
+      rescue ArgumentError
+        value
+      end
+
+      # Creates a Date instance from a Hash with keys :year, :month, :day
+      #
+      # @param [#to_mash] value
+      #   value to be typecast
+      #
+      # @return [Date]
+      #   Date constructed from hash
+      #
+      # @api private
+      def typecast_hash_to_date(value)
+        ::Date.new(*extract_time(value)[0, 3])
+      end
+    end # class Date
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,48 @@
+require 'dm-core/property/typecast/time'
+
+module DataMapper
+  class Property
+    class DateTime < Object
+      include PassThroughLoadDump
+      include Typecast::Time
+
+      primitive ::DateTime
+
+      # Typecasts an arbitrary value to a DateTime.
+      # Handles both Hashes and DateTime instances.
+      #
+      # @param [#to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [DateTime]
+      #   DateTime constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        if value.respond_to?(:to_datetime)
+          value.to_datetime
+        elsif value.respond_to?(:to_mash)
+          typecast_hash_to_datetime(value)
+        else
+          ::DateTime.parse(value.to_s)
+        end
+      rescue ArgumentError
+        value
+      end
+
+      # Creates a DateTime instance from a Hash with keys :year, :month, :day,
+      # :hour, :min, :sec
+      #
+      # @param [#to_mash] value
+      #   value to be typecast
+      #
+      # @return [DateTime]
+      #   DateTime constructed from hash
+      #
+      # @api private
+      def typecast_hash_to_datetime(value)
+        ::DateTime.new(*extract_time(value))
+      end
+    end # class DateTime
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,43 @@
+module DataMapper
+  class Property
+    class Decimal < Numeric
+      primitive BigDecimal
+
+      DEFAULT_SCALE = 0
+
+      protected
+
+      def initialize(model, name, options = {}, type = nil)
+        super
+
+        unless @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}"
+          end
+        end
+      end
+
+      # Typecast a value to a BigDecimal
+      #
+      # @param [#to_str, #to_d, Integer] value
+      #   value to typecast
+      #
+      # @return [BigDecimal]
+      #   BigDecimal constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        if value.kind_of?(::Integer)
+          # TODO: remove this case when Integer#to_d added by extlib
+          value.to_s.to_d
+        else
+          typecast_to_numeric(value, :to_d)
+        end
+      end
+    end # class Decimal
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,48 @@
+module DataMapper
+  class Property
+    class Discriminator < Class
+      include PassThroughLoadDump
+
+      default   lambda { |resource, property| resource.model }
+      required  true
+
+      # @api private
+      def bind
+        model.default_scope(repository_name).update(name => model.descendants)
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          extend Chainable
+
+          extendable do
+            def inherited(model)
+              super  # setup self.descendants
+              set_discriminator_scope_for(model)
+            end
+
+            def new(*args, &block)
+              if args.size == 1 && args.first.kind_of?(Hash)
+                discriminator = properties(repository_name).discriminator
+
+                if discriminator_value = args.first[discriminator.name]
+                  model = discriminator.typecast_to_primitive(discriminator_value)
+
+                  if model.kind_of?(Model) && !model.equal?(self)
+                    return model.new(*args, &block)
+                  end
+                end
+              end
+
+              super
+            end
+
+            private
+
+            def set_discriminator_scope_for(model)
+              model.default_scope(#{repository_name.inspect}).update(#{name.inspect} => model.descendants)
+            end
+          end
+        RUBY
+      end
+    end # class Discriminator
+  end # module Types
+end # module DataMapper

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

@@ -0,0 +1,24 @@
+module DataMapper
+  class Property
+    class Float < Numeric
+      primitive ::Float
+
+      DEFAULT_SCALE = nil
+
+      protected
+
+      # Typecast a value to a Float
+      #
+      # @param [#to_str, #to_f] value
+      #   value to typecast
+      #
+      # @return [Float]
+      #   Float constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        typecast_to_numeric(value, :to_f)
+      end
+    end # class Float
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,32 @@
+module DataMapper
+  class Property
+    class Integer < Numeric
+      primitive ::Integer
+
+      accept_options :serial
+
+      protected
+
+      # @api semipublic
+      def initialize(model, name, options = {}, type = nil)
+        if options.key?(:serial) && !kind_of?(Serial)
+          warn "Integer #{name} with explicit :serial option is deprecated, use Serial instead (#{caller[2]})"
+        end
+        super
+      end
+
+      # Typecast a value to an Integer
+      #
+      # @param [#to_str, #to_i] value
+      #   value to typecast
+      #
+      # @return [Integer]
+      #   Integer constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        typecast_to_numeric(value, :to_i)
+      end
+    end # class Integer
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,43 @@
+require 'dm-core/property/typecast/numeric'
+
+module DataMapper
+  class Property
+    class Numeric < Object
+      include PassThroughLoadDump
+      include Typecast::Numeric
+
+      accept_options :precision, :scale, :min, :max
+      attr_reader :precision, :scale, :min, :max
+
+      DEFAULT_PRECISION        = 10
+      DEFAULT_NUMERIC_MIN      = 0
+      DEFAULT_NUMERIC_MAX      = 2**31-1
+
+      protected
+
+      def initialize(model, name, options = {}, type = nil)
+        super
+
+        if [ BigDecimal, ::Float ].include?(@primitive)
+          @precision = @options.fetch(:precision, DEFAULT_PRECISION)
+          @scale     = @options.fetch(:scale,     self.class::DEFAULT_SCALE)
+
+          unless @precision > 0
+            raise ArgumentError, "precision must be greater than 0, but was #{@precision.inspect}"
+          end
+        end
+
+        if (@options.keys & [ :min, :max ]).any?
+          @min = @options.fetch(:min, DEFAULT_NUMERIC_MIN)
+          @max = @options.fetch(:max, DEFAULT_NUMERIC_MAX)
+
+          if @max < DEFAULT_NUMERIC_MIN && !@options.key?(:min)
+            raise ArgumentError, "min should be specified when the max is less than #{DEFAULT_NUMERIC_MIN}"
+          elsif @max < @min
+            raise ArgumentError, "max must be less than the min, but was #{@max} while the min was #{@min}"
+          end
+        end
+      end
+    end # class Numeric
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,32 @@
+module DataMapper
+  class Property
+    class Object < Property
+      primitive ::Object
+
+      # @api semipublic
+      def dump(value)
+        return value if value.nil?
+
+        if @type
+          @type.dump(value, self)
+        else
+          [ Marshal.dump(value) ].pack('m')
+        end
+      end
+
+      # @api semipublic
+      def load(value)
+        if @type
+          return @type.load(value, self)
+        end
+
+        case value
+          when ::String
+            Marshal.load(value.unpack('m').first)
+          when ::Object
+            value
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module DataMapper
+  class Property
+    class Serial < Integer
+      serial    true
+      min       1
+    end # class Text
+  end # module Types
+end # module DataMapper

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

@@ -0,0 +1,49 @@
+module DataMapper
+  class Property
+    class String < Object
+      include PassThroughLoadDump
+
+      primitive ::String
+
+      accept_options :length
+
+      DEFAULT_LENGTH = 50
+
+      # Returns maximum property length (if applicable).
+      # This usually only makes sense when property is of
+      # type Range or custom
+      #
+      # @return [Integer, nil]
+      #   the maximum length of this property
+      #
+      # @api semipublic
+      def length
+        if @length.kind_of?(Range)
+          @length.max
+        else
+          @length
+        end
+      end
+
+      protected
+
+      def initialize(model, name, options = {}, type = nil)
+        super
+        @length = @options.fetch(:length, DEFAULT_LENGTH)
+      end
+
+      # Typecast a value to a String
+      #
+      # @param [#to_s] value
+      #   value to typecast
+      #
+      # @return [String]
+      #   String constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        value.to_s
+      end
+    end # class String
+  end # class Property
+end # module DataMapper