rubytui 1.2.3 → 1.2.4

data/lib/rubytui/input/reader.rb

@@ -6,113 +6,204 @@ module RubyTUI
   module Input
     # Reads terminal input without blocking and decodes it with a {Parser}.
     #
+    # Input is read one byte at a time, only as far as the current event needs.
+    # Key presses or mouse reports that arrive together are each returned by
+    # successive calls to {#poll}, and input typed after an event stays unread
+    # in the input, so a later Reader or a child process can still read it
+    # once this Reader is discarded.
+    #
     # A lone ESC byte is told apart from the start of an escape sequence by
-    # waiting up to {ESC_TIMEOUT_MS} for more bytes.
+    # waiting up to {ESC_TIMEOUT_MS} for more bytes. The same wait applies to
+    # each further byte of an unfinished sequence; once no byte arrives for
+    # {ESC_TIMEOUT_MS}, an incomplete sequence is decoded as it stands (see
+    # {Parser#parse_prefix} with +partial+ false).
+    #
+    # String sequences that terminals write as replies (APC such as Kitty
+    # graphics responses, OSC, DCS, SOS, PM; see {Parser}) are read and
+    # discarded without an event when their terminator (ST or BEL) arrives.
+    # An ESC inside one that does not start ST ends it just before that ESC,
+    # also without an event.
+    #
+    # If no byte arrives for {ESC_TIMEOUT_MS}, or the input ends, before
+    # either happens, the sequence was typed, not sent: its introducer is
+    # returned as an Alt key (<tt>ESC P</tt> as Alt+P, likewise Alt+X,
+    # Alt+], Alt+^ and Alt+_) and every byte after it, a final lone ESC
+    # included, is decoded as normal input.
+    #
+    # If one reaches 4096 bytes with no terminator while bytes keep
+    # arriving, it is taken to be a reply: those bytes are discarded, and so
+    # is every further byte up to and including its terminator. Discarding
+    # also stops just before an ESC followed by a byte other than a
+    # backslash, and when no byte arrives for {ESC_TIMEOUT_MS} or the input
+    # ends; an ESC not yet discarded at that point is decoded as normal
+    # input.
+    #
+    # A CSI sequence with no final byte in its first 256 bytes is returned as
+    # Alt+[, and the bytes after <tt>ESC [</tt> are decoded as normal input
+    # (see {Parser#parse_prefix}).
+    #
+    # When the input is a TTY that reports its size (+winsize+), {#poll}
+    # also returns a {ResizeEvent} after the terminal size changes.
     #
     # @example
     #   reader = Input::Reader.new
-    #   event = reader.poll(timeout_ms: 50)  # => KeyEvent, MouseEvent or nil
+    #   event = reader.poll(timeout_ms: 50)  # => KeyEvent, MouseEvent, ResizeEvent or nil
     class Reader
       # Timeout for disambiguating standalone ESC from escape sequences (ms)
       ESC_TIMEOUT_MS = 50
 
+      # Size at which an unterminated string sequence is taken to be a
+      # terminal reply and discarded, in bytes. No other sequence is left
+      # unfinished by {Parser#parse_prefix} at this length.
+      MAX_REPLY_BYTES = 4096
+      private_constant :MAX_REPLY_BYTES
+
       # @param input [IO] input stream; must support <tt>IO.select</tt> and
       #   +read_nonblock+ (default: +$stdin+)
       def initialize(input: $stdin)
         @input = input
         @parser = Parser.new
+        @buffer = String.new
+        @eof = false
+        @size = nil
       end
 
       # Poll for an event with the given timeout.
       #
+      # Returns at once if a terminal resize is pending or input is already
+      # waiting; otherwise waits up to +timeout_ms+ for input. Each call
+      # returns at most one event; input after it is left unread for the next
+      # call. Input that yields no event (a terminal reply or an unrecognised
+      # sequence) is skipped and decoding goes on with whatever input is
+      # already waiting. At end of input (see {#eof?}) it waits the full
+      # +timeout_ms+ and returns nil, so polling loops do not spin.
+      #
       # @param timeout_ms [Integer] maximum time to wait for input, in milliseconds
       #   (default: 100)
