milktea 0.1.0

data/lib/milktea/model.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "tty-screen"
+
+module Milktea
+  # Base model class for creating TUI components following the Elm Architecture
+  class Model
+    attr_reader :state, :children
+
+    class << self
+      # Define a child model with optional state mapping
+      # @param klass [Class, Symbol] The child model class or method name
+      # @param mapper [Proc] Lambda to map parent state to child state
+      def child(klass, mapper = nil)
+        @children ||= []
+        @children << {
+          class: klass,
+          mapper: mapper || ->(_state) { {} }
+        }
+      end
+
+      # Get all child definitions for this model
+      # @return [Array<Hash>] Array of child definitions
+      def children
+        @children ||= []
+      end
+    end
+
+    def initialize(state = {})
+      @state = default_state.merge(state).freeze
+      @children = build_children(@state)
+    end
+
+    # Render the model to a string representation
+    # @return [String] The rendered output
+    def view
+      raise NotImplementedError, "#{self.class} must implement #view"
+    end
+
+    # Update the model based on a message
+    # @param message [Object] The message to process
+    # @return [Array(Model, Message)] New model and side effect message
+    def update(message)
+      raise NotImplementedError, "#{self.class} must implement #update"
+    end
+
+    # Create a new instance with updated state
+    # @param new_state [Hash] State updates to merge
+    # @return [Model] New model instance with updated state
+    def with(new_state = {})
+      merged_state = @state.merge(new_state)
+      return Kernel.const_get(self.class.name).new(merged_state) if self.class.name
+
+      self.class.new(merged_state)
+    end
+
+    # Combine all children views into a single string
+    # @return [String] Combined views of all children
+    def children_views
+      @children.map(&:view).join
+    end
+
+    # Get the current screen width
+    # @return [Integer] Screen width in characters
+    def screen_width
+      TTY::Screen.width
+    end
+
+    # Get the current screen height
+    # @return [Integer] Screen height in characters
+    def screen_height
+      TTY::Screen.height
+    end
+
+    # Get the current screen size
+    # @return [Array<Integer>] [width, height] in characters
+    def screen_size
+      TTY::Screen.size
+    end
+
+    private
+
+    # Build child model instances based on class definitions
+    # @param parent_state [Hash] The parent model's state
+    # @return [Array<Model>] Array of child model instances
+    def build_children(parent_state)
+      self.class.children.map do |definition|
+        state = definition[:mapper].call(parent_state)
+        resolve_child(definition[:class], state)
+      end.freeze
+    end
+
+    # Resolve child class and create instance
+    # @param klass [Class, Symbol] The child model class or method name
+    # @param state [Hash] The state to pass to the child
+    # @return [Model] Child model instance
+    def resolve_child(klass, state)
+      klass = send(klass) if klass.is_a?(Symbol)
+      raise ArgumentError, "Child must be a Model class, got #{klass.class}" unless klass.is_a?(Class) && klass <= Model
+
+      klass.new(state)
+    rescue NoMethodError
+      raise ArgumentError, "Method #{klass} not found for dynamic child resolution"
+    end
+
+    # Override in subclasses to provide default state
+    # @return [Hash] Default state for the model
+    def default_state
+      {}
+    end
+  end
+end

data/lib/milktea/program.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "timers"
+require "tty-reader"
+require "forwardable"
+
+module Milktea
+  # Main program class for running Milktea TUI applications
+  class Program
+    extend Forwardable
+    FPS = 60
+    REFRESH_INTERVAL = 1.0 / FPS
+
+    # Delegate config accessors
+    def_delegators :@config, :runtime, :renderer
+
+    # Delegate to runtime and renderer
+    delegate %i[start stop running? tick render? enqueue] => :runtime
+    delegate %i[setup_screen restore_screen render] => :renderer
+
+    def initialize(model, config: nil)
+      @model = model
+      @config = config || Milktea.config
+      @timers = Timers::Group.new
+      @reader = TTY::Reader.new(interrupt: :error)
+    end
+
+    def run
+      start
+      setup_screen
+      render(@model)
+      setup_timers
+      @timers.wait while running?
+    ensure
+      restore_screen
+    end
+
+    private
+
+    def process_messages
+      check_resize
+      @model = tick(@model)
+      render(@model) if render?
+    end
+
+    def setup_timers
+      # Main event loop
+      @timers.now_and_every(REFRESH_INTERVAL) do
+        read_keyboard_input
+        process_messages
+      end
+    end
+
+    def read_keyboard_input
+      key = @reader.read_keypress(nonblock: true)
+      return if key.nil?
+
+      enqueue_key_message(key)
+    rescue TTY::Reader::InputInterrupt
+      enqueue(Message::Exit.new)
+    end
+
+    def enqueue_key_message(key)
+      key_message = Message::KeyPress.new(
+        key: key,
+        value: key,
+        ctrl: key == "\u0003", # Ctrl+C
+        alt: false,
+        shift: false
+      )
+      enqueue(key_message)
+    end
+
+    def check_resize
+      return unless renderer.resize?
+
+      resize_message = Message::Resize.new
+      enqueue(resize_message)
+    end
+  end
+end

