### Install Barley Gem

Source: https://github.com/moskitohero/barley/blob/main/README.md

Install the Barley gem by adding it to your Gemfile and running `bundle install`, or by using the `gem install` command. This makes the Barley library available in your project.

```ruby
gem "barley"
```

```bash
$ bundle

# Or
$ gem install barley
```

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

### Use Cerealizer for Serialization in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Introduces the experimental 'Cerealizer' feature in Barley, which allows replacing `Serializer` with `Cerealizer` for a potentially more fun approach to serialization. It includes model and cerealizer class examples, along with generator commands.

```ruby
# /app/models/user.rb
class User < ApplicationRecord
  include Barley::Cerealizable

  cerealizer UserCerealizer
end

# app/cerealizers/user_cerealizer.rb
class UserCerealizer < Barley::Cerealizer
  attributes :id, :name, :email, :created_at, :updated_at

  many :posts
  one :group
end
```

```shell
rails generate barley:cerealizer User
# etc.
```

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

### Rails Generators for Barley Serializers (Bash)

Source: https://context7.com/moskitohero/barley/llms.txt

Provides examples of using Rails generators to create Barley serializer classes and configure models. Commands include generating a basic serializer, a serializer with a custom name, and generating both a serializer and adding `Barley::Serializable` to a model.

```bash
# Generate just the serializer class
rails generate barley:serializer User
# Creates: app/serializers/user_serializer.rb

# Generate with custom name
rails generate barley:serializer User --name=CustomUserSerializer
# Creates: app/serializers/custom_user_serializer.rb

# Generate both serializer and add Barley::Serializable to model
rails generate barley:serializable User
# Creates: app/serializers/user_serializer.rb
# Modifies: app/models/user.rb (adds include Barley::Serializable)

# With custom serializer name
rails generate barley:serializable User --name=ApiUserSerializer
# Creates: app/serializers/api_user_serializer.rb
# Modifies: app/models/user.rb (adds include Barley::Serializable and serializer ApiUserSerializer)
```

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

### Configure Barley Cache Store (Ruby)

Source: https://context7.com/moskitohero/barley/llms.txt

Configures the cache store for the Barley gem. This example shows how to use Redis for distributed caching, with commented-out options for Memcached and FileStore. Ensure the REDIS_URL environment variable is set for Redis to work.

```ruby
Barley.configure do |config|
  # Use Redis for distributed caching
  config.cache_store = ActiveSupport::Cache::RedisCacheStore.new(
    url: ENV['REDIS_URL'],
    namespace: 'barley_cache'
  )

  # Or use Memcached
  # config.cache_store = ActiveSupport::Cache::MemcachedStore.new('localhost:11211')

  # Or file-based cache
  # config.cache_store = ActiveSupport::Cache::FileStore.new('/tmp/barley_cache')
end
```

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

### Configure Barley Cache Store

Source: https://context7.com/moskitohero/barley/llms.txt

Shows how to configure the cache backend for Barley serializers in an initializer file. It defaults to MemoryStore but can be configured to use any ActiveSupport-compatible cache store.

```ruby
# config/initializers/barley.rb
Barley.configure do |config|
  config.cache_store = Rails.cache
end

# Or with specific options:
# config.cache_store = ActiveSupport::Cache::RedisCacheStore.new(url: ENV['REDIS_URL'])

```

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

### Configure Custom Cache Store in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Shows how to configure a custom cache store for the Barley gem by modifying the `config.cache_store` option within an initializer file. This allows using different caching backends like Redis.

```ruby
# /config/initializers/barley.rb
Barley.configure do |config| 
  config.cache_store = ActiveSupport::Cache::RedisCacheStore.new
end
```

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

### Serialize Model with Custom Options in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Demonstrates how to serialize a model using a custom serializer and pass caching options to the `as_json` method in Ruby. It also warns against using standard Rails `include`, `only`, or `except` options with Barley.