-      # @return [KeyEvent, MouseEvent, nil] the decoded event, or nil if no input
-      #   arrived within the timeout or the bytes read were not recognised
+      # @return [KeyEvent, MouseEvent, ResizeEvent, nil] the next event, or nil
+      #   if no input arrived within the timeout, the input read held no event
+      #   and nothing more is waiting, or the input has ended
       def poll(timeout_ms: 100)
-        timeout_sec = timeout_ms / 1000.0
-        ready = IO.select([@input], nil, nil, timeout_sec)
-        return nil unless ready
-
-        read_event
+        event = next_event(timeout_ms)
+        sleep(timeout_ms / 1000.0) if event.nil? && @eof && @buffer.empty?
+        event
       end
 
-      # Blocking read - waits indefinitely for an event.
+      # Blocking read - waits until an event arrives or the input ends.
       #
-      # Calls {#poll} in a loop until it returns an event.
+      # Waits like {#poll}, in steps of one second, until it has an event.
+      # Unlike {#poll}, it does not wait at end of input: once every buffered
+      # event has been returned it raises.
       #
-      # @return [KeyEvent, MouseEvent] the next recognised event
+      # @return [KeyEvent, MouseEvent, ResizeEvent] the next recognised event
+      # @raise [EOFError] if the input has ended and every buffered event has
+      #   been returned
       def read
         loop do
-          event = poll(timeout_ms: 1000)
+          event = next_event(1000)
           return event if event
+          raise EOFError, "end of input" if @eof && @buffer.empty?
         end
       end
 
+      # Whether the end of the input has been reached.
+      #
+      # Events still buffered when this becomes true are returned by later
+      # calls to {#poll} and {#read}.
+      #
+      # @return [Boolean] true once a read has hit end of file
+      def eof?
+        @eof
+      end
+
       private
 
-      def read_event
-        # Read the first byte
-        first = read_byte
-        return nil unless first
-
-        if first == "\e"
-          # Could be standalone ESC or start of escape sequence.
-          # Wait briefly for more bytes.
-          if has_more_input?(ESC_TIMEOUT_MS)
-            bytes = first + read_available
-            @parser.parse(bytes)
-          else
-            @parser.parse("\e")
-          end
-        elsif first.ord < 128
-          @parser.parse(first)
-        else
-          # Multi-byte UTF-8: read continuation bytes
-          bytes = read_utf8(first)
-          @parser.parse(bytes)
+      # One {#poll} step without the end-of-input wait.
+      def next_event(timeout_ms)
+        resize = resize_event
+        return resize if resize
+
+        return nil if @buffer.empty? && !fill(timeout_ms)
+
+        loop do
+          event = decode_one
+          return event if event
+          # No event (terminal reply, unrecognised sequence): go on with any
+          # input that is already waiting.
+          return nil if @buffer.empty? && !fill(0)
         end
       end
 
-      def read_byte
-        @input.read_nonblock(1)
-      rescue IO::WaitReadable, EOFError
-        nil
+      # Decode and drop the first sequence in the buffer, waiting up to
+      # ESC_TIMEOUT_MS at a time for the rest of an incomplete one.
+      def decode_one
+        event, length = @parser.parse_prefix(@buffer, partial: !@eof)
+        while length.zero?
+          return skip_reply if @buffer.bytesize >= MAX_REPLY_BYTES
+
+          more = fill(ESC_TIMEOUT_MS)
+          event, length = @parser.parse_prefix(@buffer, partial: more && !@eof)
+        end
+        @buffer = @buffer.byteslice(length..)
+        event
       end
 
-      def read_available
-        buf = String.new
-        loop do
-          byte = @input.read_nonblock(1)
-          buf << byte
-        rescue IO::WaitReadable, EOFError
-          break
+      # Discard an unterminated string sequence of MAX_REPLY_BYTES and the
+      # rest of it as it arrives: through BEL or ST, or up to an ESC followed
+      # by another byte, a pause of ESC_TIMEOUT_MS or the end of input. A
+      # byte at a time, so the cost is linear. Returns nil (no event).
+      def skip_reply
+        @buffer = @buffer.end_with?("\e") ? "\e".b : String.new
+        while fill(ESC_TIMEOUT_MS)
+          case @buffer
+          when "\e" then next # may start ST
+          when "\a", "\e\\"
+            @buffer.clear
+            break
+          else
+            break if @buffer.start_with?("\e") # ESC that is not ST: decode from it
+
+            @buffer.clear
+          end
         end
-        buf
+        nil
       end
 
