milktea 0.1.0

data/examples/dashboard.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "milktea"
+
+# Counter child component
+class CounterModel < Milktea::Model
+  def view
+    "Counter: #{state[:count]}"
+  end
+
+  def update(message)
+    case message
+    when Milktea::Message::KeyPress
+      handle_keypress(message)
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+
+  private
+
+  def default_state
+    { count: 0 }
+  end
+
+  def handle_keypress(message)
+    case message.value
+    when "+"
+      [with(count: state[:count] + 1), Milktea::Message::None.new]
+    when "-"
+      [with(count: state[:count] - 1), Milktea::Message::None.new]
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+end
+
+# Status bar child component
+class StatusBarModel < Milktea::Model
+  def view
+    "Status: #{state[:message]}"
+  end
+
+  def update(_message)
+    [self, Milktea::Message::None.new]
+  end
+
+  private
+
+  def default_state
+    { message: "Ready" }
+  end
+end
+
+# Dashboard parent component using nested models
+class DashboardModel < Milktea::Model
+  child CounterModel, ->(state) { { count: state[:count] } }
+  child StatusBarModel, ->(state) { { message: state[:status_message] } }
+
+  def view
+    <<~VIEW
+      === Dashboard v#{state[:app_version]} ===
+
+      #{children_views}
+
+      Controls:
+      - '+' / '-' to change counter
+      - 'r' to reset counter
+      - 's' to change status
+      - 'q' to quit
+
+      Ctrl+C to exit
+    VIEW
+  end
+
+  def update(message)
+    case message
+    when Milktea::Message::Exit
+      [self, message]
+    when Milktea::Message::KeyPress
+      handle_keypress(message)
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+
+  private
+
+  def default_state
+    {
+      count: 0,
+      status_message: "Dashboard Ready",
+      app_version: "1.0"
+    }
+  end
+
+  def handle_keypress(message)
+    case message.value
+    when "+"
+      [with(count: state[:count] + 1), Milktea::Message::None.new]
+    when "-"
+      [with(count: state[:count] - 1), Milktea::Message::None.new]
+    when "r"
+      [with(count: 0, status_message: "Counter Reset!"), Milktea::Message::None.new]
+    when "s"
+      new_status = state[:status_message] == "Dashboard Ready" ? "Status Updated!" : "Dashboard Ready"
+      [with(status_message: new_status), Milktea::Message::None.new]
+    when "q"
+      [self, Milktea::Message::Exit.new]
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+end
+
+# Create and run the dashboard program
+model = DashboardModel.new
+program = Milktea::Program.new(model)
+program.run

data/examples/hot_reload_demo/models/demo_model.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Hot Reload Demo Model
+#
+# This model demonstrates hot reloading capabilities.
+# While the program is running, try modifying this file:
+# 1. Change the welcome message below
+# 2. Modify the counter increment value
+# 3. Add new key bindings
+# 4. Change the view layout
+#
+# The changes should be reflected immediately in the running program!
+
+class DemoModel < Milktea::Model
+  child StatusModel, ->(state) { { message: state[:status], timestamp: state[:last_update] } }
+
+  def view
+    <<~VIEW
+      === Hot Reload Demo ===
+
+      Welcome! This demo shows hot reloading in action.
+
+      Counter: #{state[:count]} (try changing the increment value in demo_model.rb!)
+
+      #{children_views}
+
+      Instructions:
+      - '+' or 'k' to increment counter
+      - '-' or 'j' to decrement counter#{"  "}
+      - 'r' to reset counter
+      - 'm' to change status message
+      - 'q' to quit
+
+      Try editing this file while the program runs!
+      (Change the welcome message or add new features)
+
+      Ctrl+C to exit
+    VIEW
+  end
+
+  def update(message)
+    case message
+    when Milktea::Message::Exit
+      [self, message]
+    when Milktea::Message::KeyPress
+      handle_keypress(message)
+    when Milktea::Message::Reload
+      # Hot reload detected - model will be automatically rebuilt
+      [with, Milktea::Message::None.new]
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+
+  private
+
+  def default_state
+    {
+      count: 0,
+      status: "Ready for hot reloading!",
+      last_update: Time.now.strftime("%H:%M:%S")
+    }
+  end
+
+  def handle_keypress(message)
+    case message.value
+    when "+", "k"
+      # Try changing this increment value from 1 to 5 while running!
+      new_count = state[:count] + 1
+      [with(count: new_count, last_update: Time.now.strftime("%H:%M:%S")), Milktea::Message::None.new]
+    when "-", "j"
+      new_count = state[:count] - 1
+      [with(count: new_count, last_update: Time.now.strftime("%H:%M:%S")), Milktea::Message::None.new]
+    when "r"
+      [with(count: 0, status: "Counter reset!", last_update: Time.now.strftime("%H:%M:%S")), Milktea::Message::None.new]
+    when "m"
+      messages = [
+        "Hot reloading is awesome!",
+        "Change this file and see it update!",
+        "Ruby + TUI = Great experience",
+        "Milktea framework rocks!"
+      ]
+      new_status = messages.sample
+      [with(status: new_status, last_update: Time.now.strftime("%H:%M:%S")), Milktea::Message::None.new]
+    when "q"
+      [self, Milktea::Message::Exit.new]
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+end

