ratatui_ruby-tea 0.3.1 → 0.4.0

data/lib/ratatui_ruby/tea/message/system/stream.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module RatatuiRuby
+  module Tea
+    module Message
+      module System
+        # Streaming message from a system command.
+        #
+        # Streaming commands send incremental output instead of batching. Each line
+        # is a separate message, followed by a completion message.
+        #
+        # This message includes predicates to distinguish stdout, stderr, and
+        # completion events for pattern matching workflows.
+        #
+        # Use it to handle <tt>Command.system(..., stream: true)</tt> output.
+        #
+        # === Example
+        #
+        #   case msg
+        #   in { type: :system_stream, envelope: :build, stream: :stdout, content: }
+        #     model.with(log: model[:log] + content)
+        #   in { type: :system_stream, envelope: :build, stream: :complete, status: 0 }
+        #     model.with(success: true)
+        #   end
+        #
+        Stream = Data.define(:envelope, :stream, :content, :status) do
+          include Predicates
+
+          # Returns <tt>true</tt> for system stream messages.
+          def system?
+            true
+          end
+
+          # Returns <tt>true</tt> for stdout messages.
+          def stdout?
+            stream == :stdout
+          end
+
+          # Returns <tt>true</tt> for stderr messages.
+          def stderr?
+            stream == :stderr
+          end
+
+          # Returns <tt>true</tt> for complete messages.
+          def complete?
+            stream == :complete
+          end
+
+          # Deconstructs for pattern matching.
+          #
+          # Returns a hash with <tt>:type</tt>, <tt>:envelope</tt>, <tt>:stream</tt>,
+          # and either <tt>:content</tt> (for stdout/stderr) or <tt>:status</tt> (for complete).
+          def deconstruct_keys(_keys)
+            if complete?
+              { type: :system_stream, envelope:, stream:, status: }
+            else
+              { type: :system_stream, envelope:, stream:, content: }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/tea/message/timer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module RatatuiRuby
+  module Tea
+    module Message
+      # Response from a timer command.
+      #
+      # Timer commands fire after a delay. Pattern matching in UPDATE distinguishes
+      # multiple timers. Without structured responses, timers return bare symbols—hard
+      # to extend with elapsed time or other metadata.
+      #
+      # This response includes the envelope for routing and elapsed time. Include
+      # Predicates for safe predicate calls on any message.
+      #
+      # Use it to handle +Command.wait+ or +Command.tick+ completions.
+      #
+      # === Example
+      #
+      #   case msg
+      #   in { type: :timer, envelope: :dismiss }
+      #     model.with(notification: nil)
+      #   in { type: :timer, envelope: :animate, elapsed: }
+      #     model.with(frame: next_frame(elapsed))
+      #   end
+      #
+      Timer = Data.define(:envelope, :elapsed) do
+        include Predicates
+
+        # Returns +true+ for timer responses.
+        def timer?
+          true
+        end
+
+        # Deconstructs for pattern matching.
+        #
+        # Returns a hash with <tt>:type</tt>, <tt>:envelope</tt>, and <tt>:elapsed</tt>.
+        def deconstruct_keys(_keys)
+          { type: :timer, envelope:, elapsed: }
+        end
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/tea/message.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module RatatuiRuby
+  module Tea
+    # Messages sent from commands to update functions.
+    #
+    # All built-in response types live here. Each includes the +Predicates+
+    # mixin for safe predicate calls.
+    module Message
+      # Fallback predicate mixin.
+      #
+      # Returns +false+ for any unknown predicate method (ending in +?+).
+      # Include in custom message types for safe predicate calls.
+      module Predicates
+        # Returns +false+ for unknown predicate methods.
+        def method_missing(name, *args, **kwargs, &block)
+          return false if name.to_s.end_with?("?") && args.empty? && kwargs.empty?
+
+          super
+        end
+
+        # Responds to all predicate methods.
+        def respond_to_missing?(name, *)
+          name.to_s.end_with?("?")
+        end
+      end
+    end
+  end
+end
+
+require_relative "message/timer"
+require_relative "message/http_response"
+require_relative "message/system/batch"
+require_relative "message/system/stream"
+require_relative "message/all"

data/lib/ratatui_ruby/tea/router.rb

@@ -9,16 +9,16 @@ module RatatuiRuby
   module Tea
     # Declarative DSL for Fractal Architecture.
     #
-    # Large applications decompose into bags. Each bag has its own Model,
-    # UPDATE, and VIEW. Parent bags route messages to child bags and compose views.
+    # Large applications decompose into fragments. Each fragment has its own Model,
+    # UPDATE, and VIEW. Parent fragments route messages to child fragments and compose views.
     # Writing this routing logic by hand is tedious and error-prone.
     #
     # Include this module to declare routes and keymaps. Call +from_router+ to
     # generate an UPDATE lambda that handles routing automatically.
     #
-    # A *bag* is a module containing <tt>Model</tt>, <tt>INITIAL</tt>,
-    # <tt>UPDATE</tt>, and <tt>VIEW</tt> constants. Bags compose: parent bags
-    # delegate to child bags.
+    # A *fragment* is a module containing <tt>Model</tt>, <tt>INITIAL</tt>,
+    # <tt>UPDATE</tt>, and <tt>VIEW</tt> constants. Fragments compose: parent fragments
+    # delegate to child fragments.
     #
     # === Example
     #
@@ -171,13 +171,13 @@ module RatatuiRuby
 
         # Process message and return [model, command] tuple.
         def call(message, model)
-          # 1. Try routing prefixed messages to child bags
-          @routes.each do |prefix, bag|
-            bag_update = bag.const_get(:UPDATE)
-            result = Tea.delegate(message, prefix, bag_update, model.public_send(prefix))
+          # 1. Try routing prefixed messages to child fragments
+          @routes.each do |prefix, fragment|
+            fragment_update = fragment.const_get(:Update)
+            result = Tea.delegate(message, prefix, fragment_update, model.public_send(prefix))
             if result
-              new_bag_model, command = result
-              return [model.with(prefix => new_bag_model), command] #: [_DataModel, Command::execution?]
+              new_fragment_model, command = result
+              return [model.with(prefix => new_fragment_model), command] #: [_DataModel, Command::execution?]
             end
           end