-      def has_more_input?(timeout_ms)
-        ready = IO.select([@input], nil, nil, timeout_ms / 1000.0)
-        !ready.nil?
+      # Wait up to +timeout_ms+ for input and append one byte of it to the
+      # buffer, leaving the rest unread. Returns true if a byte was read.
+      def fill(timeout_ms)
+        return false if @eof
+        return false unless IO.select([@input], nil, nil, timeout_ms / 1000.0)
+
+        @buffer << @input.read_nonblock(1)
+        true
+      rescue IO::WaitReadable
+        false
+      rescue EOFError
+        @eof = true
+        false
       end
 
-      # Read remaining bytes of a UTF-8 multibyte character
-      def read_utf8(first_byte)
-        ord = first_byte.ord
-        remaining = if ord >= 0xF0 then 3
-                    elsif ord >= 0xE0 then 2
-                    elsif ord >= 0xC0 then 1
-                    else 0
-                    end
-
-        bytes = first_byte
-        remaining.times do
-          b = read_byte
-          break unless b
-
-          bytes << b
-        end
-        bytes
+      # ResizeEvent if the input terminal's size changed since the last call.
+      def resize_event
+        size = input_size
+        return nil unless size
+
+        last = @size
+        @size = size
+        return nil if last.nil? || last == size
+
+        rows, cols = size
+        ResizeEvent.new(width: cols, height: rows)
+      end
+
+      # [rows, cols] of the input terminal, or nil if unavailable.
+      def input_size
+        return nil unless @input.respond_to?(:winsize) && @input.respond_to?(:tty?) && @input.tty?
+
+        @input.winsize
+      rescue SystemCallError, IOError
+        nil
       end
     end
   end

data/lib/rubytui/layout/flex.rb

@@ -10,7 +10,7 @@ module RubyTUI
       CENTER        = :center         # Center items, spare space split around edges
       SPACE_BETWEEN = :space_between  # Distribute spare space between items
       SPACE_AROUND  = :space_around   # Distribute spare space around items
-      STRETCH       = :stretch        # Stretch fill constraints to consume all space (default)
+      STRETCH       = :stretch        # Default; currently identical to START: spare space at end
     end
   end
 end

data/lib/rubytui/layout/layout.rb

@@ -55,8 +55,12 @@ module RubyTUI
       # Split a Rect into sub-Rects according to constraints.
       #
       # Sizes are solved along {#direction} over the area's length minus the
-      # total spacing; the other dimension is taken from +area+. Space left
-      # unallocated is placed according to {#flex}.
+      # total spacing; the other dimension is taken from +area+. +max+
+      # constraints never exceed their cap and +min+ constraints never shrink
+      # below their minimum (when the space allows it). Space no constraint can
+      # absorb (for example when every flexible constraint is a capped +max+) is
+      # left unallocated and placed according to {#flex}. The sizes never sum to
+      # more than the available length.
       #
       # @param area [Rect] area to split
       # @return [Array<Rect>] one Rect per constraint, in order (empty if there
@@ -83,7 +87,7 @@ module RubyTUI
         rects = []
 
         # Calculate gaps based on flex mode
-        leading, between, trailing = compute_flex_gaps(spare, n)
+        leading, between, _trailing = compute_flex_gaps(spare, n)
 
         offset = leading
         sizes.each_with_index do |size, i|
@@ -104,7 +108,7 @@ module RubyTUI
         return [0, 0, 0] if spare <= 0 || n <= 0
 
         case @flex
-        when Flex::START, Flex::STRETCH
+        when Flex::START, Flex::STRETCH  # STRETCH currently behaves like START
           [0, 0, spare]
         when Flex::END_POS
           [spare, 0, 0]
@@ -136,7 +140,8 @@ module RubyTUI
 
       # Two-pass constraint solver:
       # Pass 1: Resolve fixed constraints (Length, Percentage, Ratio)
-      # Pass 2: Distribute remaining space to Fill, apply Min/Max clamping
+      # Pass 2: Distribute remaining space to Fill, apply Min/Max clamping,
+      # then hand the leftover to constraints that can absorb it
       def solve(total)
         n = @constraints.length
         sizes = Array.new(n, 0)
@@ -169,6 +174,7 @@ module RubyTUI
 
         # Pass 2: Distribute remaining space among fill/min/max constraints
         if fill_indices.any? && remaining > 0
