Active Model BigInteger Type

Attribute type for integers that can be serialized to an unlimited number of bytes. This type is registered under the :big_integer key.

class Person
  include ActiveModel::Attributes

  attribute :id, :big_integer
end

person = Person.new
person.id = "18_000_000_000"

person.id # => 18000000000

All casting and serialization are performed in the same way as the standard ActiveModel::Type::Integer type.

Active Model Binary Type

Attribute type for representation of binary data. This type is registered under the :binary key.

Non-string values are coerced to strings using their to_s method.

Active Model Boolean Type

A class that behaves like a boolean type, including rules for coercion of user input.

• "false", "f", "0", 0 or any other value in FALSE_VALUES will be coerced to false.

• Empty strings are coerced to nil.

• All other values will be coerced to true.

Active Model Decimal Type

Attribute type for decimal, high-precision floating point numeric representation. It is registered under the :decimal key.

class BagOfCoffee
  include ActiveModel::Attributes

  attribute :weight, :decimal
end

Numeric instances are converted to BigDecimal instances. Any other objects are cast using their to_d method, except for blank strings, which are cast to nil. If a to_d method is not defined, the object is converted to a string using to_s, which is then cast using to_d.

bag = BagOfCoffee.new

bag.weight = 0.01
bag.weight # => 0.1e-1

bag.weight = "0.01"
bag.weight # => 0.1e-1

bag.weight = ""
bag.weight # => nil

bag.weight = :arbitrary
bag.weight # => nil (the result of `.to_s.to_d`)

Decimal precision defaults to 18, and can be customized when declaring an attribute:

class BagOfCoffee
  include ActiveModel::Attributes

  attribute :weight, :decimal, precision: 24
end

Active Model Float Type

Attribute type for floating point numeric values. It is registered under the :float key.

class BagOfCoffee
  include ActiveModel::Attributes

  attribute :weight, :float
end

Values are cast using their to_f method, except for the following strings:

• Blank strings are cast to nil.

• "Infinity" is cast to Float::INFINITY.

• "-Infinity" is cast to -Float::INFINITY.

• "NaN" is cast to Float::NAN.

  bag = BagOfCoffee.new

  bag.weight = “0.25” bag.weight # => 0.25

  bag.weight = “” bag.weight # => nil

  bag.weight = “NaN” bag.weight # => Float::NAN

Active Model ImmutableString Type

Attribute type to represent immutable strings. It casts incoming values to frozen strings.

class Person
  include ActiveModel::Attributes

  attribute :name, :immutable_string
end

person = Person.new
person.name = 1

person.name # => "1"
person.name.frozen? # => true

Values are coerced to strings using their to_s method. Boolean values are treated differently, however: true will be cast to "t" and false will be cast to "f". These strings can be customized when declaring an attribute:

class Person
  include ActiveModel::Attributes

  attribute :active, :immutable_string, true: "aye", false: "nay"
end

person = Person.new
person.active = true

person.active # => "aye"

Active Model Integer Type

Attribute type for integer representation. This type is registered under the :integer key.

class Person
  include ActiveModel::Attributes

  attribute :age, :integer
end

Values are cast using their to_i method, except for blank strings, which are cast to nil. If a to_i method is not defined or raises an error, the value will be cast to nil.

person = Person.new

person.age = "18"
person.age # => 18

person.age = ""
person.age # => nil

person.age = :not_an_integer
person.age # => nil (because Symbol does not define #to_i)

Serialization also works under the same principle. Non-numeric strings are serialized as nil, for example.

Serialization also validates that the integer can be stored using a limited number of bytes. If it cannot, an ActiveModel::RangeError will be raised. The default limit is 4 bytes, and can be customized when declaring an attribute:

class Person
  include ActiveModel::Attributes

  attribute :age, :integer, limit: 6
end

Active Model String Type

Attribute type for strings. It is registered under the :string key.

This class is a specialization of ActiveModel::Type::ImmutableString. It performs coercion in the same way, and can be configured in the same way. However, it accounts for mutable strings, so dirty tracking can properly check if a string has changed.

Active Model Value Type

The base class for all attribute types. This class also serves as the default type for attributes that do not specify a type.