### SimpleForm Integration Examples

Source: https://context7.com/brainspec/enumerize/llms.txt

Demonstrates how to use Enumerize with SimpleForm for translated select inputs and radio buttons.

```erb
<%# app/views/users/_form.html.erb %>

<%= simple_form_for @user do |f| %>
  <%# Automatically renders a select with translated options %>
  <%= f.input :status %>

  <%# Render as radio buttons %>
  <%= f.input :role, as: :radio_buttons %>

  <%# With custom collection (overrides enumerize) %>
  <%= f.input :status, collection: User.status.options(only: [:active, :pending]) %>

  <%= f.submit %>
<% end %>
```

--------------------------------

### Formtastic Integration Examples

Source: https://context7.com/brainspec/enumerize/llms.txt

Shows how to integrate Enumerize with Formtastic for localized select inputs, radio buttons, and checkboxes.

```erb
<%# app/views/admin/users/_form.html.erb %>

<%= semantic_form_for [:admin, @user] do |f| %>
  <%= f.inputs do %>
    <%# Automatic select with translated options %>
    <%= f.input :status %>

    <%# As radio buttons %>
    <%= f.input :role, as: :radio %>

    <%# Multiple select for array attributes %>
    <%= f.input :interests, as: :check_boxes %>
  <% end %>

  <%= f.actions do %>
    <%= f.action :submit %>
  <% end %>
<% end %>
```

--------------------------------

### Minitest Integration Setup

Source: https://github.com/brainspec/enumerize/blob/master/README.md

To use Enumerize's RSpec matchers with Minitest, include the `enumerize/integrations/rspec` file and extend `Enumerize::Integrations::RSpec` within your `ActiveSupport::TestCase`.

```ruby
class ActiveSupport::TestCase
  ActiveRecord::Migration.check_pending!

  require 'enumerize/integrations/rspec'
  extend Enumerize::Integrations::RSpec

  ...
end
```

--------------------------------

### Define Enumeration with :in Option

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use the `:in` option to define the possible values for an enumerized attribute. This example shows defining a user status with an array of symbols.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired]
end

describe User do
  it { should enumerize(:status).in(:student, :employed, :retired) }
end
```

--------------------------------

### RSpec Matchers for Enumerized Attributes

Source: https://context7.com/brainspec/enumerize/llms.txt

Provides examples of RSpec matchers for testing enumerized attributes, including values, defaults, predicates, scopes, and multiple selection.

```ruby
# spec/models/user_spec.rb
require 'rails_helper'

RSpec.describe User, type: :model do
  # Basic attribute check
  it { should enumerize(:status) }
  it { is_expected.to enumerize(:role) }

  # Check allowed values
  it { should enumerize(:status).in(:pending, :active, :suspended) }

  # Check custom values (hash)
  it { should enumerize(:role).in(user: 1, admin: 2, moderator: 3) }

  # Check default value
  it { should enumerize(:role).in(:user, :admin).with_default(:user) }

  # Check predicates
  it { should enumerize(:status).in(:active, :pending).with_predicates(true) }
  it { should enumerize(:role).with_predicates(prefix: true) }

  # Check scopes
  it { should enumerize(:status).in(:active, :pending).with_scope(true) }
  it { should enumerize(:status).with_scope(:shallow) }
  it { should enumerize(:priority).with_scope(scope: :by_priority) }

  # Check multiple
  it { should enumerize(:interests).in(:music, :sports).with_multiple(true) }

  # Check i18n_scope
  it { should enumerize(:status).with_i18n_scope('user.statuses') }

  # Combine multiple qualifiers
  it do
    should enumerize(:role)
      .in(:user, :admin, :moderator)
      .with_default(:user)
      .with_predicates(prefix: true)
      .with_scope(true)
  end
end
```

--------------------------------

### Get List of Possible Enumerized Values

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Retrieve an array of all possible string values for an enumerized attribute from the model class.

```ruby
User.status.values # or User.enumerized_attributes[:status].values
# => ['student', 'employed', 'retired']
```

--------------------------------

### Get List of I18n Text Values for Enumerized Attribute

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Generate a list of I18n-translated text for all possible values of an enumerized attribute.

```ruby
User.status.values.collect(&:text)
# => ['Student', 'Employed', 'Retiree']
```

--------------------------------

### Get Form Options for Enumerized Attributes in Ruby

Source: https://context7.com/brainspec/enumerize/llms.txt

Retrieve options suitable for form builders using the `.options` method. You can also exclude specific values from the options list.

```ruby
# Get options for forms
User.status.options                 # => [["Pending", "pending"], ["Active", "active"], ...]
User.status.options(except: :suspended)
```

--------------------------------

### Basic Enumerized Attribute Definition

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Define an enumerated attribute with a set of allowed values. This basic setup is for plain Ruby objects.

```ruby
class User
  extend Enumerize

  enumerize :role, in: [:user, :admin]