+          floors = sizes.dup  # min constraints keep their pass-1 size
           total_weight = fill_indices.sum do |i|
             c = @constraints[i]
             c.kind == :fill ? c.value : 1
@@ -189,11 +195,20 @@ module RubyTUI
             end
           end
 
-          # Adjust rounding errors
-          allocated = sizes.sum
-          diff = total - allocated
-          if diff != 0 && fill_indices.any?
-            sizes[fill_indices.last] += diff
+          # Hand the leftover (rounding error, or space a max did not take) to
+          # the last flexible constraint, then fills, mins and maxes, each only
+          # within its bounds. Space nobody can absorb stays unallocated.
+          diff = total - sizes.sum
+          order = %i[fill min max].flat_map do |kind|
+            fill_indices.select { |i| @constraints[i].kind == kind }.reverse
+          end
+          [fill_indices.last, *order].each do |i|
+            break if diff.zero?
+
+            c = @constraints[i]
+            size = (sizes[i] + diff).clamp(floors[i], c.kind == :max ? c.value : Float::INFINITY)
+            diff -= size - sizes[i]
+            sizes[i] = size
           end
         end
 

data/lib/rubytui/text/line.rb

@@ -6,13 +6,17 @@ module RubyTUI
   # @example
   #   Line.new([Span.new("Name: ", Style.new.bold), Span.new("Ada")])
   class Line
-    attr_reader :spans, :style
+    attr_reader :spans
+
+    # @return [Style] line-level style. {Widgets::Paragraph} honours it: it is
+    #   patched over {Text#style} and under each {Span#style}
+    attr_reader :style
 
     # @param spans [String, Span, Array<Span>] content; a String becomes one
     #   unstyled Span, a single Span is wrapped in an Array, an Array is used
     #   as-is (default: empty)
-    # @param style [Style] line-level style, stored as {#style}
-    #   (default: {Style::DEFAULT})
+    # @param style [Style, nil] line-level style, stored as {#style} (+nil+ is
+    #   stored as {Style::DEFAULT}); not applied to the spans (default: {Style::DEFAULT})
     # @raise [ArgumentError] if +spans+ is not a String, Span or Array
     def initialize(spans = [], style = Style::DEFAULT)
       @spans = case spans
@@ -21,7 +25,7 @@ module RubyTUI
                when Array  then spans
                else raise ArgumentError, "Line expects String, Span, or Array, got #{spans.class}"
                end
-      @style = style
+      @style = style || Style::DEFAULT
     end
 
     # Factory: from a plain string

data/lib/rubytui/text/span.rb

@@ -10,10 +10,11 @@ module RubyTUI
     attr_reader :content, :style
 
     # @param content [String] text of the span
-    # @param style [Style] style applied to the text (default: {Style::DEFAULT})
+    # @param style [Style, nil] style applied to the text; +nil+ is stored as
+    #   {Style::DEFAULT} (default: {Style::DEFAULT})
     def initialize(content, style = Style::DEFAULT)
       @content = content
-      @style = style
+      @style = style || Style::DEFAULT
     end
 
     # @return [Integer] display width of {#content} in terminal columns

data/lib/rubytui/text/text.rb

@@ -6,14 +6,19 @@ module RubyTUI
   # @example
   #   Text.new("first\nsecond").height  # => 2
   class Text
-    attr_reader :lines, :style
+    attr_reader :lines
+
+    # @return [Style] text-level style. {Widgets::Paragraph} honours it: each
+    #   span is drawn with the paragraph style patched with this style, then
+    #   {Line#style}, then {Span#style}
+    attr_reader :style
 
     # @param lines [String, Line, Array<Line, #to_s>] content; a String is split
     #   on newlines into unstyled Lines (trailing empty lines are dropped), a
     #   single Line is wrapped in an Array, and Array elements that are not
     #   Lines become unstyled Lines of their +to_s+ (default: empty)
-    # @param style [Style] text-level style, stored as {#style}
-    #   (default: {Style::DEFAULT})
+    # @param style [Style, nil] text-level style, stored as {#style} (+nil+ is
+    #   stored as {Style::DEFAULT}); not applied to the spans (default: {Style::DEFAULT})
     # @raise [ArgumentError] if +lines+ is not a String, Line or Array
     def initialize(lines = [], style = Style::DEFAULT)
       @lines = case lines
