ratatui_ruby 0.3.1 → 0.5.0

data/examples/test_login_form.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "ratatui_ruby"
-require "ratatui_ruby/test_helper"
-require "minitest/autorun"
-require_relative "login_form"
-
-class Minitest::Test
-  include RatatuiRuby::TestHelper
-end
-
-class TestLoginForm < Minitest::Test
-  def setup
-    @app = LoginFormApp.new
-  end
-
-  def test_render_initial_state
-    with_test_terminal(60, 20) do
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Enter Username:") }
-      # Initial cursor position check could be tricky without inspecting cursor state,
-      # but we can rely on visual cursor rendering if we had a way to check attributes,
-      # or just assume the widget logic puts it there.
-    end
-  end
-
-  def test_input_handling
-    # Type 'a'
-    inject_event("key", { code: "a" })
-    @app.handle_input
-
-    with_test_terminal(60, 20) do
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Enter Username: [ a ]") }
-    end
-  end
-
-  def test_popup_flow
-    # Enter username 'user'
-    %w[u s e r].each do |char|
-      inject_event("key", { code: char })
-      @app.handle_input
-    end
-
-    # Press Enter
-    inject_event("key", { code: "enter" })
-    @app.handle_input
-
-    with_test_terminal(60, 20) do
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Successful!") }
-    end
-
-    # Press 'q' to quit popup/app
-    inject_event("key", { code: "q" })
-    status = @app.handle_input
-    assert_equal :quit, status
-  end
-end

data/examples/test_map_demo.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "ratatui_ruby"
-require "ratatui_ruby/test_helper"
-require "minitest/autorun"
-require_relative "map_demo"
-
-class TestMapDemo < Minitest::Test
-  include RatatuiRuby::TestHelper
-
-  def test_map_demo_renders
-    # Use a specific terminal size to make assertions reliable
-    with_test_terminal(20, 10) do
-      view = MapDemo.view(0.0)
-      RatatuiRuby.draw(view)
-
-      expected_buffer = [
-        "┌World Map Canvas──┐",
-        "│⣀⣀⣠⣶⣶⣶⡖⣲⠂⣶⣒⣦⣤⠶⢤⣤⣄⣀│",
-        "│⠹⠓⢦ ⠻⣿⡟⠉⣿⡿⣋⡁⠁  ⣴⠿⠋│",
-        "│⢀⡀⠘⣆⣴⡏ ⢀⡟⠻⣿⣧⣀⣀⣹⠟  │",
-        "│ ⠁ ⠈⢻⠿⣄⠘⢦⡔⢚⡏⠻⣽⣿⣀⡀ │",
-        "│⠄   ⠘⡆⣸⠃ ⡇⣼⡆ ⠈⡻⢿⣻⠤│",
-        "│     ⣷⠃  ⠙⠃ ⡀ ⠓⢳⢇⡆│",
-        "│   ⢀⡀⣻  ⣀⣀⣀⣤⣁⣤⣤⣄⣀⡀│",
-        "│⠾⠿⠉⠉⠙⠛⠛⠋⠁       ⠘⠧│",
-        "└──────────────────┘",
-      ]
-
-      expected_buffer.each_with_index do |line, i|
-        assert_equal line, buffer_content[i], "Line #{i} should match"
-      end
-    end
-  end
-
-  def test_quit
-    # We need to use with_test_terminal because MapDemo.run calls init_terminal and draw
-    with_test_terminal(80, 24) do
-      # Inject 'q' event
-      inject_event("key", { code: "q" })
-
-      # MapDemo.run should exit immediately after polling the 'q' event
-      # We use Timeout to prevent hanging if it's not quittable
-      require "timeout"
-      Timeout.timeout(1) do
-        MapDemo.run
-      end
-    end
-  end
-
-  def test_map_demo_animation
-    # Test that the animation actually happens within the run loop
-    with_test_terminal(20, 10) do
-      # We want to verify that the radius changes.
-      # We'll mock RatatuiRuby.draw to capture the views being drawn.
-      draw_calls = []
-
-      # We need to preserve the original behavior of draw if we want to see it in the test terminal,
-      # but for this test, we just want to inspect the view objects.
-
-      # Using a lambda as a mock for RatatuiRuby.draw
-      original_draw = RatatuiRuby.method(:draw)
-      RatatuiRuby.define_singleton_method(:draw) do |view|
-        draw_calls << view
-        original_draw.call(view)
-      end
-
-      begin
-        MapDemo.stub :sleep, nil do
-          # Inject some non-quitting events to let it loop
-          # radius starts at 0.0
-          # 1st loop: radius becomes 0.5, draws, polls 'up', sleeps
-          # 2nd loop: radius becomes 1.0, draws, polls 'up', sleeps
-          # 3rd loop: radius becomes 1.5, draws, polls 'q', breaks
-          inject_event("key", { code: "up" })
-          inject_event("key", { code: "up" })
-          inject_event("key", { code: "q" })
-
-          MapDemo.run
-        end
-      ensure
-        # Restore original draw method
-        RatatuiRuby.define_singleton_method(:draw, &original_draw)
-      end
-
-      assert_operator draw_calls.size, :>=, 3
-
-      # Check that the radius in each view is increasing
-      radii = draw_calls.map { |v| v.shapes.find { |s| s.is_a?(RatatuiRuby::Circle) }.radius }
-
-      assert_equal 0.5, radii[0]
-      assert_equal 1.0, radii[1]
-      assert_equal 1.5, radii[2]
-    end
-  end
-end

