ratatui_ruby-tea 0.3.1 → 0.4.0

data/examples/app_fractal_dashboard/dashboard/base.rb

@@ -5,26 +5,25 @@
 # SPDX-License-Identifier: MIT-0
 #++
 
-require_relative "../bags/stats_panel"
-require_relative "../bags/network_panel"
-require_relative "../bags/custom_shell_modal"
+require_relative "../fragments/stats_panel"
+require_relative "../fragments/network_panel"
+require_relative "../fragments/custom_shell_modal"
 
-# Shared Model, INITIAL, and VIEW for the Dashboard.
-#
-# This module is extended by the three UPDATE variants to demonstrate
-# the progression from verbose manual routing to declarative DSL.
+# Shared Model, Init, and View for the Dashboard.
+# Each Dashboard variation (Manual, Router, Helpers) provides its own Update.
 module DashboardBase
   Command = RatatuiRuby::Tea::Command
 
   Model = Data.define(:stats, :network, :shell_modal)
 
-  INITIAL = Model.new(
-    stats: StatsPanel::INITIAL,
-    network: NetworkPanel::INITIAL,
-    shell_modal: CustomShellModal::INITIAL
-  )
+  Init = -> do
+    stats, = RatatuiRuby::Tea.normalize_init(StatsPanel::Init.())
+    network, = RatatuiRuby::Tea.normalize_init(NetworkPanel::Init.())
+    shell_modal, = RatatuiRuby::Tea.normalize_init(CustomShellModal::Init.())
+    Model.new(stats:, network:, shell_modal:)
+  end
 
-  VIEW = lambda do |model, tui|
+  View = -> (model, tui) do
     modal_active = CustomShellModal.active?(model.shell_modal)
     hotkey, label_style = if modal_active
       [tui.style(fg: :dark_gray), tui.style(fg: :dark_gray)]
@@ -57,14 +56,14 @@ module DashboardBase
       direction: :vertical,
       constraints: [tui.constraint_fill(1), tui.constraint_fill(1), tui.constraint_length(3)],
       children: [
-        StatsPanel::VIEW.call(model.stats, tui, disabled: modal_active),
-        NetworkPanel::VIEW.call(model.network, tui, disabled: modal_active),
+        StatsPanel::View.call(model.stats, tui, disabled: modal_active),
+        NetworkPanel::View.call(model.network, tui, disabled: modal_active),
         controls,
       ]
     )
 
     # Compose modal overlay if active
-    modal_widget = CustomShellModal::VIEW.call(model.shell_modal, tui)
+    modal_widget = CustomShellModal::View.call(model.shell_modal, tui)
     if modal_widget
       tui.overlay(layers: [dashboard, modal_widget])
     else

data/examples/app_fractal_dashboard/dashboard/update_helpers.rb

@@ -17,10 +17,10 @@ module DashboardHelpers
 
   # Shared with other UPDATE variants
   Model = DashboardBase::Model
-  INITIAL = DashboardBase::INITIAL
-  VIEW = DashboardBase::VIEW
+  Init = DashboardBase::Init
+  View = DashboardBase::View
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     # Global Force Quit
     return [model, RatatuiRuby::Tea::Command.exit] if message.respond_to?(:ctrl_c?) && message.ctrl_c?
 
@@ -29,25 +29,25 @@ module DashboardHelpers
     # modal is active. Only user input (keys/mouse) should be blocked.
 
     # Route streaming command output to modal
-    if (result = Tea.delegate(message, :shell_output, CustomShellModal::UPDATE, model.shell_modal))
+    if (result = Tea.delegate(message, :shell_output, CustomShellModal::Update, model.shell_modal))
       new_modal, command = result
       return [model.with(shell_modal: new_modal), command]
     end
 
-    # Route to child bags
-    if (result = Tea.delegate(message, :stats, StatsPanel::UPDATE, model.stats))
+    # Route to child fragments
+    if (result = Tea.delegate(message, :stats, StatsPanel::Update, model.stats))
       new_child, command = result
       return [model.with(stats: new_child), command && Tea.route(command, :stats)]
     end
 