```ruby
user = User.find(1)
user.as_json(serializer: CustomUserSerializer, cache: { expires_in: 1.hour })
```

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

### Define Associations with Blocks in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Shows how to define associations using block syntax with the `one` and `many` macros in Ruby with the Barley gem. This allows for more complex attribute definitions and nested associations.

```ruby
  one :group do
    attributes :id, :name
  end
```

```ruby
  many :posts do
    attributes :id, :title, :body

    one :author do
      attributes :name, :email
    end
  end
```

```ruby
  many :posts, key_name: :featured do
    attributes :id, :title, :body
  end
```

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

### Include Barley::Serializable in ActiveModel

Source: https://github.com/moskitohero/barley/blob/main/README.md

Add the `Barley::Serializable` module to your ActiveModel object to enable Barley serialization. This is the first step in making your models serializable with Barley.

```ruby
# /app/models/user.rb
class User < ApplicationRecord
  include Barley::Serializable
end
```

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

### Implement Type Checking with Dry-Types in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Demonstrates how to use the `dry-types` gem with Barley serializers for robust type checking and coercion. This ensures data integrity by defining expected types and constraints for attributes.

```ruby
module Types
  include Dry.Types()
end

class UserSerializer < Barley::Serializer
  attributes id: Types::Strict::Integer, name: Types::Strict::String, email: Types::Strict::String.constrained(format: URI::MailTo::EMAIL_REGEXP)

  attribute :role, type: Types::Coercible::String do
    object.role.integer_or_string_coercible_value
  end
end
```

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

### Define Attributes with `attributes` Macro

Source: https://github.com/moskitohero/barley/blob/main/README.md

Use the `attributes` macro to declare multiple attributes at once, specifying their names and optionally their types using a type mapping. This is a concise way to define serializable fields.

```ruby
attributes :id, :name, :email, :created_at, :updated_at
```

```ruby
attributes :id, :name, :email
attribute :created_at
attribute :updated_at
```

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

### Define Associations with Key Name in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Demonstrates how to specify a custom key name for associations when defining them using the `many` macro in Ruby with the Barley gem. This is useful for customizing the JSON output.

```ruby
  many :posts, key_name: :articles
```

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

### Generate Barley Serializer Class in Rails

Source: https://github.com/moskitohero/barley/blob/main/README.md

Provides the Rails generator commands to create a new serializer class for the Barley gem. It shows how to specify the model name and an optional custom serializer name.

```shell
rails generate barley:serializer User
# or
rails generate barley:serializer User --name=CustomUserSerializer
```

```shell
rails generate barley:serializable User
# or
rails generate barley:serializable User --name=CustomUserSerializer
```

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

### Define Attributes and Associations in a Serializer

Source: https://github.com/moskitohero/barley/blob/main/README.md

Define attributes and associations within a serializer class that inherits from `Barley::Serializer`. This DSL allows specifying data types, custom keys, and relationships.

```ruby
# /app/serializers/user_serializer.rb
class UserSerializer < Barley::Serializer

  attributes id: Types::Strict::Integer, :name

  attribute :email
  attribute :value, type: Types::Coercible::Integer

  many :posts

  many :posts, key_name: :featured, scope: :featured

  many :posts, key_name: :popular, scope: -> { where("views > 10_000").limit(3) }

  many :posts, key_name: :in_current_language, scope: -> (context) { where(language: context.language) }

  one :group, serializer: CustomGroupSerializer

  many :related_users, key: :friends, cache: true

  one :profile, cache: { expires_in: 1.day } do
    attributes :avatar, :social_url

    attribute :badges do
      object.badges.map(&:display_name)
    end
  end

end
```

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

### Pass Context to Serializer in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Illustrates how to pass contextual information to a Barley serializer instance using the `with_context` method in Ruby. This context is then accessible within the serializer's attributes and nested serializers.