data/examples/test_popup_demo.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "ratatui_ruby"
-require "ratatui_ruby/test_helper"
-require "minitest/autorun"
-require_relative "popup_demo"
-
-class Minitest::Test
-  include RatatuiRuby::TestHelper
-end
-
-class TestPopupDemo < Minitest::Test
-  def setup
-    @app = PopupDemo.new
-  end
-
-  def test_render_initial_state
-    with_test_terminal(60, 20) do
-      @app.render
-
-      # Should have background text
-      assert buffer_content.any? { |line| line.include?("BACKGROUND RED") }
-
-      # Should have popup with "Clear is DISABLED" message
-      assert buffer_content.any? { |line| line.include?("Clear is DISABLED") }
-      assert buffer_content.any? { |line| line.include?("Style Bleed: Popup is RED!") }
-    end
-  end
-
-  def test_toggle_clear
-    with_test_terminal(60, 20) do
-      # Initial state: Clear disabled
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Clear is DISABLED") }
-
-      # Toggle Clear on
-      inject_event("key", { code: " " })
-      @app.handle_input
-
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Clear is ENABLED") }
-      assert buffer_content.any? { |line| line.include?("Resets background to default") }
-
-      # Toggle Clear off
-      inject_event("key", { code: " " })
-      @app.handle_input
-
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Clear is DISABLED") }
-    end
-  end
-
-  def test_quit
-    inject_event("key", { code: "q" })
-    status = @app.handle_input
-    assert_equal :quit, status
-  end
-end

data/examples/test_scroll_text.rb