-    if (result = Tea.delegate(message, :network, NetworkPanel::UPDATE, model.network))
+    if (result = Tea.delegate(message, :network, NetworkPanel::Update, model.network))
       new_child, command = result
       return [model.with(network: new_child), command && Tea.route(command, :network)]
     end
 
     # Modal intercepts user input (not command results)
     if CustomShellModal.active?(model.shell_modal)
-      new_modal, command = CustomShellModal::UPDATE.call(message, model.shell_modal)
+      new_modal, command = CustomShellModal::Update.call(message, model.shell_modal)
       return [model.with(shell_modal: new_modal), command]
     end
 

data/examples/app_fractal_dashboard/dashboard/update_manual.rb

@@ -16,10 +16,10 @@ module DashboardManual
 
   # Shared with other UPDATE variants
   Model = DashboardBase::Model
-  INITIAL = DashboardBase::INITIAL
-  VIEW = DashboardBase::VIEW
+  Init = DashboardBase::Init
+  View = DashboardBase::View
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     # Global Force Quit
     return [model, RatatuiRuby::Tea::Command.exit] if message.respond_to?(:ctrl_c?) && message.ctrl_c?
 
@@ -29,18 +29,18 @@ module DashboardManual
     case message
     # Route command results to panels
     in [:stats, *rest]
-      new_panel, command = StatsPanel::UPDATE.call(rest, model.stats)
+      new_panel, command = StatsPanel::Update.call(rest, model.stats)
       mapped_command = command ? Command.map(command) { |child_result| [:stats, *child_result] } : nil
       return [model.with(stats: new_panel), mapped_command]
 
     in [:network, *rest]
-      new_panel, command = NetworkPanel::UPDATE.call(rest, model.network)
+      new_panel, command = NetworkPanel::Update.call(rest, model.network)
       mapped_command = command ? Command.map(command) { |child_result| [:network, *child_result] } : nil
       return [model.with(network: new_panel), mapped_command]
 
     in [:shell_output, *rest]
       # Route streaming command output to modal
-      new_modal, command = CustomShellModal::UPDATE.call(message, model.shell_modal)
+      new_modal, command = CustomShellModal::Update.call(message, model.shell_modal)
       return [model.with(shell_modal: new_modal), command]
     else
       nil # Fall through to input handling
@@ -48,7 +48,7 @@ module DashboardManual
 
     # Modal intercepts user input (not command results)
     if CustomShellModal.active?(model.shell_modal)
-      new_modal, command = CustomShellModal::UPDATE.call(message, model.shell_modal)
+      new_modal, command = CustomShellModal::Update.call(message, model.shell_modal)
       return [model.with(shell_modal: new_modal), command]
     end
 
@@ -61,22 +61,22 @@ module DashboardManual
       [model.with(shell_modal: CustomShellModal.open), nil]
 
     in _ if message.s?
-      command = Command.map(SystemInfo.fetch_command) { |r| [:stats, *r] }
+      command = Command.map(SystemInfo.fetch_command) { |batch| [:stats, batch.envelope, batch] }
       new_stats = model.stats.with(system_info: model.stats.system_info.with(loading: true))
       [model.with(stats: new_stats), command]
 
     in _ if message.d?
-      command = Command.map(DiskUsage.fetch_command) { |r| [:stats, *r] }
+      command = Command.map(DiskUsage.fetch_command) { |batch| [:stats, batch.envelope, batch] }
       new_stats = model.stats.with(disk_usage: model.stats.disk_usage.with(loading: true))
       [model.with(stats: new_stats), command]
 
     in _ if message.p?
-      command = Command.map(Ping.fetch_command) { |r| [:network, *r] }
+      command = Command.map(Ping.fetch_command) { |batch| [:network, batch.envelope, batch] }
       new_network = model.network.with(ping: model.network.ping.with(loading: true))
       [model.with(network: new_network), command]
 
     in _ if message.u?
-      command = Command.map(Uptime.fetch_command) { |r| [:network, *r] }
+      command = Command.map(Uptime.fetch_command) { |batch| [:network, batch.envelope, batch] }
       new_network = model.network.with(uptime: model.network.uptime.with(loading: true))
       [model.with(network: new_network), command]
 

data/examples/app_fractal_dashboard/dashboard/update_router.rb

@@ -16,10 +16,10 @@ module DashboardRouter
 
   Command = RatatuiRuby::Tea::Command
 
