sbf-dm-core 1.3.0.beta

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

@@ -0,0 +1,19 @@
+module DataMapper
+  class Property
+    class Binary < String
+      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')
+        rescue
+          value
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module DataMapper
+  class Property
+    class Boolean < Object
+      load_as ::TrueClass
+      dump_as ::TrueClass
+
+      TRUE_VALUES  = [1, '1', 't', 'T', 'true',  'TRUE'].freeze
+      FALSE_VALUES = [0, '0', 'f', 'F', 'false', 'FALSE'].freeze
+      BOOLEAN_MAP  = (TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])).to_h.freeze
+
+      # @api semipublic
+      def value_dumped?(value)
+        value_loaded?(value)
+      end
+
+      # @api semipublic
+      def value_loaded?(value)
+        [true, false].include?(value)
+      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
+  end
+end

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

@@ -0,0 +1,23 @@
+module DataMapper
+  class Property
+    class Class < Object
+      load_as ::Class
+      dump_as ::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
+  end
+end

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

@@ -0,0 +1,45 @@
+module DataMapper
+  class Property
+    class Date < Object
+      include Typecast::Time
+
+      load_as ::Date
+      dump_as ::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
+  end
+end

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

@@ -0,0 +1,44 @@
+module DataMapper
+  class Property
+    class DateTime < Object
+      include Typecast::Time
+
+      load_as ::DateTime
+      dump_as ::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
+  end
+end

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