@@ -1,130 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "minitest/autorun"
-require "ratatui_ruby/test_helper"
-
-# Load the demo
-require_relative "./scroll_text"
-
-class TestScrollText < Minitest::Test
-  include RatatuiRuby::TestHelper
-
-  def setup
-    @demo = ScrollTextDemo.new
-  end
-
-  def test_demo_initialization
-    assert_instance_of ScrollTextDemo, @demo
-  end
-
-  def test_initial_rendering
-    with_test_terminal(60, 10) do
-      @demo.render
-      content = buffer_content
-      
-      # Should show Line 1 at the top (inside the block border)
-      assert content[1].include?("Line 1")
-      # Should show title with scroll position 0, 0
-      assert content[0].include?("X: 0, Y: 0")
-    end
-  end
-
-  def test_scroll_down
-    inject_event("key", { code: "down" })
-    @demo.handle_input
-    
-    with_test_terminal(60, 10) do
-      @demo.render
-      content = buffer_content
-      
-      # After scrolling down once, Line 2 should be at the top
-      assert content[1].include?("Line 2"), "Expected Line 2 at top, got: #{content[1]}"
-      # Line 1 should not be visible (scrolled off)
-      refute content.any? { |line| line.include?("Line 1") }, "Line 1 should be scrolled off"
-      # Should show Y scroll position 1
-      assert content[0].include?("Y: 1")
-    end
-  end
-
-  def test_scroll_right
-    inject_event("key", { code: "right" })
-    @demo.handle_input
-    
-    with_test_terminal(60, 10) do
-      @demo.render
-      content = buffer_content
-      
-      # After scrolling right once, first character should be cut off
-      # "Line 1:" becomes "ine 1:"
-      assert content[1].include?("ine 1:"), "Expected horizontal scroll, got: #{content[1]}"
-      # Should show X scroll position 1
-      assert content[0].include?("X: 1")
-    end
-  end
-
-  def test_scroll_left_at_edge
-    # Try to scroll left when already at x=0
-    inject_event("key", { code: "left" })
-    @demo.handle_input
-    
-    with_test_terminal(60, 10) do
-      @demo.render
-      content = buffer_content
-      
-      # Should still show full "Line 1:" (can't scroll left past 0)
-      assert content[1].include?("Line 1:")
-      # Should still show X scroll position 0
-      assert content[0].include?("X: 0")
-    end
-  end
-
-  def test_scroll_up_at_top
-    # Try to scroll up when already at top (should stay at 0)
-    inject_event("key", { code: "up" })
-    @demo.handle_input
-    
-    with_test_terminal(60, 10) do
-      @demo.render
-      content = buffer_content
-      
-      # Should still show Line 1 at top (can't scroll above 0)
-      assert content[1].include?("Line 1")
-      # Should still show Y scroll position 0
-      assert content[0].include?("Y: 0")
-    end
-  end
-
-  def test_scroll_both_axes
-    # Scroll down 2 times and right 3 times
-    2.times do
-      inject_event("key", { code: "down" })
-      @demo.handle_input
-    end
-    3.times do
-      inject_event("key", { code: "right" })
-      @demo.handle_input
-    end
-    
-    with_test_terminal(60, 10) do
-      @demo.render
-      content = buffer_content
-      
-      # After scrolling down 2 and right 3, Line 3 should be at top with first 3 chars cut
-      # "Line 3:" becomes " 3:"
-      assert content[1].include?(" 3:"), "Expected Line 3 scrolled right by 3, got: #{content[1]}"
-      # Should show scroll position X: 3, Y: 2
-      assert content[0].include?("X: 3, Y: 2")
-    end
-  end
-
-  def test_quit
-    inject_event("key", { code: "q" })
-    status = @demo.handle_input
-    assert_equal :quit, status
-  end
-end

data/examples/test_stock_ticker.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "ratatui_ruby"
-require "ratatui_ruby/test_helper"
-require "minitest/autorun"
-require_relative "stock_ticker"
-
-class Minitest::Test
-  include RatatuiRuby::TestHelper
-end
-
-class TestStockTicker < Minitest::Test
-  def setup
-    @app = StockTickerApp.new
-  end
-
-  def test_render
-    with_test_terminal(60, 20) do
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Network Activity") }
-      assert buffer_content.any? { |line| line.include?("Stock Ticker") }
-      # It's a dynamic simulation, so exact content varies,
-      # but titles should be stable.
-    end
-  end
-
-  def test_update
-    # Render multiple times to ensure no crash on update
-    with_test_terminal(60, 20) do
-      @app.render
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Stock Ticker") }
-    end
-  end
-end

data/examples/test_system_monitor.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "ratatui_ruby"
-require "ratatui_ruby/test_helper"
-require "minitest/autorun"
-require_relative "system_monitor"
-
-class Minitest::Test
-  include RatatuiRuby::TestHelper
-end
-
-class TestSystemMonitor < Minitest::Test
-  def setup
-    @app = SystemMonitorApp.new
-  end
-
-  def test_render_initial_state
-    with_test_terminal(60, 20) do
-      @app.render
-      assert buffer_content.any? { |line| line.include?("Processes") }
-      assert buffer_content.any? { |line| line.include?("Memory Usage") }
-      assert buffer_content.any? { |line| line.include?("50%") }
-    end
-  end
-
-  def test_interaction
-    # Increase percentage
-    inject_event("key", { code: "up" })
-    @app.handle_input
-
-    with_test_terminal(60, 20) do
-      @app.render
-      assert buffer_content.any? { |line| line.include?("55%") }
-    end
-  end
-end

data/examples/test_table_select.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-require "test_helper"
-
-# Smoke test to ensure the table_select example can be loaded and instantiated
-class TestTableSelect < Minitest::Test
-  def test_table_select_smoke
-    # Verify the example can create a table with selection
-    rows = [["1", "test", "10%"]]
-    widths = [
-      RatatuiRuby::Constraint.length(8),
-      RatatuiRuby::Constraint.length(15),
-      RatatuiRuby::Constraint.length(10)
-    ]
-    
-    table = RatatuiRuby::Table.new(
-      header: ["PID", "Name", "CPU"],
-      rows: rows,
-      widths: widths,
-      selected_row: 0,
-      highlight_style: RatatuiRuby::Style.new(fg: :yellow),
-      highlight_symbol: "> ",
-      block: RatatuiRuby::Block.new(title: "Test", borders: :all)
-    )
-    
-    # Verify it can be drawn
-    with_test_terminal(40, 10) do
-      RatatuiRuby.draw(table)
-      # Just verify it doesn't crash
-      assert true
-    end
-  end
-end

