### Rooibos Quickstart: Hello World HTTP App

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

A basic 'Hello World' example demonstrating how to create a simple HTTP application using Rooibos. This serves as an introductory example for new users.

```ruby
# Example for a simple HTTP app in Rooibos
# (Actual code would be more extensive and is not provided in the text)
```

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

### Rooibos Tutorial: Hello World Example

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

A 'Hello World' example within the Rooibos tutorial, demonstrating the VIEW, UPDATE, and quit functionalities. This is an early step in learning Rooibos.

```markdown
## 02_hello_world.md

**Story -3: VIEW, UPDATE, quit**

Introduces the fundamental concepts of rendering views, handling updates, and exiting the application in Rooibos. This serves as a basic interactive example.
```

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

### Rooibos Tutorial: Project Setup

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

The initial step in the Rooibos tutorial, focusing on creating the project structure. This is part of a TDD-first approach to building an application.

```markdown
## 01_project_setup.md

**Story -4: Creating project structure**

This step covers the initial setup of a new Rooibos project, defining the foundational directory and file structure necessary for the subsequent tutorial steps.
```

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

### Rooibos::Runtime Example

Source: https://www.rooibos.run/docs/v0.6/Rooibos/Runtime

Demonstrates how to use Rooibos.run to start an application. It takes a model, a view function, and an update function as arguments. The view function renders the current state, and the update function handles incoming messages to modify the state and commands.

```ruby
Rooibos.run(
  model: { count: 0 }.freeze,
  view: ->(model, tui) { tui.paragraph(text: model[:count].to_s) },
  update: ->(message, model) { message.q? ? [model, Command.exit] : [model, nil] }
)

```

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

### Ruby Gem Installation for Rooibos

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Instructions for installing the Rooibos gem, primarily for users who are not already familiar with Ruby. This ensures a smooth setup process for new users.

```ruby
gem install rooibos
```

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

### Ruby File Browser Tutorial - Static File List

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This snippet demonstrates the initial setup for a Ruby-based File Browser, focusing on listing static files. It introduces the concept of testing early in the development process.

```ruby
require 'pathname'

class FileBrowser
  def initialize(path)
    @path = Pathname.new(path)
  end

  def files
    @path.children.map(&:basename).map(&:to_s)
  end
end

# Example Usage:
browser = FileBrowser.new('.')
puts browser.files
```

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

### Callout Syntax Examples

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_style_md

Demonstrates the Markdown syntax for various callout types (Note, Tip, Warning, Caution) used to highlight important information within documentation.

```markdown
> **Note**: Background context that's helpful but not critical.

> **Tip**: A shortcut, best practice, or efficiency suggestion.

> **Warning**: Something that could cause confusion or bugs if ignored.

> **Caution**: High-risk actions that could cause data loss or crashes.
```

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

### Rooibos Router DSL Example

Source: https://www.rooibos.run/docs/v0.6/Rooibos/Router

This example demonstrates how to use the Rooibos::Router module to define routes, keymaps, and the basic components (Model, Init, View, Update) for a Dashboard fragment. It shows how to include the module, declare routes to child panels, define keybindings with associated commands and routing targets, and how to use `from_router` to generate the Update function.

```ruby
class Dashboard
  include Rooibos::Router

  route :stats, to: StatsPanel
  route :network, to: NetworkPanel

  keymap do
    key "s", -> { SystemInfo.fetch_command }, route: :stats
    key "q", -> { Command.exit }
  end

  Model = Data.define(:stats, :network)
  Init = -> { Model.new(stats: StatsPanel::Init.(), network: NetworkPanel::Init.()) }
  View = ->(model, tui) { ... } # Placeholder for view implementation
  Update = from_router
end
```

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

### Install Rooibos Gem

Source: https://www.rooibos.run/docs/v0.6/README_md

Instructions for installing the rooibos gem using Bundler or directly via gem install. This is the first step to using the gem in a Ruby project.