-  # Shared with other UPDATE variants
+  # Shared with other Update variants
   Model = DashboardBase::Model
-  INITIAL = DashboardBase::INITIAL
-  VIEW = DashboardBase::VIEW
+  Init = DashboardBase::Init
+  View = DashboardBase::View
 
   route :stats, to: StatsPanel
   route :network, to: NetworkPanel
@@ -39,5 +39,5 @@ module DashboardRouter
     end
   end
 
-  UPDATE = from_router
+  Update = from_router
 end

data/examples/app_fractal_dashboard/{bags → fragments}/custom_shell_input.rb

@@ -5,14 +5,18 @@
 # SPDX-License-Identifier: LGPL-3.0-or-later
 #++
 
-# Text input bag for custom shell command modal.
+require "ratatui_ruby/tea"
+# Text input fragment for custom shell command modal.
 #
 # Handles text entry. Sets cancelled: or submitted: in model for parent to detect.
 module CustomShellInput
   Model = Data.define(:text, :cancelled, :submitted)
-  INITIAL = Ractor.make_shareable(Model.new(text: "", cancelled: false, submitted: false))
 
-  VIEW = lambda do |model, tui|
+  Init = -> do
+    Ractor.make_shareable(Model.new(text: "", cancelled: false, submitted: false))
+  end
+
+  View = -> (model, tui) do
     content = if model.text.empty?
       tui.paragraph(text: tui.text_span(content: "Type a command...", style: { fg: :dark_gray }))
     else
@@ -50,7 +54,7 @@ module CustomShellInput
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
     in _ if message.respond_to?(:esc?) && message.esc?
       [model.with(cancelled: true), nil]

data/examples/app_fractal_dashboard/fragments/custom_shell_modal.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+require_relative "custom_shell_input"
+require_relative "custom_shell_output"
+
+# Modal overlay for custom shell command execution.
+module CustomShellModal
+  Command = RatatuiRuby::Tea::Command
+
+  Model = Data.define(:mode, :input, :output)
+
+  Init = -> do
+    input, = RatatuiRuby::Tea.normalize_init(CustomShellInput::Init.())
+    output, = RatatuiRuby::Tea.normalize_init(CustomShellOutput::Init.())
+    Ractor.make_shareable(Model.new(mode: :none, input:, output:))
+  end
+
+  View = -> (model, tui) do
+    case model.mode
+    when :input
+      CustomShellInput::View.call(model.input, tui)
+    when :output
+      CustomShellOutput::View.call(model.output, tui)
+    else
+      nil
+    end
+  end
+
+  Update = -> (message, model) do
+    case [model.mode, message]
+    in [:input, _]
+      # Delegate first, then check if user wants to close
+      new_input, _cmd = CustomShellInput::Update.call(message, model.input)
+
+      if new_input.cancelled
+        [Init.(), nil]
+      elsif new_input.submitted
+        shell_cmd = new_input.text
+        new_output = CustomShellOutput::Init.().with(command: shell_cmd, running: true)
+        reset_input, = RatatuiRuby::Tea.normalize_init(CustomShellInput::Init.())
+        [
+          model.with(mode: :output, input: reset_input, output: new_output),
+          Command.system(shell_cmd, :shell_output, stream: true),
+        ]
+      else
+        [model.with(input: new_input), nil]
+      end
+
+    in [:output, _]
+      # Delegate first, then check if user wants to close
+      case message
+      in RatatuiRuby::Event::Key if message.ctrl_c?
+        [Init.(), nil]
+      else
+        new_output, _cmd = CustomShellOutput::Update.call(message, model.output)
+
+        if new_output.dismissed
+          [Init.(), nil]
+        else
+          [model.with(output: new_output), nil]
+        end
+      end
+
+    else
+      [model, nil]
+    end
+  end
+
+  def self.open
+    input, = RatatuiRuby::Tea.normalize_init(CustomShellInput::Init.())
+    Init.().with(mode: :input, input:)
+  end
+
+  def self.active?(model)
+    model.mode != :none
+  end
+end

data/examples/app_fractal_dashboard/{bags → fragments}/custom_shell_output.rb

@@ -5,16 +5,20 @@
 # SPDX-License-Identifier: LGPL-3.0-or-later
 #++
 