data/lib/milktea/renderer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "tty-cursor"
+require "tty-screen"
+
+module Milktea
+  # Renderer handles TUI rendering and screen management
+  class Renderer
+    def initialize(output = $stdout)
+      @output = output
+      @cursor = TTY::Cursor
+      @last_screen_size = TTY::Screen.size
+    end
+
+    def render(model)
+      @output.print @cursor.clear_screen
+      @output.print @cursor.move_to(0, 0)
+      content = model.view
+      @output.print content
+      @output.flush
+    end
+
+    def setup_screen
+      @output.print @cursor.hide
+      @output.print @cursor.clear_screen
+      @output.print @cursor.move_to(0, 0)
+      @output.flush
+    end
+
+    def restore_screen
+      @output.print @cursor.clear_screen
+      @output.print @cursor.show
+      @output.flush
+    end
+
+    def resize?
+      current_size = TTY::Screen.size
+      return false if current_size == @last_screen_size
+
+      @last_screen_size = current_size
+      true
+    end
+  end
+end

data/lib/milktea/runtime.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Milktea
+  # Runtime manages message processing and execution state for Milktea applications
+  class Runtime
+    def initialize(queue: Queue.new)
+      @queue = queue
+      @running = false
+      @should_render = false
+    end
+
+    def tick(model)
+      has_render_messages = false
+
+      until @queue.empty?
+        message = @queue.pop(true) # non-blocking pop
+        model, side_effect = model.update(message)
+        execute_side_effect(side_effect)
+
+        # Only Message::None instances should not trigger render
+        has_render_messages = true unless message.is_a?(Message::None)
+      end
+
+      @should_render = has_render_messages
+      model
+    end
+
+    def render?
+      @should_render
+    end
+
+    def stop?
+      !@running
+    end
+
+    def running?
+      @running
+    end
+
+    def start
+      @running = true
+    end
+
+    def stop
+      @running = false
+    end
+
+    def enqueue(message)
+      @queue << message
+    end
+
+    private
+
+    def execute_side_effect(side_effect)
+      case side_effect
+      when Message::None
+        # Do nothing
+      when Message::Exit
+        stop
+      when Message::Batch
+        side_effect.messages.each { |msg| enqueue(msg) }
+      when Message::Reload
+        # Hot reload handled automatically by Zeitwerk
+        # No additional action needed
+      when Message::Resize
+        # Terminal resize detected
+        # No additional action needed at this level
+      end
+    end
+  end
+end

data/lib/milktea/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Milktea
+  VERSION = "0.1.0"
+end

data/lib/milktea.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "pathname"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+# The Milktea TUI framework for Ruby
+module Milktea
+  class Error < StandardError; end
+
+  MUTEX = Mutex.new
+
+  class << self
+    def app
+      MUTEX.synchronize { @app }
+    end
+
+    def app=(app)
+      MUTEX.synchronize { @app = app }
+    end
+
+    def root
+      @root ||= find_root
+    end
+
+    def env
+      (ENV.fetch("MILKTEA_ENV", nil) || ENV.fetch("APP_ENV", "production")).to_sym
+    end
+
+    def config
+      MUTEX.synchronize do
+        @config ||= Config.new
+      end
+    end
+
+    def configure(&block)
+      MUTEX.synchronize do
+        @config = if block_given?
+                    Config.new(&block)
+                  else
+                    Config.new
+                  end
+      end
+    end
+
+    private
+
+    def find_root
+      return Pathname.new(Bundler.root) if defined?(Bundler) && Bundler.respond_to?(:root)
+
+      # Find root by looking for common project files
+      current_dir = Pathname.new(Dir.pwd)
+      while current_dir.parent != current_dir
+        return current_dir if project_root?(current_dir)
+
+        current_dir = current_dir.parent
+      end
+
+      # Default to current directory if no project root found
+      Pathname.new(Dir.pwd)
+    end
+
+    def project_root?(dir)
+      %w[Gemfile Gemfile.lock .git].any? { |file| dir.join(file).exist? }
+    end
+  end
+end

data/sig/milktea.rbs

@@ -0,0 +1,4 @@
+module Milktea
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: milktea
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aotokitsuruya
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: timers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+- !ruby/object:Gem::Dependency
+  name: tty-cursor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: tty-reader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+description: The TUI framework for Ruby, inspired by the bubbletea framework for Go.
+email:
+- contact@aotoki.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".claude/commands/devlog.md"
+- ".claude/settings.json"
+- ".rspec"
+- ".rubocop.yml"
+- ARCHITECTURE.md
+- CLAUDE.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- docs/devlog/20250703.md
+- docs/devlog/20250704-2.md
+- docs/devlog/20250704.md
+- docs/devlog/20250705.md
+- examples/container_layout.rb
+- examples/container_simple.rb
+- examples/counter.rb
+- examples/dashboard.rb
+- examples/hot_reload_demo.rb
+- examples/hot_reload_demo/models/demo_model.rb
+- examples/hot_reload_demo/models/status_model.rb
+- examples/simple.rb
+- lib/milktea.rb
+- lib/milktea/application.rb
+- lib/milktea/bounds.rb
+- lib/milktea/config.rb
+- lib/milktea/container.rb
+- lib/milktea/loader.rb
+- lib/milktea/message.rb
+- lib/milktea/model.rb
+- lib/milktea/program.rb
+- lib/milktea/renderer.rb
+- lib/milktea/runtime.rb
+- lib/milktea/version.rb
+- sig/milktea.rbs
+homepage: https://github.com/elct9620/milktea
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/elct9620/milktea
+  source_code_uri: https://github.com/elct9620/milktea
+  changelog_uri: https://github.com/elct9620/milktea/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: The TUI framework for Ruby, inspired by the bubbletea framework for Go.
+test_files: []