tuile 0.10.0 → 0.12.0

data/lib/tuile/component/window.rb

@@ -24,7 +24,7 @@ module Tuile
         @content = nil
         # Optional bottom-row widget slot (e.g. a search field), spanning the
         # full inner width; and optional bottom-border chrome text embedded in
-        # the border line (mutually exclusive — the component, when present,
+        # the border row (mutually exclusive — the component, when present,
         # occupies the row and hides the text).
         @footer = nil
         @footer_text = StyledString::EMPTY
@@ -53,7 +53,7 @@ module Tuile
         return if @footer_text == new_text
 
         @footer_text = new_text
-        invalidate # repaint the bottom border line
+        invalidate # repaint the bottom border row
       end
 
       # Sets the bottom-row widget slot. The footer occupies the bottom border
@@ -147,10 +147,10 @@ module Tuile
         content.rect = Rect.new(rect.left + 1, rect.top + 1, rect.width - 1 - @border_right, rect.height - 2)
       end
 
-      # Paints the window border via {Component#draw_line}/{Component#draw_char},
+      # Paints the window border via {Component#draw_text}/{Component#draw_char},
       # so the border cells inherit {Component#effective_bg_color} — a
       # {Component#bg_color} on the window tints border and content alike. Both
-      # border lines are clipped by *display* width, so no caption overflows the
+      # border rows are clipped by *display* width, so no caption overflows the
       # box; when the window is active the whole border — the caption's own
       # colors included — is drawn in {Theme#active_border_color}.
       # @return [void]
@@ -165,15 +165,15 @@ module Tuile
 
         fg = active? ? screen.theme.active_border_color : nil
         bar = StyledString::Style.new(fg: fg)
-        draw_line(left, top, top_border(inner_w, fg).slice(0, w))
+        draw_text(left, top, top_border(inner_w, fg).slice(0, w))
         (1..(h - 2)).each do |dy|
           draw_char(left, top + dy, "│", bar)
           draw_char(left + w - 1, top + dy, "│", bar)
         end
-        draw_line(left, top + h - 1, bottom_border(inner_w, fg).slice(0, w)) if h >= 2
+        draw_text(left, top + h - 1, bottom_border(inner_w, fg).slice(0, w)) if h >= 2
       end
 
-      # Builds the top border line: corners, {#caption} embedded at its own
+      # Builds the top border row: corners, {#caption} embedded at its own
       # width, dashes filling the remainder. The caption keeps its own styling
       # unless `fg` is set — an active window's border claims it.
       # @param inner_w [Integer] the border's interior width.
@@ -186,7 +186,7 @@ module Tuile
         StyledString.styled("┌", fg: fg) + title + dashes + StyledString.styled("┐", fg: fg)
       end
 
-      # Builds the bottom border line. The corners take the border color; the
+      # Builds the bottom border row. The corners take the border color; the
       # interior is plain dashes when a {#footer} component occupies the row
       # (it overpaints them) or when there's no chrome, otherwise it carries
       # {#footer_text} embedded at its own width — keeping the text's own

data/lib/tuile/component.rb

@@ -211,7 +211,7 @@ module Tuile
     # Called on every attached component (pre-order, popups included) when
     # {Screen#theme} changes — at {Screen#theme=} / {Screen#theme_def=} and on
     # OS appearance flips. The hook exists for app *content* whose colors were
-    # baked in from the old theme (a {Label#text} / {List#lines} {StyledString}
+    # baked in from the old theme (a {Label#text} / {List#lines=} {StyledString}
     # styled with `theme[:accent]`); rebuild it here by re-running the code that
     # rendered it. See book ch6 for why built-in accents need no such handling.
     #
@@ -444,7 +444,7 @@ module Tuile
       screen.buffer.fill(area, bg ? StyledString::Style.new(bg:) : StyledString::Style::DEFAULT)
     end
 
-    # {Buffer#set_line} wrapper that fills {#effective_bg_color} behind any span
+    # {Buffer#set_text} wrapper that fills {#effective_bg_color} behind any span
     # with no bg of its own (via {StyledString#under_bg}), so an inherited
     # {#bg_color} shows through the content a component paints. A no-op layer
     # when nothing is inherited. Self-painters (those skipping the {#repaint}
@@ -453,11 +453,11 @@ module Tuile
     # @param y [Integer] row.
     # @param styled [StyledString]
     # @return [void]
-    def draw_line(x, y, styled)
-      screen.buffer.set_line(x, y, styled.under_bg(effective_bg_color))
+    def draw_text(x, y, styled)
+      screen.buffer.set_text(x, y, styled.under_bg(effective_bg_color))
     end
 
-    # {#draw_line}'s single-grapheme counterpart: writes `grapheme` at `(x, y)`,
+    # {#draw_text}'s single-grapheme counterpart: writes `grapheme` at `(x, y)`,
     # filling {#effective_bg_color} when `style` carries no bg of its own.
     # @param x [Integer] column.
     # @param y [Integer] row.

data/lib/tuile/screen.rb

@@ -114,7 +114,7 @@ module Tuile
     attr_reader :color_scheme
 
     # @return [Buffer] the back buffer components paint into
-    #   ({Buffer#set_line} / {Buffer#fill} / {Buffer#set_char}).
+    #   ({Buffer#set_text} / {Buffer#fill} / {Buffer#set_char}).
     attr_reader :buffer
 
     # Handler invoked when a {StandardError} escapes an event handler inside

data/lib/tuile/styled_string.rb

@@ -536,31 +536,40 @@ module Tuile
       result
     end
 