end
```

--------------------------------

### Find Specific Enumerized Values in Ruby

Source: https://context7.com/brainspec/enumerize/llms.txt

Use `find_value` to retrieve a specific enumerated value object or `find_values` to get multiple matching value objects. Access the underlying raw value using the `.value` method.

```ruby
# Find specific values
User.role.find_value(:admin)        # => <Value: admin>
User.role.find_value(:admin).value  # => 2

# Check if value exists
User.role.find_values(:user, :admin, :superuser)  # => [<Value: user>, <Value: admin>]
```

--------------------------------

### Get I18n Text for Enumerized Attribute

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Retrieve the I18n-translated text for the current value of an enumerized attribute using the `_text` method or the `.text` accessor.

```ruby
@user.status_text # or @user.status.text
```

--------------------------------

### Accessing Text Values for Multiple Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use the `.texts` method on a multiple enumerized attribute to get an array of the human-readable text values for the selected items.

```ruby
@user.interests.texts # shortcut for @user.interests.map(&:text)
```

--------------------------------

### Sequel Integration with Enumerize

Source: https://context7.com/brainspec/enumerize/llms.txt

Illustrates how to use Enumerize with the Sequel ORM by enabling the enumerize plugin on models or extending directly.

```ruby
# Using the plugin approach
class User < Sequel::Model
  plugin :enumerize

  enumerize :role, in: [:user, :admin], default: :user
  enumerize :status, in: { pending: 0, active: 1 }, scope: true
end

# Or extend directly
class User < Sequel::Model
  extend Enumerize

  enumerize :role, in: [:user, :admin], default: :user
end

user = User.new
user.role        # => "user"
user.role = :admin
user.role        # => "admin"
user.role_text   # => "Administrator"

# Scopes
User.with_status(:active)
```

--------------------------------

### Enable Prefixed Predicates

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use `predicates: { prefix: true }` to generate prefixed predicate methods (e.g., `user.is_student?`). This can help avoid naming conflicts with other methods.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired], predicates: { prefix: true }
end

describe User do
  it { should enumerize(:status).in(:student, :employed, :retired).with_predicates(prefix: true) }
end
```

--------------------------------

### Mongoid Integration with Enumerize

Source: https://context7.com/brainspec/enumerize/llms.txt

Shows how Enumerize integrates with Mongoid documents, providing similar functionality to ActiveRecord including scopes and default values.

```ruby
class User
  include Mongoid::Document
  extend Enumerize

  field :role, type: String
  field :status, type: Integer
  field :interests, type: Array

  enumerize :role, in: [:user, :admin, :moderator], default: :user, scope: true
  enumerize :status, in: { pending: 0, active: 1, suspended: 2 }, predicates: true
  enumerize :interests, in: [:music, :sports, :reading], multiple: true
end

user = User.new
user.role        # => "user"
user.active?     # => false

user.status = :active
user.active?     # => true

# Scopes work the same way
User.with_role(:admin)
User.with_role(:admin, :moderator)
```

--------------------------------

### ActiveModel Naming for Plain Ruby Objects

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Extend a plain Ruby object with ActiveModel::Naming to enable I18n features when using Enumerize.

```ruby
class User
  extend Enumerize
  extend ActiveModel::Naming
end
```

--------------------------------

### Minitest Integration with Shoulda

Source: https://context7.com/brainspec/enumerize/llms.txt

Demonstrates how to use Enumerize's RSpec matchers within Minitest by including the integration module in your test helper.