-# Streaming output bag for custom shell command modal.
+require "ratatui_ruby/tea"
+# Streaming output fragment for custom shell command modal.
 #
 # Displays interleaved stdout/stderr. Border color reflects exit status.
 # Sets dismissed: in model for parent to detect.
 module CustomShellOutput
   Chunk = Data.define(:stream, :text)
   Model = Data.define(:command, :chunks, :running, :exit_status, :dismissed)
-  INITIAL = Ractor.make_shareable(Model.new(command: "", chunks: [].freeze, running: false, exit_status: nil, dismissed: false))
 
-  VIEW = lambda do |model, tui|
+  Init = -> do
+    Ractor.make_shareable(Model.new(command: "", chunks: [].freeze, running: false, exit_status: nil, dismissed: false))
+  end
+
+  View = -> (model, tui) do
     # Build styled spans from chunks
     spans = if model.chunks.empty? && model.running
       [tui.text_span(content: "Running...", style: tui.style(fg: :dark_gray))]
@@ -56,7 +60,7 @@ module CustomShellOutput
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
     in [:stdout, chunk]
       new_chunks = Ractor.make_shareable([*model.chunks, Chunk.new(stream: :stdout, text: chunk)].freeze)

data/examples/app_fractal_dashboard/{bags → fragments}/disk_usage.rb

@@ -5,16 +5,20 @@
 # SPDX-License-Identifier: MIT-0
 #++
 
+require "ratatui_ruby/tea"
 # Fetches and displays disk usage via +df -h+.
-# A bag for fetching and displaying disk usage.
+# A fragment for fetching and displaying disk usage.
 module DiskUsage
   Command = RatatuiRuby::Tea::Command
 
   Model = Data.define(:output, :loading)
-  INITIAL = Model.new(output: "Press 'd' for disk usage", loading: false)
 
-  VIEW = lambda do |model, tui, disabled: false|
-    text_style = if disabled && model.output == INITIAL.output
+  Init = -> do
+    Model.new(output: "Press 'd' for disk usage", loading: false)
+  end
+
+  View = -> (model, tui, disabled: false) do
+    text_style = if disabled && model.output == Init.().output
       tui.style(fg: :dark_gray)
     else
       nil
@@ -26,12 +30,11 @@ module DiskUsage
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
-    in [:disk_usage, { stdout:, status: 0 }]
-      lines = Ractor.make_shareable(stdout.lines.first(4).join.strip)
-      [model.with(output: lines, loading: false), nil]
-    in [:disk_usage, { stderr:, _status: }]
+    in [{ type: :system, envelope: :disk_usage, status: 0, stdout: }]
+      [model.with(output: Ractor.make_shareable(stdout.strip), loading: false), nil]
+    in [{ type: :system, envelope: :disk_usage, stderr: }]
       [model.with(output: Ractor.make_shareable("Error: #{stderr.strip}"), loading: false), nil]
     else
       [model, nil]
@@ -39,6 +42,6 @@ module DiskUsage
   end
 
   def self.fetch_command
-    Command.system("df -h", :disk_usage)
+    Command.system("df -h /", :disk_usage)
   end
 end

data/examples/app_fractal_dashboard/{bags → fragments}/network_panel.rb

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: MIT-0
 #++
 
+require "ratatui_ruby/tea"
 require_relative "ping"
 require_relative "uptime"
 
@@ -12,31 +13,30 @@ require_relative "uptime"
 module NetworkPanel
   Model = Data.define(:ping, :uptime)
 
-  INITIAL = Model.new(
-    ping: Ping::INITIAL,
-    uptime: Uptime::INITIAL
-  )
+  Init = -> do
+    ping, = RatatuiRuby::Tea.normalize_init(Ping::Init.())
+    uptime, = RatatuiRuby::Tea.normalize_init(Uptime::Init.())
+    Model.new(ping:, uptime:)
+  end
 