-    # Word-wraps to physical lines that each fit within `width` display
+    # Word-wraps to rows that each fit within `width` display
     # columns, preserving spans and styles across breaks. Greedy word-wrap,
     # hard-break for words wider than `width`, leading whitespace dropped on
     # wrapped continuations, hard `"\n"` breaks preserved as separate output
     # lines.
     #
+    # An indent is content, so it survives onto the first row — but there is no
+    # hanging indent:
+    #
+    #   StyledString.plain("  read config").wrap(20).map(&:to_s)
+    #   # => ["  read config"]        indent kept; the line never wrapped
+    #   StyledString.plain("  read config").wrap(6).map(&:to_s)
+    #   # => ["  read", "config"]     ...but a continuation starts at column 0
+    #
     # Whitespace runs are space or tab; other characters are treated as word
     # content. When a single character is wider than `width` (e.g. a 2-column
     # CJK character with `width = 1`), it is still emitted on its own line at
     # its natural width. The "no line exceeds `width`" guarantee therefore
-    # holds whenever every character is at most `width` columns wide.
+    # holds whenever every character is at most `width` columns wide. An indent
+    # that alone exceeds `width` is dropped rather than given a row of its own.
     #
     # @param width [Integer, nil] target column width. `nil` or `<= 0` skips
     #   wrapping and returns each hard-line as-is, so callers can pass a
     #   stale viewport width without crashing.
-    # @return [Array<StyledString>] one entry per physical (output) line.
+    # @return [Array<StyledString>] one entry per output row.
     #   An empty receiver returns `[]`.
     def wrap(width)
       return [] if empty?
 
-      hard_lines = lines
-      return hard_lines if width.nil? || width <= 0
+      input_lines = lines
+      return input_lines if width.nil? || width <= 0
 
       result = []
-      hard_lines.each { |hl| result.concat(wrap_one(hl, width)) }
+      input_lines.each { |line| result.concat(wrap_one(line, width)) }
       result
     end
 
@@ -708,20 +717,21 @@ module Tuile
       self.class.new(out)
     end
 
-    # @param hard_line [StyledString] one hard-broken line — no embedded `"\n"`.
+    # @param line [StyledString] one line — no embedded `"\n"`.
     # @param width [Integer]
     # @return [Array<StyledString>]
-    def wrap_one(hard_line, width)
-      return [hard_line] if hard_line.empty?
+    def wrap_one(line, width)
+      return [line] if line.empty?
 
       result = []
       line_glyphs = []
       line_w = 0
 
-      tokenize_for_wrap(hard_line).each do |type, glyphs, w|
+      tokenize_for_wrap(line).each do |type, glyphs, w|
         if type == :space
-          if line_w.zero?
-            # leading whitespace on a wrapped continuation: drop
+          if line_w.zero? && (!result.empty? || w > width)
+            # Nothing to emit: a continuation's leading run was consumed by the
+            # break, and an indent wider than the viewport conveys no nesting.
           elsif line_w + w <= width
             line_glyphs.concat(glyphs)
             line_w += w
@@ -753,18 +763,18 @@ module Tuile
     # a cluster is the unit a terminal draws, so measuring its parts separately
     # would both mis-total an emoji sequence and let a wrap break a letter away
     # from its combining mark.
-    # @param hard_line [StyledString]
+    # @param line [StyledString]
     # @return [Array<Array>] tokens shaped `[type, glyphs, w]` where `type` is
     #   `:space` or `:word`, `glyphs` is an `Array<[String, Style, Integer]>`
     #   (grapheme cluster, style, display width), and `w` is the token's total
     #   width.
-    def tokenize_for_wrap(hard_line)
+    def tokenize_for_wrap(line)
       tokens = []
       current_glyphs = []
       current_w = 0
       current_type = nil
 
-      each_glyph_with_style(hard_line) do |g, s|
+      each_glyph_with_style(line) do |g, s|
         type = [" ", "\t"].include?(g) ? :space : :word
         gw = Buffer.display_width(g)
         if current_type && current_type != type

data/lib/tuile/version.rb

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

data/lib/tuile/vertical_scroll_bar.rb

@@ -18,20 +18,20 @@ module Tuile
 
     # @param height [Integer] number of rows in the scrollbar (== viewport
     #   height).
-    # @param line_count [Integer] total number of content lines.
-    # @param top_line [Integer] index of the first visible content line.
-    def initialize(height, line_count:, top_line:)
+    # @param row_count [Integer] total number of content rows.
+    # @param scroll_top_row [Integer] index of the first visible content row.
+    def initialize(height, row_count:, scroll_top_row:)
       @height = height
 
       return unless height >= 1
 
-      if line_count <= height
+      if row_count <= height
         @handle_height = height
         @handle_start  = 0
         @handle_end    = height - 1
       else
-        @handle_height = [(height * height / line_count.to_f).ceil, 1].max
-        @handle_start  = (height * top_line / line_count.to_f).floor
+        @handle_height = [(height * height / row_count.to_f).ceil, 1].max
+        @handle_start  = (height * scroll_top_row / row_count.to_f).floor
         @handle_end    = @handle_start + @handle_height - 1
       end
     end

data/lib/tuile.rb

@@ -32,5 +32,9 @@ module Tuile
   end
 
   loader = Zeitwerk::Loader.for_gem
+  # Keeps Tuile's one optional dependency optional: the file requires
+  # `bigdecimal` at load, so a host app calling Zeitwerk::Loader.eager_load_all
+  # would otherwise raise LoadError for a component it never names.
+  loader.do_not_eager_load("#{__dir__}/tuile/component/big_decimal_field.rb")
   loader.setup
 end