```ruby
# test/test_helper.rb
require 'enumerize/integrations/rspec'

class ActiveSupport::TestCase
  ActiveRecord::Migration.check_pending!

  extend Enumerize::Integrations::RSpec
end

# test/models/user_test.rb
require 'test_helper'

class UserTest < ActiveSupport::TestCase
  should enumerize(:status).in(:pending, :active, :suspended)
  should enumerize(:role).in(:user, :admin).with_default(:user)
  should enumerize(:interests).in(:music, :sports).with_multiple(true)

  test "user has default role"
    user = User.new
    assert_equal "user", user.role
  end

  test "status predicates work correctly"
    user = User.new(status: :active)
    assert user.active?
    refute user.pending?
  end
end
```

--------------------------------

### ActiveRecord Migration for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Create a database table with string columns to store enumerated attributes for an ActiveRecord model.

```ruby
class CreateUsers < ActiveRecord::Migration
  def change
    create_table :users do |t|
      t.string :status
      t.string :role

      t.timestamps
    end
  end
end
```

--------------------------------

### Formtastic Integration

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Enumerize integrates with Formtastic, automatically handling the input type and collection for select and radio button inputs.

```erb
<%= semantic_form_for @user do |f| %>
  <%= f.input :status %>
<% end %>
```

```erb
<%= semantic_form_for @user do |f| %>
  <%= f.input :status, as: :radio %>
<% end %>
```

--------------------------------

### Generate Predicate Methods for Enumerated Values

Source: https://context7.com/brainspec/enumerize/llms.txt

Generate boolean predicate methods for each enumerated value using `:predicates: true`. A prefix can be added to avoid name collisions, and specific values can be included or excluded.

```ruby
class User
  extend Enumerize

  enumerize :status, in: %w[student employed retired], predicates: true
  enumerize :role, in: %w[user admin moderator], predicates: { prefix: true }
  enumerize :level, in: %w[beginner intermediate advanced],
            predicates: { only: [:beginner, :advanced] }
end

user = User.new
user.status = :student
user.student?     # => true
user.employed?    # => false
user.retired?     # => false

# With prefix
user.role = :admin
user.role_admin?      # => true
user.role_user?       # => false
user.role_moderator?  # => false

# Predicates on the value itself
user.status.student?  # => true
user.status.retired?  # => false
```

--------------------------------

### Set Default Values for Enumerated Attributes

Source: https://context7.com/brainspec/enumerize/llms.txt

Set default values using the `:default` option, which supports static values or lambda expressions for dynamic defaults based on instance attributes.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  enumerize :role, in: [:user, :admin], default: :user
  enumerize :status, in: [:student, :employed, :retired],
            default: lambda { |user| user.age >= 65 ? :retired : :employed }
end

user = User.new
user.role    # => "user"

senior = User.new(age: 70)
senior.status # => "retired"

young = User.new(age: 25)
young.status  # => "employed"
```

--------------------------------

### Share Enumerations Across Models with Modules

Source: https://context7.com/brainspec/enumerize/llms.txt

Define enumerations within a module and include it in multiple classes to share attribute definitions. This promotes DRY principles and consistent enumeration usage across your application.

```ruby
module RoleEnumeration
  extend Enumerize

  enumerize :role, in: %w[user admin moderator], default: :user, predicates: true
end
```

```ruby
module StatusEnumeration
  extend Enumerize

  enumerize :status, in: { pending: 0, active: 1, suspended: 2 }, scope: true
end
```

```ruby
class User < ActiveRecord::Base
  include RoleEnumeration
  include StatusEnumeration
end
```

```ruby
class ApiClient < ActiveRecord::Base
  include RoleEnumeration
  include StatusEnumeration
end
```

```ruby
user = User.new
user.role           # => "user"
user.admin?         # => false
```

```ruby
client = ApiClient.new
client.role = :admin
client.admin?       # => true
```

```ruby
User.with_status(:active)
ApiClient.with_status(:pending)
```

--------------------------------

### I18n Translations for Enumerated Attributes

Source: https://context7.com/brainspec/enumerize/llms.txt

Enumerize integrates with I18n for human-readable text. Translations can be defined in locale files and accessed via `_text` or `.text`. Custom `i18n_scope` can be specified.

```yaml
# config/locales/en.yml
en:
  enumerize:
    user:
      status:
        student: "Currently Studying"
        employed: "Gainfully Employed"
        retired: "Enjoying Retirement"
defaults:
  role:
    user: "Regular User"
    admin: "Administrator"