-  VIEW = lambda do |model, tui, disabled: false|
+  View = -> (model, tui, disabled: false) do
     tui.layout(
       direction: :horizontal,
       constraints: [tui.constraint_percentage(50), tui.constraint_percentage(50)],
       children: [
-        Ping::VIEW.call(model.ping, tui, disabled:),
-        Uptime::VIEW.call(model.uptime, tui, disabled:),
+        Ping::View.call(model.ping, tui, disabled:),
+        Uptime::View.call(model.uptime, tui, disabled:),
       ]
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
     in [:ping, *rest]
-      child_message = [:ping, *rest]
-      new_child, command = Ping::UPDATE.call(child_message, model.ping)
+      new_child, command = Ping::Update.call(rest, model.ping)
       [model.with(ping: new_child), command]
     in [:uptime, *rest]
-      child_message = [:uptime, *rest]
-      new_child, command = Uptime::UPDATE.call(child_message, model.uptime)
+      new_child, command = Uptime::Update.call(rest, model.uptime)
       [model.with(uptime: new_child), command]
     else
       [model, nil]

data/examples/app_fractal_dashboard/{bags → fragments}/ping.rb

@@ -5,16 +5,20 @@
 # SPDX-License-Identifier: MIT-0
 #++
 
+require "ratatui_ruby/tea"
 # Pings localhost to check network connectivity.
-# A bag for pinging localhost.
+# A fragment for pinging localhost.
 module Ping
   Command = RatatuiRuby::Tea::Command
 
   Model = Data.define(:output, :loading)
-  INITIAL = Model.new(output: "Press 'p' for ping", loading: false)
 
-  VIEW = lambda do |model, tui, disabled: false|
-    text_style = if disabled && model.output == INITIAL.output
+  Init = -> do
+    Model.new(output: "Press 'p' for ping", loading: false)
+  end
+
+  View = -> (model, tui, disabled: false) do
+    text_style = if disabled && model.output == Init.().output
       tui.style(fg: :dark_gray)
     else
       nil
@@ -26,11 +30,11 @@ module Ping
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
-    in [:ping, { stdout:, status: 0 }]
+    in [{ type: :system, envelope: :ping, status: 0, stdout: }]
       [model.with(output: Ractor.make_shareable(stdout.strip), loading: false), nil]
-    in [:ping, { stderr:, _status: }]
+    in [{ type: :system, envelope: :ping, stderr: }]
       [model.with(output: Ractor.make_shareable("Error: #{stderr.strip}"), loading: false), nil]
     else
       [model, nil]
@@ -38,6 +42,6 @@ module Ping
   end
 
   def self.fetch_command
-    Command.system("ping -c 1 localhost", :ping)
+    Command.system("ping -c 3 8.8.8.8", :ping)
   end
 end

data/examples/app_fractal_dashboard/{bags → fragments}/stats_panel.rb

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: MIT-0
 #++
 
+require "ratatui_ruby/tea"
 require_relative "system_info"
 require_relative "disk_usage"
 
@@ -12,31 +13,30 @@ require_relative "disk_usage"
 module StatsPanel
   Model = Data.define(:system_info, :disk_usage)
 
-  INITIAL = Model.new(
-    system_info: SystemInfo::INITIAL,
-    disk_usage: DiskUsage::INITIAL
-  )
+  Init = -> do
+    system_info, = RatatuiRuby::Tea.normalize_init(SystemInfo::Init.())
+    disk_usage, = RatatuiRuby::Tea.normalize_init(DiskUsage::Init.())
+    Model.new(system_info:, disk_usage:)
+  end
 
-  VIEW = lambda do |model, tui, disabled: false|
+  View = -> (model, tui, disabled: false) do
     tui.layout(
       direction: :horizontal,
       constraints: [tui.constraint_percentage(50), tui.constraint_percentage(50)],
       children: [
-        SystemInfo::VIEW.call(model.system_info, tui, disabled:),
-        DiskUsage::VIEW.call(model.disk_usage, tui, disabled:),
+        SystemInfo::View.call(model.system_info, tui, disabled:),
+        DiskUsage::View.call(model.disk_usage, tui, disabled:),
       ]
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
     in [:system_info, *rest]
-      child_message = [:system_info, *rest]
-      new_child, command = SystemInfo::UPDATE.call(child_message, model.system_info)
+      new_child, command = SystemInfo::Update.call(rest, model.system_info)
       [model.with(system_info: new_child), command]
     in [:disk_usage, *rest]
-      child_message = [:disk_usage, *rest]
-      new_child, command = DiskUsage::UPDATE.call(child_message, model.disk_usage)
+      new_child, command = DiskUsage::Update.call(rest, model.disk_usage)
       [model.with(disk_usage: new_child), command]
     else
       [model, nil]

data/examples/app_fractal_dashboard/{bags → fragments}/system_info.rb

@@ -5,16 +5,20 @@
 # SPDX-License-Identifier: MIT-0
 #++
 
+require "ratatui_ruby/tea"
 # Fetches and displays system information via +uname -a+.
-# A bag for fetching and displaying system information.
+# A fragment for fetching and displaying system information.
 module SystemInfo
   Command = RatatuiRuby::Tea::Command
 
   Model = Data.define(:output, :loading)
-  INITIAL = Model.new(output: "Press 's' for system info", loading: false)
 
-  VIEW = lambda do |model, tui, disabled: false|
-    text_style = if disabled && model.output == INITIAL.output
+  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
@@ -26,11 +30,11 @@ module SystemInfo
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
-    in [:system_info, { stdout:, status: 0 }]
+    in [{ type: :system, envelope: :system_info, status: 0, stdout: }]
       [model.with(output: Ractor.make_shareable(stdout.strip), loading: false), nil]
-    in [:system_info, { stderr:, _status: }]
+    in [{ type: :system, envelope: :system_info, stderr: }]
       [model.with(output: Ractor.make_shareable("Error: #{stderr.strip}"), loading: false), nil]
     else
       [model, nil]

data/examples/app_fractal_dashboard/{bags → fragments}/uptime.rb

@@ -5,16 +5,20 @@
 # SPDX-License-Identifier: MIT-0
 #++
 
+require "ratatui_ruby/tea"
 # Displays system uptime.
-# A bag for displaying system uptime.
+# A fragment for displaying system uptime.
 module Uptime
   Command = RatatuiRuby::Tea::Command
 
   Model = Data.define(:output, :loading)
-  INITIAL = Model.new(output: "Press 'u' for uptime", loading: false)
 
-  VIEW = lambda do |model, tui, disabled: false|
-    text_style = if disabled && model.output == INITIAL.output
+  Init = -> do
+    Model.new(output: "Press 'u' for uptime", loading: false)
+  end
+
+  View = -> (model, tui, disabled: false) do
+    text_style = if disabled && model.output == Init.().output
       tui.style(fg: :dark_gray)
     else
       nil
@@ -26,11 +30,11 @@ module Uptime
     )
   end
 
-  UPDATE = lambda do |message, model|
+  Update = -> (message, model) do
     case message
-    in [:uptime, { stdout:, status: 0 }]
+    in [{ type: :system, envelope: :uptime, status: 0, stdout: }]
       [model.with(output: Ractor.make_shareable(stdout.strip), loading: false), nil]
-    in [:uptime, { stderr:, _status: }]
+    in [{ type: :system, envelope: :uptime, stderr: }]
       [model.with(output: Ractor.make_shareable("Error: #{stderr.strip}"), loading: false), nil]
     else
       [model, nil]

data/examples/verify_readme_usage/README.md

@@ -19,9 +19,12 @@ This example exists as a documentation regression test. It ensures that the very
 <!-- SYNC:START:./app.rb:mvu -->
 ```ruby
 Model = Data.define(:text)
-MODEL = Model.new(text: "Hello, Ratatui! Press 'q' to quit.")
 
-VIEW = -> (model, tui) do
+Init = -> do
+  Model.new(text: "Hello, Ratatui! Press 'q' to quit.")
+end
+
+View = -> (model, tui) do
   tui.paragraph(
     text: model.text,
     alignment: :center,
@@ -33,7 +36,7 @@ VIEW = -> (model, tui) do
   )
 end
 
-UPDATE = -> (msg, model) do
+Update = -> (msg, model) do
   if msg.q? || msg.ctrl_c?
     RatatuiRuby::Tea::Command.exit
   else
@@ -42,7 +45,7 @@ UPDATE = -> (msg, model) do
 end
 
 def run
-  RatatuiRuby::Tea.run(model: MODEL, view: VIEW, update: UPDATE)
+  RatatuiRuby::Tea.run(VerifyReadmeUsage)
 end
 ```
 <!-- SYNC:END -->