data/examples/hot_reload_demo/models/status_model.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Status Model - Child Component for Hot Reload Demo
+#
+# This demonstrates how child models are also reloaded automatically.
+# Try modifying this component while the demo is running:
+# 1. Change the status display format
+# 2. Add additional information
+# 3. Modify the styling
+
+class StatusModel < Milktea::Model
+  def view
+    <<~VIEW
+      Status: #{state[:message]}
+      Last Updated: #{state[:timestamp]}
+
+      [Tip: Try editing status_model.rb to change this display!]
+    VIEW
+  end
+
+  def update(_message)
+    # Status model is read-only, managed by parent
+    [self, Milktea::Message::None.new]
+  end
+
+  private
+
+  def default_state
+    {
+      message: "Default status",
+      timestamp: Time.now.strftime("%H:%M:%S")
+    }
+  end
+end

data/examples/hot_reload_demo.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "milktea"
+
+# Hot Reload Demo using Milktea::Application - Simplified setup
+#
+# This example shows how to use Milktea::Application for easier setup.
+# The Application class encapsulates Loader and Program configuration.
+#
+# To test hot reloading:
+# 1. Run this file: ruby examples/hot_reload_demo.rb
+# 2. In another terminal, edit files in examples/hot_reload_demo/models/
+# 3. Save the files and see changes reflected immediately!
+#
+# Features demonstrated:
+# - Simplified Application setup
+# - Automatic Loader and Program configuration
+# - Hot reloading with minimal boilerplate
+# - Clean Architecture with DDD principles
+
+puts "=== Milktea Application Hot Reload Demo ==="
+puts ""
+puts "This demo shows the new Application class in action!"
+puts "Try editing files in hot_reload_demo/models/ while this runs."
+puts ""
+
+# Check if Listen gem is available for optimal experience
+begin
+  gem "listen"
+  puts "✓ Listen gem detected - hot reloading will work!"
+rescue Gem::LoadError
+  puts "⚠ Listen gem not found - basic autoloading only"
+  puts "  Install with: gem install listen"
+end
+
+puts ""
+puts "Starting demo... (press any key to continue)"
+gets
+
+# Configure Milktea for hot reloading
+Milktea.configure do |c|
+  # Point to our demo components directory
+  c.autoload_dirs = ["examples/hot_reload_demo/models"]
+
+  # Enable hot reloading explicitly
+  c.hot_reloading = true
+end
+
+# Define Application class
+class HotReloadDemo < Milktea::Application
+  root "DemoModel"
+end
+
+puts "Hot reload demo starting..."
+puts "Edit files in hot_reload_demo/models/ to see changes instantly!"
+puts ""
+
+begin
+  HotReloadDemo.boot
+rescue Interrupt
+  puts "\nDemo ended. Thanks for trying the new Application class!"
+end

