tuile 0.8.0 → 0.9.0

data/lib/tuile/fake_event_queue.rb

@@ -33,23 +33,39 @@ module Tuile
     def post(event); end
 
     # Mirrors {EventQueue#tick} but timeless: returns a {FakeTicker} that
-    # only fires when a test calls {#tick_once}. The `fps` argument is
+    # only fires when a test calls {#tick_once}. The `seconds` argument is
     # validated the same way the real queue validates it, then discarded —
     # the fake has no clock, so frame cadence is up to the test.
     #
-    # @param fps [Numeric] firings per second, must be positive. Validated
-    #   for parity with {EventQueue#tick}; otherwise unused.
+    # @param seconds [Numeric] interval between firings, must be positive.
+    #   Validated for parity with {EventQueue#tick}; otherwise unused.
     # @yield [tick] called on each {#tick_once}.
     # @yieldparam tick [Integer] 0-based monotonically increasing counter.
     # @yieldreturn [void]
     # @return [FakeTicker]
-    def tick(fps, &block)
+    def tick(seconds, &block)
+      raise ArgumentError, "block required" unless block
+      unless seconds.is_a?(Numeric) && seconds.positive?
+        raise ArgumentError, "seconds must be a positive Numeric, got #{seconds.inspect}"
+      end
+
+      FakeTicker.new(block).tap { |t| @tickers << t }
+    end
+
+    # Mirrors {EventQueue#tick_fps}: validates `fps` for parity, then delegates
+    # to {#tick} (the fake discards the interval regardless).
+    # @param fps [Numeric] firings per second, must be positive.
+    # @yield [tick] called on each {#tick_once}.
+    # @yieldparam tick [Integer] 0-based monotonically increasing counter.
+    # @yieldreturn [void]
+    # @return [FakeTicker]
+    def tick_fps(fps, &block)
       raise ArgumentError, "block required" unless block
       unless fps.is_a?(Numeric) && fps.positive?
         raise ArgumentError, "fps must be a positive Numeric, got #{fps.inspect}"
       end
 
-      FakeTicker.new(block).tap { |t| @tickers << t }
+      tick(1.0 / fps, &block)
     end
 
     # Test helper: fires every live ticker's user block once and prunes

data/lib/tuile/fraction.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Tuile
+  # A width/height ratio, each a float in `0.0..1.0` — the single relational
+  # sizing primitive in Tuile. It exists for exactly one job: sizing a
+  # {Component::Popup} against the screen. A popup has no siblings competing for
+  # space and no rectangle in a tiled layout, so "half the screen, centered" is
+  # the sensible default, and that wants a ratio rather than a hard-coded cell
+  # count that would be wrong on the next terminal size.
+  #
+  # Tiled components are *not* sized this way: their parent computes explicit
+  # integer rects in its own `rect=` and hands them down. `Fraction` is
+  # deliberately scoped to {Component::Popup#size=} and is not a general layout
+  # primitive.
+  #
+  # Resolve it against a reference {Size} (the screen) to get concrete integer
+  # cells:
+  #
+  #   Fraction::HALF.resolve(Size.new(80, 24))  # => 40x12
+  #
+  # Integer arguments are coerced to float, so `Fraction.new(1, 1) == FULL`.
+  class Fraction < Data.define(:width, :height)
+    # @param width [Numeric] fraction of the reference width, `0.0..1.0`.
+    # @param height [Numeric] fraction of the reference height, `0.0..1.0`.
+    def initialize(width:, height:)
+      super(width: width.to_f, height: height.to_f)
+    end
+
+    # Resolves this fraction against a reference size, rounding each axis to the
+    # nearest cell and flooring at 1 — so a fraction never yields a zero-size
+    # result on a tiny terminal.
+    # @param reference [Size] the size to take a fraction of (usually the screen).
+    # @return [Size]
+    def resolve(reference)
+      Size.new([(reference.width * width).round, 1].max,
+               [(reference.height * height).round, 1].max)
+    end
+
+    # Half the reference size on each axis — the default {Component::Popup} size.
+    # @return [Fraction]
+    HALF = new(0.5, 0.5)
+    # The full reference size on each axis — fullscreen for a {Component::Popup}.
+    # @return [Fraction]
+    FULL = new(1.0, 1.0)
+  end
+end

data/lib/tuile/screen.rb

@@ -35,9 +35,9 @@ module Tuile
       @repainting = Set.new
       # Until the event loop is run, we pretend we're in the UI thread.
       @pretend_ui_lock = true
-      @scheme = detect_scheme
+      @color_scheme = detect_scheme
       @theme_def = ThemeDef.default
-      @theme = @theme_def.for(@scheme)
+      @theme = @theme_def.for(@color_scheme)
       # Structural root of the component tree: holds tiled content, popup
       # stack and status bar.
       @pane = ScreenPane.new
@@ -60,6 +60,9 @@ module Tuile
     # @return [ScreenPane] the structural root of the component tree.
     attr_reader :pane
 
+    # @return [Symbol] `:light` or `:dark`
+    attr_reader :color_scheme
+
     # @return [Buffer] the back buffer components paint into
     #   ({Buffer#set_line} / {Buffer#fill} / {Buffer#set_char}).
     attr_reader :buffer
@@ -133,7 +136,7 @@ module Tuile
 
       check_locked
       @theme_def = theme_def
-      self.theme = @theme_def.for(@scheme)
+      self.theme = @theme_def.for(@color_scheme)
     end
 
     # Replaces the theme and restyles the whole UI: fires
@@ -565,8 +568,8 @@ module Tuile
     # @param scheme [Symbol] `:dark` or `:light`.
     # @return [void]
     def on_color_scheme(scheme)
-      @scheme = scheme
-      self.theme = @theme_def.for(@scheme)
+      @color_scheme = scheme
+      self.theme = @theme_def.for(@color_scheme)
     end
 
     # Walks the current modal scope in pre-order, collects tab stops, and

data/lib/tuile/screen_pane.rb

@@ -123,14 +123,16 @@ module Tuile
     end
 
     # Lays out content (full pane minus the bottom row) and the status bar
-    # (bottom row). Modal popups self-recenter via {Component::Popup#center};
-    # non-modal overlays keep the position their owner assigned.
+    # (bottom row). Each popup re-resolves its {Component::Popup#size} against
+    # the new screen via {Component::Popup#reposition} — so a {Fraction} size
+    # tracks resize — repositioning itself (modal popups recenter; non-modal
+    # overlays keep the top-left their owner assigned).
     # @return [void]
     def layout
       return if rect.empty?
 
       @content.rect = Rect.new(rect.left, rect.top, rect.width, [rect.height - 1, 0].max) unless @content.nil?
-      @popups.each { |p| p.center if p.modal? }
+      @popups.each(&:reposition)
       @status_bar.rect = Rect.new(rect.left, rect.top + rect.height - 1, rect.width, 1)
     end
 

data/lib/tuile/version.rb

@@ -2,5 +2,5 @@
 
 module Tuile
   # @return [String]
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end