@@ -0,0 +1,47 @@
+module DataMapper
+  class Property
+    class Decimal < Numeric
+      load_as BigDecimal
+      dump_as BigDecimal
+
+      DEFAULT_PRECISION = 10
+      DEFAULT_SCALE     = 0
+
+      precision(DEFAULT_PRECISION)
+      scale(DEFAULT_SCALE)
+
+      protected def initialize(model, name, options = {})
+        super
+
+        %i(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
+
+        raise ArgumentError, "scale must be equal to or greater than 0, but was #{@scale.inspect}" unless @scale >= 0
+
+        return if @precision >= @scale
+
+        raise ArgumentError, "precision must be equal to or greater than scale, but was #{@precision.inspect} and scale was #{@scale.inspect}"
+      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
+      protected def typecast_to_primitive(value)
+        if value.is_a?(::Integer)
+          value.to_s.to_d
+        else
+          typecast_to_numeric(value, :to_d)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module DataMapper
+  class Property
+    class Discriminator < Class
+      default   ->(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.is_a?(Hash)
+            discriminator = properties(repository_name).discriminator
+
+            if (discriminator_value = args.first[discriminator.name])
+              model = discriminator.typecast_to_primitive(discriminator_value)
+
+              return model.new(*args, &block) if model.is_a?(Model) && !model.equal?(self)
+            end
+          end
+
+          super
+        end
+
+        private def set_discriminator_scope_for(model)
+          discriminator = properties.discriminator
+          default_scope = model.default_scope(discriminator.repository_name)
+          default_scope.update(discriminator.name => model.descendants.dup << model)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,32 @@
+module DataMapper
+  class Property
+    class Integer < Numeric
+      load_as ::Integer
+      dump_as ::Integer
+
+      accept_options :serial
+
+      # @api semipublic
+      protected def initialize(model, name, options = {})
+        if options.key?(:serial) && !is_a?(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
+      protected def typecast_to_primitive(value)
+        typecast_to_numeric(value, :to_i)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module DataMapper
+  class Property
+    # Exception raised when DataMapper is about to work with
+    # invalid property values.
+    class InvalidValueError < StandardError
+      attr_reader :property, :value
+
+      def initialize(property, value)
+        msg = format('Invalid value %s for property %s (%s) on model %s', value.inspect, property.name.inspect, property.class.name,
+                     property.model.name)
+        super(msg)
+        @property = property
+        @value = value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module DataMapper
+  class Property
+    module Lookup
+      #
+      # 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
+      #
+      protected 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,35 @@
+module DataMapper
+  class Property
+    class Numeric < Object
+      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 is_a?(Decimal) || is_a?(Float)
+          @precision = @options.fetch(:precision)
+          @scale     = @options.fetch(:scale)
+
+          raise ArgumentError, "precision must be greater than 0, but was #{@precision.inspect}" unless @precision > 0
+        end
+
+        return unless @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
+end

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

@@ -0,0 +1,33 @@
+module DataMapper
+  class Property
+    class Object < Property
+      load_as ::Object
+      dump_as ::Object
+
+      # @api semipublic
+      def dump(value)
+        instance_of?(Object) ? marshal(value) : value
+      end
+
+      # @api semipublic
+      def load(value)
+        typecast(instance_of?(Object) ? unmarshal(value) : value)
+      end
+
+      # @api semipublic
+      def marshal(value)
+        [Marshal.dump(value)].pack('m') unless value.nil?
+      end
+
+      # @api semipublic
+      def unmarshal(value)
+        Marshal.load(value.unpack1('m')) unless value.nil?
+      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
+  end
+end

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

@@ -0,0 +1,47 @@
+module DataMapper
+  class Property
+    class String < Object
+      load_as ::String
+      dump_as ::String
+
+      accept_options :length
+
+      DEFAULT_LENGTH = 50
+      length(DEFAULT_LENGTH)
+
+      # 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.is_a?(Range)
+          @length.max
+        else
+          @length
+        end
+      end
+
+      protected def initialize(model, name, options = {})
+        super
+        @length = @options.fetch(:length)
+      end
+
+      # Typecast a value to a String
+      #
+      # @param [#to_s] value
+      #   value to typecast
+      #
+      # @return [String]
+      #   String constructed from value
+      #
+      # @api private
+      protected def typecast_to_primitive(value)
+        value.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module DataMapper
+  class Property
+    class Text < String
+      length  65_535
+      lazy    true
+
+      def primitive?(value)
+        value.is_a?(::String)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module DataMapper
+  class Property
+    class Time < Object
+      include Typecast::Time
+
+      load_as ::Time
+      dump_as ::Time
+
+      # Typecasts an arbitrary value to a Time
+      # Handles both Hashes and Time instances.
+      #
+      # @param [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [Time]
+      #   Time constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        if value.respond_to?(:to_time)
+          value.to_time
+        elsif value.is_a?(::Hash) || value.respond_to?(:to_mash)
+          typecast_hash_to_time(value)
+        else
+          ::Time.parse(value.to_s)
+        end
+      rescue ArgumentError
+        value
+      end
+
+      # Creates a Time instance from a Hash with keys :year, :month, :day,
+      # :hour, :min, :sec
+      #
+      # @param [Hash, #to_mash] value
+      #   value to be typecast
+      #
+      # @return [Time]
+      #   Time constructed from hash
+      #
+      # @api private
+      def typecast_hash_to_time(value)
+        ::Time.local(*extract_time(value))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module DataMapper
+  class Property
+    module Typecast
+      module Numeric
+        # Match numeric string
+        #
+        # @param [#to_str, Numeric] value
+        #   value to typecast
+        # @param [Symbol] method
+        #   method to typecast with
+        #
+        # @return [Numeric]
+        #   number if matched, value if no match
+        #
+        # @api private
+        def typecast_to_numeric(value, method)
+          if value.respond_to?(:to_str)
+            if value.to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+              ::Regexp.last_match(1).send(method)
+            else
+              value
+            end
+          elsif value.respond_to?(method)
+            value.send(method)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dm-core/property/typecast/time.rb

@@ -0,0 +1,33 @@
+module DataMapper
+  class Property
+    module Typecast
+      module Time
+        include Numeric
+
+        # Extracts the given args from the hash. If a value does not exist, it
+        # uses the value of Time.now.
+        #
+        # @param [Hash, #to_mash] value
+        #   value to extract time args from
+        #
+        # @return [Array]
+        #   Extracted values
+        #
+        # @api private
+        def extract_time(value)
+          mash = if value.respond_to?(:to_mash)
+                   value.to_mash
+                 else
+                   DataMapper::Ext::Hash.to_mash(value)
+                 end
+
+          now  = ::Time.now
+
+          %i(year month day hour min sec).map do |segment|
+            typecast_to_numeric(mash.fetch(segment, now.send(segment)), :to_i)
+          end
+        end
+      end
+    end
+  end
+end