@@ -22,14 +27,14 @@ module RubyTUI
                when Array  then lines.map { |l| l.is_a?(Line) ? l : Line.new(l.to_s) }
                else raise ArgumentError, "Text expects String, Line, or Array, got #{lines.class}"
                end
-      @style = style
+      @style = style || Style::DEFAULT
     end
 
     # Factory: from a plain string (splits on newlines)
     #
     # @param content [String] text; see {#initialize} for the other accepted types
     # @param style [Style] text-level style stored as {#style}; not applied to
-    #   the spans (default: {Style::DEFAULT})
+    #   the spans, but honoured by {Widgets::Paragraph} (default: {Style::DEFAULT})
     # @return [Text]
     # @raise [ArgumentError] if +content+ is not a String, Line or Array
     def self.from(content, style = Style::DEFAULT)

data/lib/rubytui/unicode.rb

@@ -96,7 +96,7 @@ module RubyTUI
     def truncate_to_width(string, max_width)
       return "" if max_width <= 0
 
-      result = String.new
+      result = String.new(encoding: string.encoding)
       width = 0
 
       string.grapheme_clusters.each do |gc|

data/lib/rubytui/version.rb

@@ -2,5 +2,5 @@
 
 module RubyTUI
   # Gem version string.
-  VERSION = "1.2.3"
+  VERSION = "1.2.4"
 end

data/lib/rubytui/widgets/async_image.rb

@@ -51,20 +51,29 @@ module RubyTUI
 
       # @param loader [Proc] proc that returns PNG data (called in background thread)
       # @param key [Object, nil] cache key (uses loader.object_id if nil)
-      # @param cache [Hash, nil] shared cache hash for storing loaded images; if it
-      #   already holds +key+, the widget is ready immediately and +loader+ is not
+      # @param cache [Hash, nil] shared cache hash for storing loaded images; only
+      #   data that passes {Image} validation is stored. If it already holds +key+,
+      #   +loader+ is not called and the widget is ready immediately, or in the
+      #   error state if the cached data fails validation; neither callback is
       #   called (default: nil, uses a private Hash)
       # @param placeholder [String, Widget, nil] widget or text to show while the
       #   image is not ready. A {Widget} is rendered in the pending, loading and
-      #   error states. A String is drawn centered only while pending; while loading
-      #   the text <tt>"Loading..."</tt> is shown instead (default: nil)
+      #   error states. A String is drawn centered on the middle row, truncated to
+      #   the area width, while pending and while loading; in the error state
+      #   +error_placeholder+ is drawn the same way instead (default: nil,
+      #   nothing while pending and <tt>"Loading..."</tt> while loading)
       # @param error_placeholder [String, nil] text to show on error unless
       #   +placeholder+ is a {Widget} (default: nil, shows <tt>"[Error]"</tt>)
       # @param on_ready [Proc, nil] callback invoked when image is ready (for triggering redraw).
-      #   Called with no arguments on the loading thread after +loader+ returns; not
-      #   called on a cache hit
+      #   Called once, with no arguments, on the loading thread after +loader+ returns
+      #   data that passes {Image} validation and the state is +:ready+; not called on
+      #   a cache hit or on error. An exception it raises does not change the state
+      #   and does not call +on_error+: it ends the loading thread, so Ruby reports it
+      #   on $stderr (Thread#report_on_exception) and re-raises it in a thread that
+      #   joins the loader
       # @param on_error [Proc, nil] callback invoked on load error. Called on the loading
-      #   thread with the exception raised by +loader+
+      #   thread with the exception raised by +loader+ or by {Image} validation of the
+      #   returned data (e.g. {UnsupportedImageFormat} for JPEG bytes)
       # @param style [Style] background style, also used for placeholder text
       #   (default: {Style::DEFAULT})
       # @param block [Widgets::Block, nil] optional wrapping block
@@ -107,9 +116,13 @@ module RubyTUI
       # Start background loading if not already started.
       #
       # Does nothing unless the state is +:pending+. Otherwise sets the state to