```ruby
serializer = PostSerializer.new(Post.last).with_context(current_user: current_user)
```

```ruby
class PostSerializer < Barley::Serializer
  attributes :id, :title, :body

  attribute :is_owner do
    object.user == context.current_user
  end

  many :comments do
    many :likes do
      attribute :is_owner do
        object.user == context.current_user # context is here too!
      end
    end
  end
end
```

```ruby
  many :posts, scope: -> (context) { where(language: context.language) }
```

```ruby
my_context = Struct.new(:current_user).new(current_user)

serializer = PostSerializer.new(Post.last, context: my_context)
```

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

### Define Basic Serializer with Attributes

Source: https://context7.com/moskitohero/barley/llms.txt

Create a serializer class that inherits from `Barley::Serializer`. Use the `attributes` macro to define multiple model attributes for JSON output simultaneously, or use the `attribute` macro for single attribute definitions.

```ruby
class UserSerializer < Barley::Serializer
  # Define multiple attributes at once
  attributes :id, :email, :created_at, :updated_at

  # Define a single attribute
  attribute :name
end

# Usage
user = User.find(1)
serializer = UserSerializer.new(user)
serializer.serializable_hash
# => { id: 1, email: "user@example.com", name: "John Doe",
#      created_at: "2024-01-01T00:00:00Z", updated_at: "2024-01-15T00:00:00Z" }
```

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

### Enable Caching for Serializers in Ruby

Source: https://github.com/moskitohero/barley/blob/main/README.md

Explains how to enable caching for Barley serializers by passing `cache: true` or a hash of caching options to the `serializer` macro in a Rails model. This improves performance by storing serialized output.

```ruby
# /app/models/user.rb
# ...
serializer UserSerializer, cache: true
```

```ruby
# /app/models/user.rb
# ...
serializer UserSerializer, cache: { expires_in: 1.hour }
```

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

### Implement Caching Strategies in Barley

Source: https://context7.com/moskitohero/barley/llms.txt

Details how to enable caching at model, serializer, or association level in Barley. Cache keys automatically include model ID and updated_at timestamp for efficient data retrieval.

```ruby
# Model-level caching
class User < ApplicationRecord
  include Barley::Serializable
  serializer UserSerializer, cache: { expires_in: 1.hour }
end

# Serializer-level caching
user = User.find(1)
UserSerializer.new(user, cache: true).serializable_hash
UserSerializer.new(user, cache: { expires_in: 30.minutes }).serializable_hash

# Association-level caching
class UserSerializer < Barley::Serializer
  attributes :id, :email

  # Cache this association separately
  many :posts, cache: { expires_in: 15.minutes } do
    attributes :id, :title
  end

  one :profile, cache: true do
    attributes :name, :age
  end
end

# Clear cache manually
serializer = UserSerializer.new(user, cache: true)
serializer.clear_cache
# => true
```

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

### Custom Serializer and Caching for Many Associations

Source: https://github.com/moskitohero/barley/blob/main/README.md

Configure custom serializers and caching options for one-to-many associations. This allows for specialized serialization and performance optimizations for collections.

```ruby
many :posts, serializer: CustomPostSerializer, cache: { expires_in: 1.hour }
```

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

### Define One-to-One Associations

Source: https://github.com/moskitohero/barley/blob/main/README.md

Use the `one` macro to define one-to-one associations. Barley will serialize the associated object according to its own serializer or the default.

```ruby
one :group
```

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

### Specify Serializer with `serializer` Macro

Source: https://github.com/moskitohero/barley/blob/main/README.md

Optionally, define the serializer class for a model using the `serializer` macro within the model itself. This explicitly links a model to its corresponding serializer.

```ruby
# /app/models/user.rb
class User < ApplicationRecord
  include Barley::Serializable

  serializer UserSerializer
end
```

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

### Custom Serializer and Caching for Associations

Source: https://github.com/moskitohero/barley/blob/main/README.md