```ruby
gem "rooibos"
bundle install
```

```ruby
gem install rooibos
```

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

### Tuple Return Initialization Example (Rust/Iced)

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/design/mvu_tea_implementations_research_md

Provides a concrete example of the tuple return initialization pattern using Rust with the Iced framework. It shows how initial state and commands are returned from the `new` function, demonstrating the use of a `flags` parameter.

```rust
fn new(flags: Flags) -> (MyApp, Command<Message>) {
  let initial_state = MyApp { count: flags.initial_count };
  let initial_cmd = Command::none();
  (initial_state, initial_cmd)
}
```

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

### Install Rooibos Gem

Source: https://www.rooibos.run/docs/v0.6/README_rdoc

Installs the Rooibos gem, enabling the creation and running of terminal applications. This is the first step for any new Rooibos project.

```bash
gem install rooibos

```

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

### Cmd.map for Component Composition in Ruby

Source: https://www.rooibos.run/docs/v0.6/examples/app_fractal_dashboard/README_md

Demonstrates how Cmd.map can wrap child commands to route their results through parents, facilitating component composition. This avoids a monolithic reducer by allowing each layer to handle its own messages.

```ruby
# Child produces [:system_info, {stdout:, ...}]
child_cmd = SystemInfoWidget.fetch_cmd

# Parent wraps to produce [:stats, :system_info, {...}]
parent_cmd = Cmd.map(child_cmd) { |m| [:stats, *m] }
```

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

### Create and Run a New Rooibos App

Source: https://www.rooibos.run/docs/v0.6/README_rdoc

Quickly scaffold a new Rooibos application and start it. This command-line process sets up a basic project structure, ready for customization.

```bash
rooibos new my_app
cd my_app
rooibos run

```

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

### Rooibos Runtime Integration Example

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/design/mvu_tea_implementations_research_md

Demonstrates the runtime integration pattern for Rooibos, based on Iced and Elm. The `Rooibos.run` function takes a fragment and arguments, internally calling the fragment's `Init` function.

```ruby
Rooibos.run(
        fragment: App,
        argv: ARGV,
        env: ENV
)
# Internally calls: model, cmd = App::Init.(argv: ARGV, env: ENV)
```

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

### Install Rooibos CLI

Source: https://www.rooibos.run/docs/v0.6/LICENSES/MIT-0

Installs the Rooibos command-line interface using RubyGems. This is the first step to start building terminal applications with Rooibos.

```bash
$ gem install rooibos
```

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

### Elm Architecture Concept Document Example

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_style_md

An example of a concept document explaining the Elm Architecture. It follows the Context-Problem-Solution pattern and includes learning objectives, context, problem statement, and solution overview.

```markdown
# The Elm Architecture

After reading this guide, you will know:
- What Model-View-Update means
- Why unidirectional data flow prevents bugs
- How the runtime coordinates your app

---

## Context

Applications have state. A counter has a count. A file browser has a current directory. A chat app has messages.

State changes over time. Users click. Servers respond. Timers fire.

## Problem

Coordinating state changes is hard. Callbacks create spaghetti. Shared mutable state causes race conditions. Event emitters become untraceable.

## Solution

The Elm Architecture solves this with **unidirectional data flow**:

1. **Model** — A single source of truth for state
2. **Update** — A pure function that computes the next state
3. **View** — A function that renders the model

...
```

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

### Rooibos Tutorial: Static File List and Testing Intro

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This step in the Rooibos tutorial covers the MODEL concept and introduces testing. It focuses on displaying a static list of files and setting up the testing environment.

```markdown
## 03_static_file_list.md

**Story -2: MODEL, INIT, testing intro ⭐**

Focuses on defining the application's model (data structure), initialization logic, and introduces the basics of writing tests for Rooibos applications. Demonstrates displaying a static list of files.
```

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

### Cross-Reference Link Examples

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_style_md