data/examples/simple.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "milktea"
+
+# Simple test model
+class TestModel < Milktea::Model
+  def view
+    "Hello from Milktea!\nPress 'q' to quit or Ctrl+C to exit\n"
+  end
+
+  def update(message)
+    case message
+    when Milktea::Message::Exit
+      [self, message]
+    when Milktea::Message::KeyPress
+      handle_keypress(message)
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+
+  private
+
+  def handle_keypress(message)
+    case message.value
+    when "q"
+      [self, Milktea::Message::Exit.new]
+    else
+      [self, Milktea::Message::None.new]
+    end
+  end
+end
+
+# Create and run a simple Milktea program
+model = TestModel.new
+program = Milktea::Program.new(model)
+program.run

data/lib/milktea/application.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+module Milktea
+  # Application class provides a high-level interface for creating Milktea applications
+  # It encapsulates the Loader and Program setup, making it easier to create TUI applications
+  class Application
+    class << self
+      def inherited(subclass)
+        super
+
+        Milktea.app = subclass
+      end
+
+      def root(model_name = nil)
+        return @root_model_name if model_name.nil?
+
+        @root_model_name = model_name
+      end
+
+      def root_model_class
+        return unless @root_model_name
+
+        Kernel.const_get(@root_model_name)
+      end
+
+      def boot
+        return new.run if @root_model_name
+
+        raise Error, "No root model defined. Use 'root \"ModelName\"' in your Application class."
+      end
+    end
+
+    attr_reader :config, :loader, :program
+
+    def initialize(config: nil)
+      @config = config || Milktea.config
+      setup_loader
+      setup_program
+    end
+
+    def run
+      loader.hot_reload if config.hot_reloading?
+      program.run
+    end
+
+    private
+
+    def setup_loader
+      @loader = Loader.new(config)
+      loader.setup
+    end
+
+    def setup_program
+      unless self.class.root_model_class
+        raise Error,
+              "No root model defined. Use 'root \"ModelName\"' in your Application class."
+      end
+
+      @program = Program.new(self.class.root_model_class.new, config: config)
+    end
+  end
+end

data/lib/milktea/bounds.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Milktea
+  # Bounds represents the position and size of a UI element
+  Bounds = Data.define(:width, :height, :x, :y) do
+    def initialize(width: 0, height: 0, x: 0, y: 0) # rubocop:disable Naming/MethodParameterName
+      super
+    end
+  end
+end

data/lib/milktea/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Milktea
+  # Configuration class for Milktea applications
+  class Config
+    attr_accessor :autoload_dirs, :output
+    attr_writer :hot_reloading, :runtime, :renderer
+
+    def initialize
+      @autoload_dirs = ["app/models"]
+      @output = $stdout
+      @hot_reloading = nil # Will be set by lazy evaluation
+      @runtime = nil # Will be set by lazy evaluation
+      @renderer = nil # Will be set by lazy evaluation
+
+      yield(self) if block_given?
+    end
+
+    def hot_reloading?
+      @hot_reloading || (Milktea.env == :development)
+    end
+
+    def runtime
+      @runtime ||= Runtime.new
+    end
+
+    def renderer
+      @renderer ||= Renderer.new(@output)
+    end
+
+    def autoload_paths
+      @autoload_dirs.map { |dir| Milktea.root.join(dir) }
+    end
+  end
+end