-      # +:loading+ and calls +loader+ on a new thread. On success the data is
-      # stored in the cache and the state becomes +:ready+; if +loader+ raises a
-      # StandardError the state becomes +:error+.
+      # +:loading+ and calls +loader+ on a new thread, then validates the returned
+      # data by building an {Image}. On success the data is stored in the cache,
+      # the state becomes +:ready+ and then +on_ready+ is called, outside the error
+      # handling: an exception from +on_ready+ propagates out of the thread and
+      # leaves the widget +:ready+. If +loader+ or the validation raises a
+      # StandardError, nothing is cached, the state becomes +:error+, {#error} is
+      # set to the message and +on_error+ is called with the exception.
       #
       # @return [self]
       def start_loading
@@ -122,19 +135,22 @@ module RubyTUI
         @thread = Thread.new do
           begin
             data = @loader.call
+            image = new_image(data)
             @mutex.synchronize do
               @image_data = data
+              @image_widget = image
               @cache[@key] = data
               @state = STATE_READY
             end
-            build_image_widget
-            @on_ready&.call
           rescue => e
             @mutex.synchronize do
               @error = e.message
               @state = STATE_ERROR
             end
             @on_error&.call(e)
+          else
+            # Outside the rescue: an exception from the app's callback is not a load failure
+            @on_ready&.call
           end
         end
 
@@ -196,7 +212,7 @@ module RubyTUI
         when STATE_READY
           @image_widget&.render(render_area, buf)
         when STATE_LOADING
-          render_placeholder(render_area, buf, "Loading...")
+          render_placeholder(render_area, buf, @placeholder || "Loading...")
         when STATE_ERROR
           render_placeholder(render_area, buf, @error_placeholder)
         when STATE_PENDING
@@ -207,16 +223,8 @@ module RubyTUI
       private
 
       def build_image_widget
-        return unless @image_data
-
         @mutex.synchronize do
-          @image_widget = Image.new(
-            data: @image_data,
-            style: @style,
-            fit: @fit,
-            cell_size: @cell_size,
-            clip: true
-          )
+          @image_widget = new_image(@image_data)
         end
       rescue ArgumentError, UnsupportedImageFormat => e
         @mutex.synchronize do
@@ -225,19 +233,23 @@ module RubyTUI
         end
       end
 
+      def new_image(data)
+        Image.new(
+          data: data,
+          style: @style,
+          fit: @fit,
+          cell_size: @cell_size,
+          clip: true
+        )
+      end
+
+      # Render a Widget placeholder, otherwise draw +text+ truncated to the area width and centered.
       def render_placeholder(area, buf, text)
         case @placeholder
         when Widget
           @placeholder.render(area, buf)
-        when String
-          display_text = text || @placeholder
-          # Center the placeholder text
-          x = area.x + [(area.width - Unicode.string_width(display_text)) / 2, 0].max
-          y = area.y + area.height / 2
-          buf.set_string(x, y, display_text, @style)
         else
-          # Default: show text centered
-          display_text = text.to_s
+          display_text = Unicode.truncate_to_width(text.to_s, area.width)
           x = area.x + [(area.width - Unicode.string_width(display_text)) / 2, 0].max
           y = area.y + area.height / 2
           buf.set_string(x, y, display_text, @style)

data/lib/rubytui/widgets/block.rb

@@ -45,8 +45,8 @@ module RubyTUI
       # @param borders [Symbol, Array<Symbol>, Boolean, nil] sides to draw:
       #   +:all+ or +true+ (default: {ALL}), +:none+, +false+ or +nil+ for none,
       #   a single side symbol (+:top+, +:bottom+, +:left+, +:right+), or an
-      #   Array of side symbols (the Array is frozen in place); any other value
-      #   draws all sides
+      #   Array of side symbols (a frozen copy is kept; the caller's Array is not
+      #   modified); any other value draws all sides
       # @param border_set [Symbols::BorderSet] border characters (default: {Symbols::ROUNDED})
       # @param border_style [Style] style of the border characters (default: {Style::DEFAULT})
       # @param style [Style] style patched onto every cell of the area when it is
@@ -207,8 +207,8 @@ module RubyTUI
 
         return if available <= 0
 
-        title_text = Buffer.truncate_to_width(@title, available)
-        title_width = Buffer.string_width(title_text)
+        title_text = Unicode.truncate_to_width(@title, available)
+        title_width = Unicode.string_width(title_text)
 
         x = case @title_alignment
             when :center
@@ -232,7 +232,7 @@ module RubyTUI
         when Symbol
           [borders].freeze
         when Array
-          borders.freeze
+          borders.dup.freeze
         else
           [:top, :bottom, :left, :right].freeze
         end