```

```ruby
# Or use custom i18n_scope
class User
  extend Enumerize
  extend ActiveModel::Naming

  enumerize :status, in: %w[student employed retired]
  enumerize :priority, in: %w[low medium high], i18n_scope: "priorities"
  enumerize :color, in: %w[red green], i18n_scope: proc { |value| "colors" }
end

user = User.new(status: :student)
user.status_text       # => "Currently Studying"
user.status.text       # => "Currently Studying"

# Get all translated options for forms
User.status.values.collect(&:text)  # => ["Currently Studying", "Gainfully Employed", "Enjoying Retirement"]
User.status.options                 # => [["Currently Studying", "student"], ["Gainfully Employed", "employed"], ...]
User.status.options(only: [:student, :employed])   # Filter options
User.status.options(except: [:retired])            # Exclude options
```

--------------------------------

### Define Enumerized Attribute with Predicate Prefixes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use `predicates: { prefix: true }` to generate predicate methods with a prefix, such as `status_student?`. This helps avoid naming conflicts.

```ruby
class User
  extend Enumerize

  enumerize :status, in: %w(student employed retired), predicates: { prefix: true }
end

user = User.new
user.status = 'student'
user.status_student? # => true
```

--------------------------------

### I18n Translations for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Provide translations for enumerated attribute values in English using the 'enumerize' scope in I18n configuration.

```yaml
en:
  enumerize:
    user:
      status:
        student: "Student"
        employed: "Employed"
        retired: "Retiree"
```

--------------------------------

### Form Select Options for Enumerized Attribute

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Generate options for a form select element using the `options` method provided for enumerized attributes.

```erb
<%= form_for @user do |f| %>
  <%= f.select :status, User.status.options %>
<% end %>
```

--------------------------------

### Share Enumerations Across Classes with a Module

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Define enumerations in a module and include it in multiple classes to share common attribute definitions.

```ruby
module RoleEnumerations
  extend Enumerize

  enumerize :roles, in: %w[user admin]
end

class Buyer
  include RoleEnumerations
end

class Seller
  include RoleEnumerations
end
```

--------------------------------

### Define Enumeration with Hash for :in Option

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use the `:in` option with a hash to define enumerized attribute values with custom keys and associated values. This is useful for mapping symbolic names to integers or other types.

```ruby
class User
  extend Enumerize

  enumerize :role, in: { user: 0, admin: 1 }
end

describe User do
  it { should enumerize(:role).in(user: 0, admin: 1) }
end
```

--------------------------------

### Configure Internationalization Scope

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use the `:i18n_scope` option to customize the internationalization scope for enumerized attribute values. This allows for more organized translation keys.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired], i18n_scope: 'status'
end

describe User do
  it { should enumerize(:status).in(:student, :employed, :retired).with_i18n_scope('status') }
end
```

--------------------------------

### Use Custom Integer Storage for Enumerated Attributes

Source: https://context7.com/brainspec/enumerize/llms.txt

Store enumerated attributes using custom values like integers by mapping symbols to values in the `:in` option. The `.value` method retrieves the stored value, and queries can use these stored values.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  enumerize :role, in: { user: 1, admin: 2, moderator: 3 }
  enumerize :status, in: { pending: 0, active: 1, suspended: 2 }
end

user = User.new
user.role = :admin
user.role        # => "admin"
user.role_value  # => 2

# Query the stored value
User.role.find_value(:user).value    # => 1
User.role.find_value(:admin).value   # => 2

# Works transparently in queries
User.where(role: 2)  # Finds admins
```

--------------------------------

### Enable Predicates for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Set `:predicates` to `true` to automatically generate predicate methods (e.g., `user.student?`) for an enumerized attribute. This simplifies checking the current state of the attribute.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired], predicates: true
end

describe User do
  it { should enumerize(:status).in(:student, :employed, :retired).with_predicates(true) }
end
```

--------------------------------

### Array-like Attributes with Multiple Values

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use `multiple: true` to allow an enumerized attribute to hold an array of values. This is useful for attributes like 'interests'.

```ruby
class User
  extend Enumerize

  enumerize :interests, in: [:music, :sports], multiple: true
end

user = User.new
user.interests << :music
user.interests << :sports
```

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  serialize :interests, Array
  enumerize :interests, in: [:music, :sports], multiple: true