data/lib/milktea/container.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Milktea
+  # Container model with layout capabilities using Flexbox
+  class Container < Model
+    attr_reader :bounds
+
+    class << self
+      # Define a child model with optional state mapping and flex properties
+      # @param klass [Class, Symbol] The child model class or method name
+      # @param mapper [Proc] Lambda to map parent state to child state
+      # @param flex [Integer] Flex grow factor for layout
+      def child(klass, mapper = nil, flex: 1)
+        @children ||= []
+        @children << {
+          class: klass,
+          mapper: mapper || ->(_state) { {} },
+          flex: flex
+        }
+      end
+
+      # Set the flex direction for the container
+      # @param dir [Symbol] The direction (:column or :row)
+      def direction(dir)
+        @direction = dir
+      end
+
+      # Get the flex direction (defaults to :column)
+      # @return [Symbol] The flex direction
+      def flex_direction
+        @direction || :column
+      end
+    end
+
+    def initialize(state = {})
+      @bounds = extract_bounds(state)
+      # Remove bounds keys from state before passing to parent
+      super(state.except(:width, :height, :x, :y))
+    end
+
+    def view = children_views
+
+    private
+
+    def extract_bounds(state)
+      Bounds.new(
+        width: state[:width] || screen_width,
+        height: state[:height] || screen_height,
+        x: state[:x] || 0,
+        y: state[:y] || 0
+      )
+    end
+
+    # Override build_children to apply flexbox layout
+    def build_children(parent_state)
+      return [].freeze if self.class.children.empty?
+
+      layout_children(parent_state)
+    end
+
+    def layout_children(parent_state)
+      case self.class.flex_direction
+      when :row
+        layout_children_row(parent_state)
+      else
+        layout_children_column(parent_state)
+      end
+    end
+
+    def layout_children_column(parent_state)
+      total_flex = calculate_total_flex
+      current_y = bounds.y
+
+      self.class.children.map do |definition|
+        child_height = calculate_child_height(definition[:flex], total_flex)
+        child_state = build_child_state_column(definition, parent_state, current_y, child_height)
+        current_y += child_height
+        resolve_child(definition[:class], child_state)
+      end.freeze
+    end
+
+    def layout_children_row(parent_state)
+      total_flex = calculate_total_flex
+      current_x = bounds.x
+
+      self.class.children.map do |definition|
+        child_width = calculate_child_width(definition[:flex], total_flex)
+        child_state = build_child_state_row(definition, parent_state, current_x, child_width)
+        current_x += child_width
+        resolve_child(definition[:class], child_state)
+      end.freeze
+    end
+
+    def calculate_total_flex
+      self.class.children.sum { |definition| definition[:flex] }
+    end
+
+    def calculate_child_height(flex, total_flex)
+      (bounds.height * flex) / total_flex
+    end
+
+    def calculate_child_width(flex, total_flex)
+      (bounds.width * flex) / total_flex
+    end
+
+    def build_child_state_column(definition, parent_state, pos_y, child_height)
+      definition[:mapper].call(parent_state).merge(
+        width: bounds.width,
+        height: child_height,
+        x: bounds.x,
+        y: pos_y
+      )
+    end
+
+    def build_child_state_row(definition, parent_state, pos_x, child_width)
+      definition[:mapper].call(parent_state).merge(
+        width: child_width,
+        height: bounds.height,
+        x: pos_x,
+        y: bounds.y
+      )
+    end
+  end
+end

data/lib/milktea/loader.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+module Milktea
+  # Auto loading and hot reloading implementation for Milktea applications
+  class Loader
+    def initialize(config = nil)
+      @config = config || Milktea.config
+      @autoload_paths = @config.autoload_paths
+      @runtime = @config.runtime
+      @loader = nil
+      @listeners = []
+    end
+
+    def setup
+      @loader = Zeitwerk::Loader.new
+      @autoload_paths.each { |path| @loader.push_dir(path) }
+      @loader.enable_reloading
+      @loader.setup
+    end
+
+    def hot_reload
+      gem "listen"
+      require "listen"
+
+      @listeners = @autoload_paths.map do |path|
+        Listen.to(path, only: /\.rb$/) do |modified, added, removed|
+          reload if modified.any? || added.any? || removed.any?
+        end
+      end
+
+      @listeners.each(&:start)
+    rescue Gem::LoadError
+      # Listen gem not available, skip file watching
+    end
+
+    def reload
+      return unless @loader
+
+      @loader.reload
+      @runtime.enqueue(Message::Reload.new)
+    end
+  end
+end

data/lib/milktea/message.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Milktea
+  # Message definitions for events in the Milktea framework
+  module Message
+    # No operation message
+    None = Data.define
+
+    # Message to exit the program
+    Exit = Data.define
+
+    # Timer tick message
+    Tick = Data.define
+
+    # Keyboard event message
+    KeyPress = Data.define(:key, :value, :ctrl, :alt, :shift) do
+      def initialize(key:, value:, ctrl: false, alt: false, shift: false)
+        super
+      end
+    end
+
+    # Batch multiple messages
+    Batch = Data.define(:messages) do
+      def initialize(messages: [])
+        super
+      end
+    end
+
+    # Hot reload message
+    Reload = Data.define
+
+    # Terminal resize message
+    Resize = Data.define(:width, :height) do
+      def initialize(width: TTY::Screen.width, height: TTY::Screen.height)
+        super
+      end
+    end
+  end
+end