Illustrates how to create cross-references to other documentation pages using Markdown links, including links to related topics and sequential navigation.

```markdown
See [The Elm Architecture](../essentials/the_elm_architecture.md) for background.

For advanced patterns, see [Fractal Architecture](../scaling_up/fractal_architecture.md).

Related: [Commands](commands.md) | [Messages](messages.md) | [The Runtime](the_runtime.md)
```

```markdown
---

← Previous: [Handling Input](04_handling_input.md) | Next: [Organizing Your Code](06_organizing_your_code.md) →
```

```markdown
For widget details, see the [RatatuiRuby List docs](https://ratatui-ruby.dev/docs).
```

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

### Rooibos Tutorial: Handling Real Files and Mocking

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This tutorial step addresses the challenge of working with real files in tests and introduces mocking techniques. It covers scenarios where tests might break due to external dependencies.

```markdown
## 05_real_files.md

**Story 0: Tests break, learn mocking ⭐⭐⭐**

Deals with the complexities of testing code that interacts with the file system. Introduces mocking strategies to isolate components and ensure reliable test execution.
```

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

### Ruby Model Definition Example

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_style_md

A simple Ruby code snippet defining a data structure using `Data.define` for a model, likely representing application state.

```ruby
Model = Data.define(:count)
```

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

### Rooibos Tutorial: Terminal Capabilities and Fallbacks

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Discusses handling terminal capabilities, including support for NO_COLOR and implementing fallbacks for environments with limited terminal features. This ensures broader compatibility.

```markdown
## 23_terminal_capabilities.md

**Story 23: NO_COLOR, fallbacks ⭐**

Addresses terminal capabilities, including respecting the `NO_COLOR` environment variable and implementing fallback mechanisms for environments with limited terminal support.
```

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

### Define Model in Ruby

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_style_md

Example of defining a model in Ruby using Data.define for application state. This is a common pattern in the Rooibos framework for managing data within an application.

```ruby
Model = Data.define(:current_path, :entries)
```

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

### Rooibos Tutorial: Performance Profiling and Optimization

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This step in the Rooibos tutorial focuses on performance. It covers profiling the application to identify bottlenecks and applying optimization techniques to improve speed.

```markdown
## 27_performance.md

**Story 24: Profiling, optimization**

Covers techniques for profiling application performance, identifying bottlenecks, and applying optimizations to enhance speed and efficiency.
```

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

### Rooibos Tutorial: Configuration Files

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Covers the integration and usage of configuration files within Rooibos applications. This allows for externalizing settings and customizing application behavior.

```markdown
## 29_configuration.md

**Story 27: Config files**

Details the process of using configuration files to manage application settings, enabling easier customization and deployment.
```

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

### Ruby File Browser Tutorial - Modal Overlays

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This Ruby code snippet demonstrates the pattern for implementing modal overlays, such as a help screen, within the File Browser. It manages overlay UI state and interaction.

```ruby
# Conceptual example for managing modal overlays.

class OverlayManager
  attr_reader :current_overlay

  def initialize
    @current_overlay = nil # e.g., { type: :help, content: "..." }
  end

  def show_help
    @current_overlay = {
      type: :help,
      title: "Help",
      content: "Use arrow keys to navigate, Enter to open, Esc to go back."
    }
    puts "Showing help overlay."
  end

  def hide_overlay
    @current_overlay = nil
    puts "Overlay hidden."
  end

  def handle_key(key)
    if @current_overlay
      if key == :escape
        hide_overlay
      else
        # Handle keys specific to the overlay (e.g., scrolling help content)
        puts "Overlay key press: #{key}"
      end
    else
      # Handle keys for the main application
      puts "Main app key press: #{key}"
    end
  end
end

# Example Usage:
# overlay_manager = OverlayManager.new
# overlay_manager.show_help
# overlay_manager.handle_key(:escape)

```

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

### Verify Global Rooibos Gem Installation

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/e2e_pty_md