end
```

--------------------------------

### Handle Multiple Values for Attributes with Enumerize

Source: https://context7.com/brainspec/enumerize/llms.txt

Use the `:multiple: true` option to allow an attribute to hold multiple enumerated values, stored as an array and wrapped in an `Enumerize::Set`. This is useful for attributes like tags or interests.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  serialize :interests, Array
  enumerize :interests, in: [:music, :sports, :reading, :gaming, :travel], multiple: true
end
```

```ruby
user = User.new
user.interests << :music
user.interests << :sports
user.interests            # => #<Enumerize::Set {music, sports}>
user.interests.to_a       # => ["music", "sports"]
```

```ruby
user.interests.include?(:music)  # => true
user.interests.include?(:gaming) # => false
```

```ruby
user.interests.music?     # => true
user.interests.gaming?    # => false
```

```ruby
user.interests.texts      # => ["Music", "Sports"]
```

```ruby
user.interests.delete(:music)
user.interests            # => #<Enumerize::Set {sports}>
```

```ruby
user.interests = [:reading, :travel]
user.interests            # => #<Enumerize::Set {reading, travel}>
```

--------------------------------

### Define Basic Enumerated Attributes

Source: https://context7.com/brainspec/enumerize/llms.txt

Define enumerated attributes on any Ruby class with a fixed set of allowed values using the `:in` option. Invalid values will result in nil.

```ruby
class User
  extend Enumerize

  enumerize :role, in: [:user, :admin]
  enumerize :status, in: [:active, :inactive, :pending]
end

user = User.new
user.role = :admin
user.role          # => "admin"
user.role.admin?   # => true
user.role.user?    # => false

# Invalid values are not allowed
user.role = :superuser
user.role          # => nil
```

--------------------------------

### Custom I18n Scope for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Specify custom I18n scopes for enumerated attributes, including single scopes, arrays of scopes, and proc-based scopes.

```ruby
class Person
  extend Enumerize
  extend ActiveModel::Naming

  enumerize :status, in: %w[student employed retired], i18n_scope: "status"
  enumerize :roles, in: %w[user admin], i18n_scope: ["user.roles", "roles"]
  enumerize :color, in: %w[green blue], i18n_scope: proc { |value| "color" }
end

# localization file
en:
  status:
    student: "Student"
    employed: "Employed"
    retired: "Retiree"
  user:
    roles:
      user: "User"
  roles:
    admin: "Admin"
```

--------------------------------

### SimpleForm Integration

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Enumerize integrates seamlessly with SimpleForm. The input type and collection are automatically handled for select and radio button inputs.

```erb
<%= simple_form_for @user do |f| %>
  <%= f.input :status %>
<% end %>
```

```erb
<%= simple_form_for @user do |f| %>
  <%= f.input :status, as: :radio_buttons %>
<% end %>
```

--------------------------------

### Customizing Enumerize Value with a Hash

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Store enumerized attribute values using custom types like integers by passing a hash to the `:in` option. Use `_value` to access the stored value.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  enumerize :role, in: { user: 1, admin: 2 }
end

user = User.new
user.role = :user
user.role #=> 'user'
user.role_value #=> 1

User.role.find_value(:user).value #=> 1
User.role.find_value(:admin).value #=> 2
```

--------------------------------

### Enable Multiple Selections

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Set `:multiple` to `true` to allow an enumerized attribute to hold multiple values. This is useful for attributes where a record can have several associated states or categories.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired], multiple: true
end

describe User do
  it { should enumerize(:status).in(:student, :employed, :retired).with_multiple(true) }
end
```

--------------------------------

### Define and Access Enumerized Attributes in Ruby

Source: https://context7.com/brainspec/enumerize/llms.txt

Define enumerated attributes using the `enumerize` method and access their metadata, values, and default values programmatically. This includes iterating through all enumerized attributes and accessing specific ones.

```ruby
class User
  extend Enumerize

  enumerize :role, in: { user: 1, admin: 2 }, default: :user
  enumerize :status, in: [:pending, :active, :suspended]
end

# Access all enumerized attributes
User.enumerized_attributes.each do |attr|
  puts "#{attr.name}: #{attr.values.join(', ')}"
end
# Output:
# role: user, admin
# status: pending, active, suspended

# Access specific attribute
User.role                           # => Enumerize::Attribute
User.role.values                    # => [<Value: user>, <Value: admin>]
User.role.default_value             # => "user"
User.enumerized_attributes[:role]   # => Enumerize::Attribute
```