Specify a custom serializer for an association using the `serializer` option and configure caching with the `cache` option, including an expiration time. This enhances performance and control over serialization.

```ruby
one :group, serializer: CustomGroupSerializer, cache: { expires_in: 1.hour }
```

```ruby
class UserSerializer < Barley::Serializer
  attributes :id, :name, :email, :created_at, :updated_at

  one :group, serializer: LocalGroupSerializer

    class LocalGroupSerializer < Barley::Serializer
        attributes :id, :name
    end
end
```

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

### Define Custom Attributes with a Block

Source: https://github.com/moskitohero/barley/blob/main/README.md

Create custom attributes by providing a block to the `attribute` macro. Inside the block, you can access the `object` being serialized to compute the attribute's value dynamically.

```ruby
attribute :full_name do
  "#{object.first_name} #{object.last_name}"
end
```

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

### Selective Attribute Serialization with `as_json` (Ruby)

Source: https://context7.com/moskitohero/barley/llms.txt

Demonstrates how to use `only` and `except` options with the `as_json` method on a serialized object to control which attributes are included or excluded from the output. This allows for dynamic filtering of serialized data.

```ruby
class UserSerializer < Barley::Serializer
  attributes :id, :email, :name, :created_at, :updated_at

  many :posts do
    attributes :id, :title, :body, :published_at
  end

  one :profile do
    attributes :name, :age, :bio
  end
end

user = User.find(1)

# Include only specific fields
user.as_json(only: [:id, :name])
# => { id: 1, name: "John Doe" }

# Include nested associations with selective fields
user.as_json(only: [:id, :email, posts: [:id, :title]])
# => { id: 1, email: "user@example.com",
#      posts: [{ id: 1, title: "First Post" }, { id: 2, title: "Second Post" }] }

# Exclude specific fields
user.as_json(except: [:created_at, :updated_at])
# => { id: 1, email: "user@example.com", name: "John Doe", posts: [...], profile: {...} }
```

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

### Set Custom Key Name for Attributes

Source: https://github.com/moskitohero/barley/blob/main/README.md

Customize the key name for an attribute in the serialized output using the `key_name` option. This allows for flexible naming conventions in your API responses.

```ruby
attribute :updated_at, key: :last_change
```

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

### Define One-to-One Associations with Barley Serializer

Source: https://context7.com/moskitohero/barley/llms.txt

Demonstrates how to use the `one` macro in Barley serializers to define one-to-one associations. It covers basic associations, custom serializers, key renaming, caching, and inline serializer definitions.

```ruby
class UserSerializer < Barley::Serializer
  attributes :id, :email

  # Basic association (uses Profile's default serializer)
  one :profile

  # With custom serializer
  one :profile, serializer: CustomProfileSerializer

  # With custom key name
  one :profile, key_name: :user_profile

  # With caching
  one :profile, cache: { expires_in: 30.minutes }

  # Inline serializer definition with block
  one :profile do
    attributes :name, :age

    attribute :bio do
      object.biography.truncate(100)
    end
  end
end

user = User.includes(:profile).find(1)
UserSerializer.new(user).serializable_hash
# => { id: 1, email: "user@example.com",
#      profile: { name: "John Doe", age: 30, bio: "Software developer..." } }
```

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

### Define One-to-Many Associations

Source: https://github.com/moskitohero/barley/blob/main/README.md

Use the `many` macro to define one-to-many associations. Barley will serialize the collection of associated objects.

```ruby
many :posts
```

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

### Set Custom Key Name for Associations

Source: https://github.com/moskitohero/barley/blob/main/README.md

Provide a custom key name for a one-to-one association in the serialized output using the `key_name` option. This allows renaming associations in the JSON response.

```ruby
one :group, key_name: :team
```

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

### Include Barley::Serializable in Rails Models

Source: https://context7.com/moskitohero/barley/llms.txt