A Ruby function that checks if the 'rooibos' gem is installed globally. It requires the 'rooibos/version' and then searches for the installed gem specification. If not found, it fails the test and suggests running `rake install:force`.

```ruby
def require_global_rooibos!
  require "rooibos/version"
  installed = Gem::Specification.find_all_by_name("rooibos", Rooibos::VERSION)
  if installed.empty?
    flunk "Rooibos #{Rooibos::VERSION} not installed globally. Run: rake install:force"
  end
end
```

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

### Rooibos Tutorial: Text Preview and File Reading

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This tutorial step covers reading file content and implementing a text preview feature within the Rooibos application. It also touches upon scrolling within the UI.

```markdown
## 09_text_preview.md

**Story 6: File reading, scrolling**

Details the implementation of reading file contents to display a preview. Includes functionality for scrolling through the previewed text within the terminal interface.
```

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

### Rooibos Tutorial: Resize Events and Responsive Layouts

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Covers handling terminal resize events in Rooibos to create responsive layouts. This ensures the application's UI adapts gracefully to different terminal window sizes.

```markdown
## 25_resize_events.md

**Story 21: Responsive layouts**

Focuses on handling terminal resize events to implement responsive layouts that adapt dynamically to changes in the terminal window size.
```

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

### Ruby MVU TUI App with Rooibos and Ratatui

Source: https://www.rooibos.run/docs/v0.6/examples/verify_readme_usage/app_rb

This Ruby code defines a Model-View-Update (MVU) structure for a terminal user interface (TUI) application. It uses the 'rooibos_ruby' and 'ratatui_ruby' gems. The Model holds the application state, Init initializes the model, View renders the UI based on the model, and Update handles user input and state changes. The 'run' method starts the TUI application.

```ruby
# frozen_string_literal: true

#--
# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
# SPDX-License-Identifier: MIT-0
#++

$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)

require "ratatui_ruby"
require "rooibos"

class VerifyReadmeUsage
  # [SYNC:START:mvu]
  Model = Data.define(:text)

  Init = -> do
    Model.new(text: "Hello, Ratatui! Press 'q' to quit.")
  end

  View = -> (model, tui) do
    tui.paragraph(
      text: model.text,
      alignment: :center,
      block: tui.block(
        title: "My Ruby TUI App",
        borders: [:all],
        border_style: { fg: "cyan" }
      )
    )
  end

  Update = -> (msg, model) do
    if msg.q? || msg.ctrl_c?
      Rooibos::Command.exit
    else
      model
    end
  end

  def run
    Rooibos.run(VerifyReadmeUsage)
  end
  # [SYNC:END:mvu]
end

VerifyReadmeUsage.new.run if __FILE__ == $PROGRAM_NAME

```

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

### Rooibos Tutorial: File Metadata Pre-calculation

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Introduces the pattern of pre-calculating file metadata within the Rooibos application. This optimization technique can improve performance by avoiding repeated calculations.

```markdown
## 08_file_metadata.md

**Story 5: Pre-calculation pattern**

Explores the pattern of pre-calculating file metadata to optimize performance. This involves computing and storing information about files upfront rather than on demand.
```

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

### Rooibos Scaling: Comprehensive Testing Guide

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Provides a comprehensive guide to testing Rooibos applications. It covers strategies and best practices for writing effective tests to ensure application quality and reliability.

```markdown
## Testing

A detailed guide covering various aspects of testing Rooibos applications, including unit, integration, and end-to-end testing strategies.
```

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

### Rooibos Tutorial: Modal Overlays and Help Patterns

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Explains the pattern for implementing modal overlays in Rooibos, such as help overlays. This focuses on creating non-intrusive UI elements that provide contextual information.

```markdown
## 21_modal_overlays.md

**Story 18: Help overlay pattern**

Details the implementation of modal overlays, using a help overlay as an example. This pattern is useful for providing contextual information without disrupting the main UI flow.
```

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

