ghost_dm-core 1.3.0.beta

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

@@ -0,0 +1,21 @@
+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") 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,20 @@
+module DataMapper
+  class Property
+    class Boolean < Object
+      load_as         ::TrueClass
+      dump_as         ::TrueClass
+      coercion_method :to_boolean
+
+      # @api semipublic
+      def value_dumped?(value)
+        value_loaded?(value)
+      end
+
+      # @api semipublic
+      def value_loaded?(value)
+        value == true || value == false
+      end
+
+    end # class Boolean
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,17 @@
+module DataMapper
+  class Property
+    class Class < Object
+      load_as         ::Class
+      dump_as         ::Class
+      coercion_method :to_constant
+
+      # @api semipublic
+      def typecast(value)
+        DataMapper::Ext::Module.find_const(model, value.to_s) unless value.nil?
+      rescue NameError
+        value
+      end
+
+    end # class Class
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,10 @@
+module DataMapper
+  class Property
+    class Date < Object
+      load_as         ::Date
+      dump_as         ::Date
+      coercion_method :to_date
+
+    end # class Date
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,10 @@
+module DataMapper
+  class Property
+    class DateTime < Object
+      load_as         ::DateTime
+      dump_as         ::DateTime
+      coercion_method :to_datetime
+
+    end # class DateTime
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,36 @@
+module DataMapper
+  class Property
+    class Decimal < Numeric
+      load_as         BigDecimal
+      dump_as         BigDecimal
+      coercion_method :to_decimal
+
+      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
+
+    end # class Decimal
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,44 @@
+module DataMapper
+  class Property
+    class Discriminator < Class
+      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(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,16 @@
+module DataMapper
+  class Property
+    class Float < Numeric
+      load_as         ::Float
+      dump_as         ::Float
+      coercion_method :to_float
+
+      DEFAULT_PRECISION = 10
+      DEFAULT_SCALE     = nil
+
+      precision(DEFAULT_PRECISION)
+      scale(DEFAULT_SCALE)
+
+    end # class Float
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,22 @@
+module DataMapper
+  class Property
+    class Integer < Numeric
+      load_as         ::Integer
+      dump_as         ::Integer
+      coercion_method :to_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
+
+    end # class Integer
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,22 @@
+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 = "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 # class InvalidValueError
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,27 @@
+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
+      #
+      def const_missing(name)
+        Property.find_class(name.to_s) || super
+      end
+
+    end # module Lookup
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,38 @@
+module DataMapper
+  class Property
+    class Numeric < Object
+      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 kind_of?(Decimal) || kind_of?(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,34 @@
+module DataMapper
+  class Property
+    class Object < Property
+      load_as         ::Object
+      dump_as         ::Object
+      coercion_method :to_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.unpack('m').first) 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,14 @@
+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

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

@@ -0,0 +1,38 @@
+module DataMapper
+  class Property
+    class String < Object
+      load_as         ::String
+      dump_as         ::String
+      coercion_method :to_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.kind_of?(Range)
+          @length.max
+        else
+          @length
+        end
+      end
+
+    protected
+
+      def initialize(model, name, options = {})
+        super
+        @length = @options.fetch(:length)
+      end
+
+    end # class String
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,9 @@
+module DataMapper
+  class Property
+    class Text < String
+      length 65535
+      lazy   true
+
+    end # class Text
+  end # class Property
+end # module DataMapper

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

@@ -0,0 +1,10 @@
+module DataMapper
+  class Property
+    class Time < Object
+      load_as         ::Time
+      dump_as         ::Time
+      coercion_method :to_time
+
+    end # class Time
+  end # class Property
+end # module DataMapper

data/lib/dm-core/property_set.rb

@@ -0,0 +1,177 @@
+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 < SubjectSet
+    include Enumerable
+
+    def <<(property)
+      clear_cache
+      super
+    end
+
+    # 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, 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
+
+    def |(other)
+      self.class.new(to_a | other.to_a)
+    end
+
+    def &(other)
+      self.class.new(to_a & other.to_a)
+    end
+
+    def -(other)
+      self.class.new(to_a - other.to_a)
+    end
+
+    def +(other)
+      self.class.new(to_a + other.to_a)
+    end
+
+    def ==(other)
+      to_a == other.to_a
+    end
+
+    # TODO: make PropertySet#reject return a PropertySet instance
+    # @api semipublic
+    def defaults
+      @defaults ||= self.class.new(key | [ discriminator ].compact | reject { |property| property.lazy? }).freeze
+    end
+
+    # @api semipublic
+    def key
+      @key ||= self.class.new(select { |property| property.key? }).freeze
+    end
+
+    # @api semipublic
+    def discriminator
+      @discriminator ||= detect { |property| property.kind_of?(Property::Discriminator) }
+    end
+
+    # @api semipublic
+    def indexes
+      index_hash = {}
+      each { |property| parse_index(property.index, property.field, index_hash) }
+      index_hash
+    end
+
+    # @api semipublic
+    def unique_indexes
+      index_hash = {}
+      each { |property| parse_index(property.unique_index, property.field, index_hash) }
+      index_hash
+    end
+
+    # @api semipublic
+    def get(resource)
+      return [] if resource.nil?
+      map { |property| resource.__send__(property.name) }
+    end
+
+    # @api semipublic
+    def get!(resource)
+      map { |property| property.get!(resource) }
+    end
+
+    # @api semipublic
+    def set(resource, values)
+      zip(values) { |property, value| resource.__send__("#{property.name}=", value) }
+    end
+
+    # @api semipublic
+    def set!(resource, values)
+      zip(values) { |property, value| property.set!(resource, value) }
+    end
+
+    # @api semipublic
+    def loaded?(resource)
+      all? { |property| property.loaded?(resource) }
+    end
+
+    # @api semipublic
+    def valid?(values)
+      zip(values.nil? ? [] : values).all? { |property, value| property.valid?(value) }
+    end
+
+    # @api semipublic
+    def typecast(values)
+      zip(values.nil? ? [] : values).map { |property, value| property.typecast(value) }
+    end
+
+    # @api private
+    def property_contexts(property)
+      contexts = []
+      lazy_contexts.each do |context, properties|
+        contexts << context if properties.include?(property)
+      end
+      contexts
+    end
+
+    # @api private
+    def lazy_context(context)
+      lazy_contexts[context] ||= []
+    end
+
+    # @api private
+    def in_context(properties)
+      properties_in_context = properties.map do |property|
+        if (contexts = property_contexts(property)).any?
+          lazy_contexts.values_at(*contexts)
+        else
+          property
+        end
+      end
+
+      properties_in_context.flatten.uniq
+    end
+
+    # @api private
+    def field_map
+      Hash[ map { |property| [ property.field, property ] } ]
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    private
+
+    # @api private
+    def clear_cache
+      @defaults, @key, @discriminator = nil
+    end
+
+    # @api private
+    def lazy_contexts
+      @lazy_contexts ||= {}
+    end
+
+    # @api private
+    def parse_index(index, property, index_hash)
+      case index
+        when true
+          index_hash[property] = [ property ]
+        when Symbol
+          index_hash[index] ||= []
+          index_hash[index] << property
+        when Array
+          index.each { |idx| parse_index(idx, property, index_hash) }
+      end
+    end
+  end # class PropertySet
+end # module DataMapper