Add serialization capabilities to ActiveRecord models by including the `Barley::Serializable` module. This module automatically discovers and associates a serializer class based on the model's naming convention. Optionally, you can explicitly define the serializer and caching strategy.

```ruby
class User < ApplicationRecord
  include Barley::Serializable

  # Optional: explicitly define the serializer and caching strategy
  serializer UserSerializer, cache: { expires_in: 1.hour }

  has_many :posts
  belongs_to :profile
end

# Serialize the model
user = User.find(1)
user.as_json
# => { id: 1, email: "user@example.com", created_at: "2024-01-01T00:00:00Z", ... }
```

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

### Nested Serializer Classes Definition (Ruby)

Source: https://context7.com/moskitohero/barley/llms.txt

Illustrates how to define serializers as nested classes within a parent serializer. This is useful for organizing serializers that are only used internally by a specific parent serializer, improving code structure.

```ruby
class UserSerializer < Barley::Serializer
  # Nested serializer for profile
  class ProfileSerializer < Barley::Serializer
    attributes :name, :age

    attribute :birthday do
      object.birthdate.strftime("%m-%d")
    end
  end

  # Nested serializer for groups
  class GroupSerializer < Barley::Serializer
    attributes :id, :name, :member_count
  end

  attributes :id, :email, :created_at, :updated_at

  one :profile, serializer: ProfileSerializer
  many :groups, serializer: GroupSerializer, cache: true
end

user = User.includes(:profile, :groups).find(1)
UserSerializer.new(user).serializable_hash
# => { id: 1, email: "user@example.com", created_at: "2024-01-01T00:00:00Z",
#      updated_at: "2024-01-15T00:00:00Z",
#      profile: { name: "John Doe", age: 30, birthday: "05-15" },
#      groups: [
#        { id: 1, name: "Developers", member_count: 42 },
#        { id: 2, name: "Admins", member_count: 5 }
#      ] }
```

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

### Pass Context to Barley Serializers

Source: https://context7.com/moskitohero/barley/llms.txt

Explains how to pass additional contextual data to Barley serializers using `with_context` or directly in the initializer. Context is accessible within attributes and nested associations.

```ruby
class PostSerializer < Barley::Serializer
  attributes :id, :title, :body

  # Use context in attribute
  attribute :is_owner do
    context.current_user && object.author_id == context.current_user.id
  end

  attribute :localized_title do
    object.translations[context.locale] || object.title
  end

  # Context available in nested associations
  many :comments do
    attributes :id, :content

    attribute :can_edit do
      context.current_user && object.user_id == context.current_user.id
    end
  end

  # Context used in scoped associations
  many :related_posts, scope: ->(ctx) { where(category: ctx.category).limit(3) } do
    attributes :id, :title
  end
end

current_user = User.find(1)
post = Post.includes(:comments, :related_posts).find(1)
serializer = PostSerializer.new(post).with_context(
  current_user: current_user,
  locale: :en,
  category: 'technology'
)
serializer.serializable_hash
# => { id: 1, title: "My Post", body: "Content...", is_owner: true,
#      localized_title: "My Post",
#      comments: [{ id: 1, content: "Great post!", can_edit: false }, ...],
#      related_posts: [{ id: 5, title: "Related Tech Post" }, ...] }

# Alternative: pass context object directly in initializer
my_context = Struct.new(:current_user, :locale).new(current_user, :en)
PostSerializer.new(post, context: my_context).serializable_hash
```

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

### Define One-to-Many Associations with Barley Serializer

Source: https://context7.com/moskitohero/barley/llms.txt

Illustrates the use of the `many` macro in Barley serializers for defining one-to-many associations. Supports scopes, custom serializers, caching, and nested serializers with context.