### Fetch System Info with Rooibos (Ruby)

Source: https://www.rooibos.run/docs/v0.6/examples/app_fractal_dashboard/fragments/system_info_rb

This Ruby code defines a module `SystemInfo` that fetches system information using the `uname -a` command via Rooibos. It includes a data model for output and loading state, initialization logic, a view function for rendering, and an update function to process command results. The `fetch_command` method prepares the command for execution.

```ruby
# frozen_string_literal: true

#--
# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
# SPDX-License-Identifier: MIT-0
#++

require "rooibos"
# Fetches and displays system information via +uname -a+.
# A fragment for fetching and displaying system information.
module SystemInfo
  Command = Rooibos::Command

  Model = Data.define(:output, :loading)

  Init = -> do
    Model.new(output: "Press 's' for system info", loading: false)
  end

  View = -> (model, tui, disabled: false) do
    text_style = if disabled && model.output == Init.().output
      tui.style(fg: :dark_gray)
    else
      nil
    end

    tui.paragraph(
      text: tui.text_span(content: model.output, style: text_style),
      block: tui.block(title: "System Info", borders: [:all], border_style: { fg: :cyan })
    )
  end

  Update = -> (message, model) do
    case message
    in { type: :system, envelope: :system_info, status: 0, stdout: }
      [model.with(output: Ractor.make_shareable(stdout.strip), loading: false), nil]
    in { type: :system, envelope: :system_info, stderr: }
      [model.with(output: Ractor.make_shareable("Error: #{stderr.strip}"), loading: false), nil]
    else
      [model, nil]
    end
  end

  def self.fetch_command
    Command.system("uname -a", :system_info)
  end
end

```

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

### Translating BubbleTea to Rooibos for Go Developers

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

A guide for Go developers who are familiar with the BubbleTea framework, providing a translation guide to help them understand and migrate to Rooibos. This focuses on mapping BubbleTea patterns to Rooibos.

```markdown
## For Go Developers

This guide bridges the gap between BubbleTea (a popular Go framework for TUI applications) and Rooibos. It details how to translate common BubbleTea patterns, such as components, messages, and the update loop, into their Rooibos equivalents.
```

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

### Translating Textual to Rooibos for Python Developers

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

A guide for Python developers using the Textual framework, offering a translation guide to Rooibos. It helps Python developers understand how to map Textual's concepts to Rooibos.

```markdown
## For Python Developers

This section provides a translation guide for developers coming from Python's Textual framework. It explains how to map Textual's widget-based approach and event handling to Rooibos's message-driven architecture and view system.
```

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

### Rooibos Tutorial: Red-First TDD for Fragments

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This step in the Rooibos tutorial explains how to build new fragments using a red-first Test-Driven Development (TDD) approach. It focuses on writing tests before writing the implementation code.

```markdown
## 07_red_first_tdd.md

**Story 4b: Build second fragment via TDD ⭐**

Illustrates the Test-Driven Development (TDD) process, specifically the 'red' phase, for creating new application fragments. This ensures functionality is built to meet test requirements from the outset.
```

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

### Rooibos Fractal Composition Example

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/design/mvu_tea_implementations_research_md

Provides an example of fractal composition in Rooibos, inspired by Elm and Iced patterns. It shows how child fragment initializations can be combined and their commands batched for the parent.

```ruby
module Dashboard
  Init = ->(theme: :dark) do
    stats_model, stats_cmd = StatsPanel::Init.(theme: theme)
    network_model, network_cmd = NetworkPanel::Init.(theme: theme)

    model = Model.new(stats: stats_model, network: network_model)
    command = Command.batch(
            Rooibos.route(stats_cmd, :stats),
            Rooibos.route(network_cmd, :network)
    )

    [model, command]
  end
end
```

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

### Rooibos Tutorial: Loading States and Tri-State Models

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Explains how to manage loading states within the Rooibos application, utilizing tri-state models (e.g., loading, success, error) for robust data handling.

