ardm-core 1.2.1

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

@@ -0,0 +1,22 @@
+module DataMapper
+  class Property
+    class Binary < String
+      include PassThroughLoadDump
+
+      if RUBY_VERSION >= "1.9"
+
+        def load(value)
+          super.dup.force_encoding("BINARY") unless value.nil?
+        end
+
+        def dump(value)
+          value.dup.force_encoding("BINARY") unless value.nil?
+        rescue
+          value
+        end
+
+      end
+
+    end # class Binary
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,31 @@
+module DataMapper
+  class Property
+    class Boolean < Object
+      include PassThroughLoadDump
+
+      primitive ::TrueClass
+
+      TRUE_VALUES  = [ 1, '1', 't', 'T', 'true',  'TRUE'  ].freeze
+      FALSE_VALUES = [ 0, '0', 'f', 'F', 'false', 'FALSE' ].freeze
+      BOOLEAN_MAP  = Hash[
+        TRUE_VALUES.product([ true ]) + FALSE_VALUES.product([ false ]) ].freeze
+
+      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)
+        BOOLEAN_MAP.fetch(value, 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)
+        DataMapper::Ext::Module.find_const(model, 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,45 @@
+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 [Hash, #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.is_a?(::Hash) || 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 [Hash, #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,44 @@
+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 [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [DateTime]
+      #   DateTime constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        if value.is_a?(::Hash) || 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 [Hash, #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,50 @@
+module DataMapper
+  class Property
+    class Decimal < Numeric
+      primitive BigDecimal
+
+      DEFAULT_PRECISION = 10
+      DEFAULT_SCALE     = 0
+
+      precision(DEFAULT_PRECISION)
+      scale(DEFAULT_SCALE)
+
+      protected
+
+      def initialize(model, name, options = {})
+        super
+
+        [ :scale, :precision ].each do |key|
+          unless @options.key?(key)
+            warn "options[#{key.inspect}] should be set for #{self.class}, defaulting to #{send(key).inspect} (#{caller.first})"
+          end
+        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
+
+      # 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)
+          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,46 @@
+module DataMapper
+  class Property
+    class Discriminator < Class
+      include PassThroughLoadDump
+
+      default   lambda { |resource, property| resource.model }
+      required  true
+
+      # @api private
+      def bind
+        model.extend Model unless model < Model
+      end
+
+      module Model
+        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)
+          discriminator = self.properties.discriminator
+          default_scope = model.default_scope(discriminator.repository_name)
+          default_scope.update(discriminator.name => model.descendants.dup << model)
+        end
+      end
+    end # class Discriminator
+  end # module Property
+end # module DataMapper

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

@@ -0,0 +1,28 @@
+module DataMapper
+  class Property
+    class Float < Numeric
+      primitive ::Float
+
+      DEFAULT_PRECISION = 10
+      DEFAULT_SCALE     = nil
+
+      precision(DEFAULT_PRECISION)
+      scale(DEFAULT_SCALE)
+
+      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 = {})
+        if options.key?(:serial) && !kind_of?(Serial)
+          raise "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/lookup.rb

@@ -0,0 +1,29 @@
+module DataMapper
+  class Property
+    module Lookup
+
+      protected
+
+      #
+      # Provides transparent access to the Properties defined in
+      # {Property}.
+      #
+      # @param [Symbol] name
+      #   The name of the property to lookup.
+      #
+      # @return [Property]
+      #   The property with the given name.
+      #
+      # @raise [NameError]
+      #   The property could not be found.
+      #
+      # @api private
+      #
+      # @since 1.0.1
+      #
+      def const_missing(name)
+        Property.find_class(name.to_s) || super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+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_NUMERIC_MIN = 0
+      DEFAULT_NUMERIC_MAX = 2**31-1
+
+      protected
+
+      def initialize(model, name, options = {})
+        super
+
+        if @primitive == BigDecimal || @primitive == ::Float
+          @precision = @options.fetch(:precision)
+          @scale     = @options.fetch(:scale)
+
+          unless @precision > 0
+            raise ArgumentError, "precision must be greater than 0, but was #{@precision.inspect}"
+          end
+        end
+
+        if @options.key?(:min) || @options.key?(:max)
+          @min = @options.fetch(:min, self.class::DEFAULT_NUMERIC_MIN)
+          @max = @options.fetch(:max, self.class::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,28 @@
+module DataMapper
+  class Property
+    class Object < Property
+      primitive ::Object
+
+      # @api semipublic
+      def dump(value)
+        return if value.nil?
+        [ Marshal.dump(value) ].pack('m')
+      end
+
+      # @api semipublic
+      def load(value)
+        case value
+          when ::String
+            Marshal.load(value.unpack('m').first)
+          when ::Object
+            value
+          end
+      end
+
+      # @api private
+      def to_child_key
+        self.class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module DataMapper
+  class Property
+    class Serial < Integer
+      serial    true
+      min       1
+
+      # @api private
+      def to_child_key
+        Property::Integer
+      end
+    end # class Text
+  end # module Property
+end # module DataMapper