```ruby
class UserSerializer < Barley::Serializer
  attributes :id, :email

  # Basic collection
  many :posts

  # With custom serializer and caching
  many :posts, serializer: DetailedPostSerializer, cache: true

  # With named scope
  many :posts, key_name: :published_posts, scope: :published

  # With lambda scope
  many :posts, key_name: :recent_posts, scope: -> { order(created_at: :desc).limit(5) }

  # With context-aware scope
  many :posts, key_name: :user_language_posts, scope: ->(context) { where(language: context.locale) }

  # Inline serializer with nested associations
  many :posts do
    attributes :id, :title, :published_at

    one :author do
      attributes :name, :email
    end

    attribute :excerpt do
      object.body.truncate(200)
    end
  end
end

user = User.includes(posts: :author).find(1)
UserSerializer.new(user).serializable_hash
# => { id: 1, email: "user@example.com",
#      posts: [
#        { id: 1, title: "First Post", published_at: "2024-01-01T00:00:00Z",
#          author: { name: "John Doe", email: "john@example.com" },
#          excerpt: "This is the beginning of the post..." },
#        { id: 2, title: "Second Post", ... }
#      ] }
```

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

### Scope Associations with Symbols or Lambdas

Source: https://github.com/moskitohero/barley/blob/main/README.md

Filter or scope associated collections using the `scope` option. It can reference a named scope on the model or accept a lambda for custom query logic. This allows for conditional serialization of related data.

```ruby
many :posts, scope: :published # given you have a scope named `published` on your Post model
```

```ruby
many :posts, scope: -> { where(published: true).limit(4) }
```

```ruby
many :posts, scope: -> (context) { where(language: context.language) }
```

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

### Custom Attributes with Blocks in Serializers

Source: https://context7.com/moskitohero/barley/llms.txt

Define computed or transformed attributes within a serializer using blocks. The `object` variable within the block refers to the model instance being serialized. You can also specify a custom key name for the serialized attribute using `key_name`.

```ruby
class UserSerializer < Barley::Serializer
  attributes :id, :email

  # Custom computed attribute
  attribute :full_name do
    "#{object.first_name} #{object.last_name}"
  end

  # Transform existing attribute
  attribute :username do
    object.email.split('@').first.upcase
  end

  # Custom key name for attribute
  attribute :updated_at, key_name: :last_modified
end

user = User.create(id: 1, email: "john.doe@example.com",
                   first_name: "John", last_name: "Doe",
                   updated_at: Time.parse("2024-01-15"))
UserSerializer.new(user).serializable_hash
# => { id: 1, email: "john.doe@example.com", full_name: "John Doe",
#      username: "JOHN.DOE", last_modified: "2024-01-15T00:00:00Z" }
```

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

### Type Checking with Dry-Types in Serializers

Source: https://context7.com/moskitohero/barley/llms.txt

Utilize dry-types within your Barley serializers to enforce type constraints and coerce values during serialization. This ensures data integrity and provides clear validation rules. Strict types raise errors for mismatches, while coercible types attempt conversion.

```ruby
# app/lib/types.rb
module Types
  include Dry.Types()
end

class UserSerializer < Barley::Serializer
  # Strict type checking (raises error if type doesn't match)
  attributes id: Types::Strict::Integer,
             name: Types::Strict::String,
             email: Types::Strict::String.constrained(format: URI::MailTo::EMAIL_REGEXP)

  # Coercible types (converts value to target type)
  attribute :age, type: Types::Coercible::Integer

  # Type with custom block
  attribute :role, type: Types::Coercible::String do
    object.role_id.to_s
  end
end

user = User.new(id: 1, name: "John", email: "john@example.com", age: "25", role_id: 3)
UserSerializer.new(user).serializable_hash
# => { id: 1, name: "John", email: "john@example.com", age: 25, role: "3" }

# Invalid type raises error
invalid_user = User.new(id: "not_an_int", name: "John", email: "john@example.com")
UserSerializer.new(invalid_user).serializable_hash
# => Barley::InvalidAttributeError: Invalid value type found for attribute id::Integer: not_an_int::String
```

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