--------------------------------

### ActiveRecord Scopes for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Enable ActiveRecord scopes for enumerized attributes using `scope: true`. This generates `with_attribute` and `without_attribute` scopes.

```ruby
class User < ActiveRecord::Base
  extend Enumerize
  enumerize :role, in: [:user, :admin], scope: true
  enumerize :status, in: { student: 1, employed: 2, retired: 3 }, scope: :having_status
end

User.with_role(:admin)
# SELECT "users".* FROM "users" WHERE "users"."role" IN ('admin')

User.without_role(:admin)
# SELECT "users".* FROM "users" WHERE "users"."role" NOT IN ('admin')

User.having_status(:employed).with_role(:user, :admin)
# SELECT "users".* FROM "users" WHERE "users"."status" IN (2) AND "users"."role" IN ('user', 'admin')
```

--------------------------------

### Define Custom Scope Name

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use the `:scope` option with a string or symbol to define a custom name for the generated ActiveRecord scopes. This allows for more descriptive scope names.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed], scope: :employable
end

describe User do
  it { should enumerize(:status).in(:student, :employed, :retired).with_scope(scope: :employable) }
end
```

--------------------------------

### Default I18n Translations for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Define default I18n translations for an enumerated attribute 'status' that can be used across multiple models.

```yaml
en:
  enumerize:
    defaults:
      status:
        student: "Student"
        employed: "Employed"
        retired: "Retiree"
```

--------------------------------

### Skip Validations with Enumerize

Source: https://context7.com/brainspec/enumerize/llms.txt

Use the `:skip_validations` option to bypass automatic inclusion validation. It accepts a boolean for always skipping or a lambda for conditional skipping based on the record's state.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  # Always skip validation
  enumerize :legacy_status, in: [:active, :inactive], skip_validations: true

  # Conditionally skip validation
  enumerize :role, in: [:user, :admin],
            skip_validations: lambda { |user| user.imported? }

  enumerize :status, in: [:pending, :active],
            skip_validations: lambda { |user| user.new_record? }
end
```

```ruby
user = User.new
user.legacy_status = :unknown  # No validation error
user.valid?                    # => true
```

```ruby
imported_user = User.new(imported: true)
imported_user.role = :superadmin  # No validation error for imported records
imported_user.valid?              # => true
```

--------------------------------

### Define Shallow Scopes with Enumerize

Source: https://context7.com/brainspec/enumerize/llms.txt

Use `scope: :shallow` to create direct scope methods on the class for each enumerated value, providing a more Rails-like API. This is suitable when you want direct access to scopes for each enum value.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  enumerize :status, in: [:pending, :active, :suspended], scope: :shallow
  enumerize :role, in: { user: 1, admin: 2 }, scope: :shallow
end
```

```ruby
User.pending
# SELECT "users".* FROM "users" WHERE "users"."status" = 'pending'
```

```ruby
User.active
# SELECT "users".* FROM "users" WHERE "users"."status" = 'active'
```

```ruby
User.admin
# SELECT "users".* FROM "users" WHERE "users"."role" = 2
```

```ruby
User.not_pending
# SELECT "users".* FROM "users" WHERE "users"."status" != 'pending'
```

```ruby
User.not_admin
# SELECT "users".* FROM "users" WHERE "users"."role" != 2
```

```ruby
User.active.where(created_at: 1.week.ago..)
```

--------------------------------

### ActiveRecord Model with Default Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Define enumerated attributes in an ActiveRecord model, including a default value for 'status' based on a lambda and a simple default for 'role'.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired], default: lambda { |user| StatusIdentifier.status_for_age(user.age).to_sym }

  enumerize :role, in: [:user, :admin], default: :user
end
```

--------------------------------

### Enable Scopes for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Set `:scope` to `true` to automatically generate ActiveRecord scopes for each enumerized value (e.g., `User.student`). This simplifies querying records based on enumeration values.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired], scope: true
end

describe User do
  it { should enumerize(:status).in(:student, :employed, :retired).with_scope(true) }
end
```

--------------------------------

### Boolean Predicate Methods for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Check the current value of an enumerized attribute using generated boolean predicate methods (e.g., `attribute_name?`).

```ruby
user.status = :student
user.status.student? #=> true
user.status.retired? #=> false
```

--------------------------------

### MongoMapper Model with Enumerized Attribute

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Define an enumerated attribute 'role' in a MongoMapper document, including a default value.

```ruby
class User
  include MongoMapper::Document
  extend Enumerize

  key :role
  enumerize :role, in: [:user, :admin], default: :user