```markdown
## 26_loading_states.md

**Story 22: Tri-state models**

Introduces the concept of tri-state models for managing loading, success, and error states, providing a clear way to handle asynchronous data operations.
```

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

### Invariant Violation Example in Rooibos

Source: https://www.rooibos.run/docs/v0.6/Rooibos/Error/Invariant

Demonstrates an `Invariant` violation error in Rooibos, which occurs when library rules about valid states and contracts are broken. This example shows a common cause: providing conflicting API parameters to the `Rooibos.run` method.

```ruby
Rooibos.run(model: Model.new, view: nil, update: Update)  # => raises Error::Invariant
```

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

### Rooibos Tutorial: Text Input Widget and Cancellation Tokens

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Focuses on building a dedicated text input widget and introduces the concept of cancellation tokens for managing asynchronous operations. This is important for robust UI components.

```markdown
## 15_text_input_widget.md

**Story 12: Cancellation tokens ⭐**

Details the creation of a reusable text input widget and introduces the use of cancellation tokens for managing potentially long-running or interruptible operations within the UI.
```

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

### Rooibos CLI - New Command

Source: https://www.rooibos.run/docs/v0.6/Rooibos/CLI/Commands/New

Scaffolds a new Rooibos TUI application. This command simplifies project setup by handling gem structure, test setup, executable wiring, and dependency management, creating a Model-View-Update skeleton with tests.

```APIDOC
## POST /cli/commands/new

### Description
Scaffolds a new `Rooibos` TUI application. This command delegates to `bundle gem` for boilerplate and customizes the result for `Rooibos`, creating a Model-View-Update skeleton with a passing test.

### Method
POST

### Endpoint
/cli/commands/new

### Parameters
#### Query Parameters
- **app_name** (string) - Required - The name of the new application to create.
- **no-git** (boolean) - Optional - Skips Git initialization.
- **test** (string) - Optional - Specifies the testing framework (e.g., 'rspec').

### Request Example
```json
{
  "app_name": "my_app",
  "no-git": false,
  "test": "minitest"
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the application was created successfully.

#### Response Example
```json
{
  "message": "Application 'my_app' scaffolded successfully."
}
```

#### Error Response (400)
- **error** (string) - An error message if the application name is missing or invalid.
```

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

### Rooibos Tutorial: State Updates and More Tests

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

This tutorial step covers handling state updates within the Rooibos application and expands on writing tests. It builds upon the previous concepts of model and updates.

```markdown
## 04_arrow_navigation.md

**Story -1: State updates, more tests**

Explores how to manage and update the application's state effectively in Rooibos. This step also emphasizes writing more comprehensive tests to ensure application stability.
```

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

### Rooibos Tutorial: Conditional Rendering

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Demonstrates how to implement conditional rendering in Rooibos, allowing UI elements to be displayed or hidden based on the application's state. This is key for dynamic interfaces.

```markdown
## 14_toggle_hidden.md

**Story 11: Conditional rendering**

Explains how to conditionally render UI elements based on the application's state, enabling dynamic interfaces that adapt to different conditions.
```

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

### Rooibos Tutorial: Confirmation Dialogs and Modal UI State

Source: https://www.rooibos.run/docs/v0.6/doc/contributors/documentation_plan_md

Explains how to implement confirmation dialogs and manage the associated modal UI state within Rooibos. This is crucial for user confirmation of critical actions.

```markdown
## 17_confirmation_dialogs.md

**Story 14: Modal UI state**

Focuses on creating confirmation dialogs and managing the state associated with modal user interfaces, ensuring user actions are deliberate.
```

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

### Get Rooibos Actions Hash (Ruby)

Source: https://www.rooibos.run/docs/v0.6/Rooibos/Router/ClassMethods

Returns the registered handler actions hash. This hash stores the actions that have been defined and registered within the router.

```ruby
def actions
  @actions ||= {}
end
```