data/ext/ratatui_ruby/src/buffer.rs

@@ -1,54 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use crate::style::parse_style;
-use magnus::prelude::*;
-use magnus::{Error, Ruby, Value};
-use ratatui::buffer::Buffer;
-use std::ffi::CStr;
-
-pub struct BufferWrapper {
-    ptr: *mut Buffer,
-}
-
-unsafe impl Send for BufferWrapper {}
-
-impl BufferWrapper {
-    pub fn new(buffer: &mut Buffer) -> Self {
-        Self { ptr: buffer }
-    }
-
-    pub fn set_string(&self, x: u16, y: u16, string: String, style_val: Value) -> Result<(), Error> {
-        let style = parse_style(style_val)?;
-        let buffer = unsafe { &mut *self.ptr };
-        buffer.set_string(x, y, string, style);
-        Ok(())
-    }
-
-    pub fn area(&self) -> Value {
-        let ruby = Ruby::get().unwrap();
-        let module = ruby.define_module("RatatuiRuby").unwrap();
-        let class = module.const_get::<_, magnus::RClass>("Rect").unwrap();
-        let buffer = unsafe { &*self.ptr };
-        let area = buffer.area;
-        class.funcall("new", (area.x, area.y, area.width, area.height)).unwrap()
-    }
-}
-
-unsafe impl magnus::TypedData for BufferWrapper {
-    fn class(ruby: &Ruby) -> magnus::RClass {
-        ruby.define_module("RatatuiRuby")
-            .and_then(|m| m.const_get("Buffer"))
-            .unwrap()
-    }
-
-    fn data_type() -> &'static magnus::DataType {
-        static DATA_TYPE: magnus::DataType = magnus::DataType::builder::<BufferWrapper>(unsafe {
-            CStr::from_bytes_with_nul_unchecked(b"RatatuiRuby::Buffer\0")
-        })
-        .build();
-        &DATA_TYPE
-    }
-}
-
-impl magnus::DataTypeFunctions for BufferWrapper {}

data/lib/ratatui_ruby/dsl.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-
-module RatatuiRuby
-  ##
-  # A wrapper class that provides a concise DSL for creating widgets and interacting
-  # with the terminal within the +main_loop+.
-  #
-  # This class is yielded to the block provided to {RatatuiRuby.main_loop}.
-  # It uses metaprogramming to delegate method calls to {RatatuiRuby} module functions
-  # and to act as a factory for {RatatuiRuby} widget classes.
-  #
-  # == Features
-  #
-  # 1. **Widget Shorthand**: Provides factory methods for every widget class.
-  #    Converts snake_case method calls (e.g., +paragraph+) into CamelCase class instantiations
-  #    (e.g., +RatatuiRuby::Paragraph.new+).
-  #
-  # 2. **Method Shorthand**: Aliases module functions of {RatatuiRuby}, allowing you
-  #    to call methods like +draw+ and +poll_event+ directly on the DSL object.
-  #
-  # == Example
-  #
-  #   RatatuiRuby.main_loop do |tui|
-  #     # Create UI using shorthand methods
-  #     view = tui.paragraph(
-  #       text: "Hello World",
-  #       block: tui.block(borders: [:all])
-  #     )
-  #
-  #     # Use module aliases to draw and handle events
-  #     tui.draw(view)
-  #     event = tui.poll_event
-  #
-  #     break if event && event[:code] == "q"
-  #   end
-  class DSL
-    # Wrap methods directly
-    RatatuiRuby.singleton_methods(false).each do |method_name|
-      define_method(method_name) do |*args, **kwargs, &block|
-        RatatuiRuby.public_send(method_name, *args, **kwargs, &block)
-      end
-    end
-
-    # Wrap classes as snake_case factories
-    RatatuiRuby.constants.each do |const_name|
-      next if const_name == :Buffer
-
-      klass = RatatuiRuby.const_get(const_name)
-      next unless klass.is_a?(Class)
-
-      method_name = const_name.to_s
-                              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                              .downcase
-
-      define_method(method_name) do |*args, **kwargs, &block|
-        klass.new(*args, **kwargs, &block)
-      end
-    end
-  end
-end