# class ActiveModel::Type::Value

### Attributes

limit[R]
precision[R]
scale[R]

### Public Class Methods

new(precision: nil, limit: nil, scale: nil) click to toggle source

    # File lib/active_model/type/value.rb, line 6
    def initialize(precision: nil, limit: nil, scale: nil)
      @precision = precision
      @scale = scale
      @limit = limit
    end

### Public Instance Methods

==(other) click to toggle source

    # File lib/active_model/type/value.rb, line 91
    def ==(other)
      self.class == other.class &&
        precision == other.precision &&
        scale == other.scale &&
        limit == other.limit
    end

Also aliased as: eql?
assert_valid_value(*) click to toggle source

    # File lib/active_model/type/value.rb, line 103
    def assert_valid_value(*)
    end

cast(value) click to toggle source

Type casts a value from user input (e.g. from a setter). This value may be a string from the form builder, or a ruby object passed to a setter. There is currently no way to differentiate between which source it came from.

The return value of this method will be returned from ActiveRecord::AttributeMethods::Read#read_attribute. See also: #cast_value.

`value` The raw input, as provided to the attribute setter.

    # File lib/active_model/type/value.rb, line 35
    def cast(value)
      cast_value(value) unless value.nil?
    end

changed?(old_value, new_value, _new_value_before_type_cast) click to toggle source

Determines whether a value has changed for dirty checking. `old_value` and `new_value` will always be type-cast. Types should not need to override this method.

    # File lib/active_model/type/value.rb, line 62
    def changed?(old_value, new_value, _new_value_before_type_cast)
      old_value != new_value
    end

changed_in_place?(raw_old_value, new_value) click to toggle source

Determines whether the mutable value has been modified since it was read. Returns `false` by default. If your type returns an object which could be mutated, you should override this method. You will need to either:

- pass `new_value` to #serialize and compare it to `raw_old_value`

or

- pass `raw_old_value` to #deserialize and compare it to `new_value`

`raw_old_value` The original value, before being passed to `deserialize`.

`new_value` The current value, after type casting.

    # File lib/active_model/type/value.rb, line 83
    def changed_in_place?(raw_old_value, new_value)
      false
    end

deserialize(value) click to toggle source

Converts a value from database input to the appropriate ruby type. The return value of this method will be returned from ActiveRecord::AttributeMethods::Read#read_attribute. The default implementation just calls #cast.

`value` The raw input, as provided from the database.

    # File lib/active_model/type/value.rb, line 21
    def deserialize(value)
      cast(value)
    end

eql?(other)
Alias for: ==
hash() click to toggle source

    # File lib/active_model/type/value.rb, line 99
    def hash
      [self.class, precision, scale, limit].hash
    end

serialize(value) click to toggle source

Casts a value from the ruby type to a type that the database knows how to understand. The returned value from this method should be a `String`, `Numeric`, `Date`, `Time`, `Symbol`, `true`, `false`, or `nil`.

    # File lib/active_model/type/value.rb, line 43
    def serialize(value)
      value
    end

### Private Instance Methods

cast_value(value) click to toggle source

Convenience method for types which do not need separate type casting behavior for user and database inputs. Called by #cast for values except `nil`.

    # File lib/active_model/type/value.rb, line 111
    def cast_value(value) # :doc:
      value
    end