end
```

--------------------------------

### Define Enumerized Attribute with Predicate Methods

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use `predicates: true` to automatically generate boolean methods for each enum value. These methods return true if the attribute matches the value, false otherwise.

```ruby
class User
  extend Enumerize

  enumerize :status, in: %w(student employed retired), predicates: true
end

user = User.new

user.student?  # => false
user.employed? # => false

user.status = :student

user.student?  # => true
user.employed? # => false
```

--------------------------------

### Mongoid Model with Enumerized Attribute

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Define an enumerated attribute 'role' in a Mongoid document, including a default value.

```ruby
class User
  include Mongoid::Document
  extend Enumerize

  field :role
  enumerize :role, in: [:user, :admin], default: :user
end
```

--------------------------------

### Set Default Value for Enumerized Attribute

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use the `:default` option to specify a default value for an enumerized attribute. This ensures the attribute has a predefined value if none is explicitly set.

```ruby
class User
  extend Enumerize

  enumerize :role, in: [:user, :admin], default: :user
end

describe User do
  it { should enumerize(:user).in(:user, :admin).with_default(:user) }
end
```

--------------------------------

### Define ActiveRecord Scopes with Enumerize

Source: https://context7.com/brainspec/enumerize/llms.txt

Use the `:scope` option with `true` for default scope naming (e.g., `with_attribute`, `without_attribute`) or provide a custom scope name. This is useful for filtering records based on enumerated attribute values.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  enumerize :role, in: [:user, :admin, :moderator], scope: true
  enumerize :status, in: { pending: 0, active: 1, suspended: 2 }, scope: :having_status
end
```

```ruby
User.with_role(:admin)
# SELECT "users".* FROM "users" WHERE "users"."role" IN ('admin')
```

```ruby
User.with_role(:admin, :moderator)
# SELECT "users".* FROM "users" WHERE "users"."role" IN ('admin', 'moderator')
```

```ruby
User.without_role(:user)
# SELECT "users".* FROM "users" WHERE "users"."role" NOT IN ('user')
```

```ruby
User.having_status(:active)
# SELECT "users".* FROM "users" WHERE "users"."status" IN (1)
```

```ruby
User.having_status(:active).with_role(:admin)
# SELECT "users".* FROM "users" WHERE "users"."status" IN (1) AND "users"."role" IN ('admin')
```

--------------------------------

### Shallow ActiveRecord Scopes for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use `scope: :shallow` to add named scopes directly to the class for each enumerized value. This allows direct calls like `User.student`.

```ruby
class User < ActiveRecord::Base
  extend Enumerize
  enumerize :status, in: [:student, :employed, :retired], scope: :shallow
  enumerize :role, in: { user: 1, admin: 2 }, scope: :shallow
end

User.student
# SELECT "users".* FROM "users" WHERE "users"."status" = 'student'

User.admin
# SELECT "users".* FROM "users" WHERE "users"."role" = 2
```

--------------------------------

### Overriding Reader Method with Super

Source: https://github.com/brainspec/enumerize/blob/master/README.md

The reader method for an enumerized attribute can be overridden. Use `super` to access the original enumerized value within the overridden method.

```ruby
def status
  if current_user.admin?
    "Super #{super}"
  else
    super
  end
end
```

--------------------------------

### Skipping Validations for Enumerized Attributes in ActiveRecord

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Configure enumerated attributes in an ActiveRecord model to skip validations conditionally using a lambda or unconditionally.

```ruby
class User < ActiveRecord::Base
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired], skip_validations: lambda { |user| user.new_record? }

  enumerize :role, in: [:user, :admin], skip_validations: true
end
```

--------------------------------

### RSpec Matcher for Enumerized Attributes

Source: https://github.com/brainspec/enumerize/blob/master/README.md

Use the built-in RSpec matcher `enumerize(:attribute_name)` to test if an attribute has been properly enumerized.

```ruby
class User
  extend Enumerize

  enumerize :status, in: [:student, :employed, :retired]
end

describe User do
  it { should enumerize(:status) }

  # or with RSpec 3 expect syntax
  it { is_expected.to enumerize(:status) }
end
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.