tty_string 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce94f319deb6062d8492d19e856f93d1e4b7fb1ef454e31e6824a1814b59a319
-  data.tar.gz: '05826ce61d59609df5db320f5e4bf83084b494a9f045f90b13cf8a3c18f07b40'
+  metadata.gz: 73cc746b842f0d06ee1999b3f489a6ff01dc369dab4541bc35b095fe48e040ca
+  data.tar.gz: 5e4ab9ee53fc27904a98e59c8f264fe14618ed324e9fc2097dd408da9614ff9d
 SHA512:
-  metadata.gz: 4299d0e7ffca36bf56f6899cb971a882e0646a71777cdbf0fd34a4569cfe3986d057fb0b10137815747b163d2e4da44b6243692d36ab8bee0141695df93416b1
-  data.tar.gz: 81e5f9aeee83e5b65df853dcfe94f41398eb5de0d690acafeded7aa896cfe80ba5c1cb09fad9ed4ff0a84edeb495cf6b4185a832261ce7ca9a248508015d0de9
+  metadata.gz: df7fa737a041d1593609f342e060c5a92a78c17fb8b7df8658c72c803d9f8ca72a6c8137ccda4ecdfadd9f042a9652c6ec33c554ad090edc9d2aad7eef1deb03
+  data.tar.gz: bd1246abfe031c1206d932e30a724b64e14455c99e9d7298774dbf8c76157ec365de312f32173b0adcfed11f906100bee7ded4151c82699332255d4b0d4cdd54

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# v2.0.0
+- TTYString is now a module not a class.
+- Address the issue where preserved styles and unknown codes would cause the cursor to be misaligned when moving, and potentially overwriting styles unexpectedly:
+  - `clear_style: false` is now `style: TTYString::RENDER`, which modifies styles to display as they would rather than just passing them through them unprocessed
+  - `clear_style: true` is now `style: TTYString::DROP` (and still the default)
+  - Unknown codes are now dropped by default
+  - it's now possible to set `unknown: TTYString::RAISE` to raise on unrecognized CSI codes (`unknown: TTYString::DROP` is the default)
+- drop more codes that are known to do nothing for the display of text `\e[?5l`,`\e[?5h`,`\e[?25l`,`\e[?25h`,`\e[?1004l`,`\e[?1004h`,`\e[?1049l`,`\e[?1049h`
+
 # v1.1.1
 - i forgot how arity works
 

data/README.md

@@ -32,11 +32,20 @@ Intended for use in tests of command line interfaces.
 | `\e[nK` | _n_=`0`: clear the line from the cursor forward <br>_n_=`1`: clear the line from the cursor backward <br>_n_=`2`: clear the line | _n_=`0` |
 | `\e[nS` | scroll up _n_ rows | _n_=`1` |
 | `\e[nT` | scroll down _n_ rows | _n_=`1` |
-| `\e[m` | styling codes: optionally suppressed with `clear_style: false` | |
-| `\e[?2004h` | enabled bracketed paste: suppressed | |
-| `\e[?2004l` | disable bracketed paste: suppressed | |
-| `\e[200~` | bracketed paste start: suppressed | |
-| `\e[201~` | bracketed paste end: suppressed | |
+| `\e[m` | styling codes: dropped with `style: :drop` (default), rendered with `style: :render`. | |
+| `\e[?5h` | reverse the screen: dropped | |
+| `\e[?5l` | normal the screen: dropped | |
+| `\e[?25h` | show the cursor: dropped | |
+| `\e[?25l` | hide the cursor: dropped | |
+| `\e[?1004h` | enable reporting focus: dropped | |
+| `\e[?1004l` | disable reporting focus: dropped | |
+| `\e[?1049h` | enable alternate screen buffer: dropped | |
+| `\e[?1049l` | disable alternate screen buffer: dropped | |
+| `\e[?2004h` | enable bracketed paste mode: dropped | |
+| `\e[?2004l` | disable bracketed paste mode: dropped | |
+| `\e[200~` | bracketed paste start: dropped | |
+| `\e[201~` | bracketed paste end: dropped | |
+| `\e[` | any other valid CSI code: dropped with `unknown: :drop` (default), raises TTYString::Error with `unknown: :raise`. | |
 
 ## Installation
 
@@ -61,14 +70,19 @@ TTYString.parse("th\ta string\e[3Gis is")
 => "this is a string"
 ```
 
-Styling information is suppressed by default:
+Styling information is dropped by default:
 ```ruby
 TTYString.parse("th\ta \e[31mstring\e[0m\e[3Gis is")
 => "this is a string"
 ```
-But can be passed through:
+But can be rendered:
 ```ruby
-TTYString.parse("th\ta \e[31mstring\e[0m\e[3Gis is", clear_style: false)
+TTYString.parse("th\ta \e[31mstring\e[0m\e[3Gis is", style: :render)
+=> "this is a \e[31mstring\e[0m"
+```
+
+```ruby
+TTYString.parse("th\ta \e[31mstring\e[0m\e[3Gis is", style: :render)
 => "this is a \e[31mstring\e[0m"
 ```
 
@@ -81,10 +95,7 @@ Just for fun TTYString.to_proc provides the `parse` method as a lambda, so:
 ## Limitations
 
 - Various terminals are wildly variously permissive with what they accept,
-  so this doesn't even try to cover all possible cases,
-  instead it covers the narrowest possible case, and leaves the codes in place when unrecognized
-
-- `clear_style: false` treats the style codes as regular text which may work differently when rendering codes that move the cursor.
+  so this doesn't even try to cover all possible cases
 
 ## Development
 

data/lib/tty_string/cell.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TTYString
+  class Cell
+    attr_reader :style, :value
+
+    def initialize(value, style: NullStyle)
+      @style = style
+      @value = value
+    end
+
+    def to_s(style_context: NullStyle)
+      "#{style.to_s(context: style_context)}#{value}"
+    end
+  end
+end

data/lib/tty_string/code.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class TTYString
+module TTYString
   class Code
     class << self
       def descendants

data/lib/tty_string/code_definitions.rb

@@ -3,7 +3,7 @@
 require_relative 'code'
 require_relative 'csi_code'
 
-class TTYString
+module TTYString
   class Code
     class SlashA < TTYString::Code # leftovers:allow
       char "\a"
@@ -32,7 +32,7 @@ class TTYString
       def action
         cursor.down
         cursor.col = 0
-        screen.write('')
+        screen.ensure_row
       end
     end
 

data/lib/tty_string/csi_code.rb

@@ -2,12 +2,12 @@
 
 require_relative 'code'
 
-class TTYString
+module TTYString
   class CSICode < TTYString::Code
     class << self
       def default_arg(value = nil)
         @default_arg ||= value
-        @default_arg || 1
+        @default_arg || '0'
       end
 
       private
@@ -19,7 +19,7 @@ class TTYString
       def args(parser)
         a = parser.matched.slice(2..-2).split(';')
         a = a.slice(0, max_args) unless max_args == -1
-        a.map! { |n| n.empty? ? default_arg : n.to_i }
+        a.map! { |n| n.empty? ? default_arg : n }
         a
       end
 
@@ -27,19 +27,14 @@ class TTYString
         @re ||= /\e\[#{args_re}#{char}/
       end
 
-      def args_re # rubocop:disable Metrics/MethodLength
+      def args_re
         case max_args
-        when 0 then nil
-        when 1 then /#{arg_re}?/
-        when -1 then /(#{arg_re}?(;#{arg_re})*)?/
-        else /(#{arg_re}?(;#{arg_re}){0,#{max_args - 1}})?/
+        when 0, 1 then /(?:[0-:<-?]*){0,#{max_args}}/
+        when -1 then %r{[0-?]*[ -/]*}
+        else /(?:(?:[0-:<-?]*)?(?:;(?:[0-:<-?]*)?){0,#{max_args - 1}})?/
         end
       end
 
-      def arg_re
-        /\d*/
-      end
-
       def max_args
         @max_args ||= begin
           params = instance_method(:action).parameters
@@ -49,6 +44,12 @@ class TTYString
         end
       end
     end
+
+    def integer(value)
+      return value.to_i if value.match?(/\A\d+\z/)
+
+      parser.unknown
+    end
   end
 end
 

data/lib/tty_string/csi_code_definitions.rb

@@ -2,63 +2,103 @@
 
 require_relative 'csi_code'
 
-class TTYString
+module TTYString
   class CSICode
     class A < TTYString::CSICode # leftovers:allow
-      def action(rows = 1)
-        cursor.up(rows)
+      def action(rows = '1')
+        rows = integer(rows)
+        cursor.up(rows) if rows
       end
     end
 
     class B < TTYString::CSICode # leftovers:allow
-      def action(rows = 1)
-        cursor.down(rows)
+      default_arg '1'
+
+      def action(rows = '1')
+        rows = integer(rows)
+        cursor.down(rows) if rows
       end
     end
 
     class C < TTYString::CSICode # leftovers:allow
-      def action(cols = 1)
-        cursor.right(cols)
+      default_arg 1
+
+      def action(cols = '1')
+        cols = integer(cols)
+        cursor.right(cols) if cols
       end
     end
 
     class D < TTYString::CSICode # leftovers:allow
-      def action(cols = 1)
-        cursor.left(cols)
+      default_arg '1'
+
+      def action(cols = '1')
+        cols = integer(cols)
+        cursor.left(cols) if cols
       end
     end
 
     class E < TTYString::CSICode # leftovers:allow
-      def action(rows = 1)
+      default_arg '1'
+
+      def action(rows = '1')
+        rows = integer(rows)
+        return unless rows
+
         cursor.down(rows)
         cursor.col = 0
       end
     end
 
     class F < TTYString::CSICode # leftovers:allow
-      def action(rows = 1)
+      default_arg '1'
+
+      def action(rows = '1')
+        rows = integer(rows)
+        return unless rows
+
         cursor.up(rows)
         cursor.col = 0
       end
     end
 
     class G < TTYString::CSICode # leftovers:allow
-      def action(col = 1)
+      default_arg '1'
+
+      def action(col = '1')
+        col = integer(col)
+        return unless col
+
         # cursor is zero indexed, arg is 1 indexed
-        cursor.col = col.to_i - 1
+        cursor.col = col - 1
       end
     end
 
     class H < TTYString::CSICode # leftovers:allow
-      def action(row = 1, col = 1)
+      default_arg '1'
+
+      def action(row = '1', col = '1')
+        col = integer(col)
+        row = integer(row)
+        return unless col && row
+
         # cursor is zero indexed, arg is 1 indexed
-        cursor.row = row.to_i - 1
-        cursor.col = col.to_i - 1
+        cursor.row = row - 1
+        cursor.col = col - 1
       end
     end
 
     class LowH < TTYString::CSICode # leftovers:allow
-      char(/\?2004h/)
+      char('h')
+
+      def action(code)
+        case code
+        when '?5', '?25', '?1004', '?1049', '?2004'
+          # drop
+        else
+          parser.unknown
+        end
+      end
     end
 
     class LowF < TTYString::CSICode::H # leftovers:allow
@@ -66,74 +106,70 @@ class TTYString
     end
 
     class J < TTYString::CSICode # leftovers:allow
-      default_arg 0
-
-      def self.arg_re
-        /[0-3]?/
-      end
-
-      def action(mode = 0)
-        # :nocov: else won't ever be called. don't worry about it
+      def action(mode = '0') # rubocop:disable Metrics/MethodLength
         case mode
-        # :nocov:
-        when 0 then screen.clear_forward
-        when 1 then screen.clear_backward
-        when 2, 3 then screen.clear
+        when '0' then screen.clear_forward
+        when '1' then screen.clear_backward
+        when '2', '3' then screen.clear
+        else parser.unknown
         end
       end
     end
 
     class K < TTYString::CSICode # leftovers:allow
-      default_arg 0
-
-      def self.arg_re
-        /[0-2]?/
-      end
-
-      def action(mode = 0)
-        # :nocov: else won't ever be called. don't worry about it
+      def action(mode = '0') # rubocop:disable Metrics/MethodLength
         case mode
-        # :nocov:
-        when 0 then screen.clear_line_forward
-        when 1 then screen.clear_line_backward
-        when 2 then screen.clear_line
+        when '0' then screen.clear_line_forward
+        when '1' then screen.clear_line_backward
+        when '2' then screen.clear_line
+        else parser.unknown
         end
       end
     end
 
-    class LowL < TTYString::CSICode # leftovers:allow
-      char(/\?2004l/)
+    class LowL < TTYString::CSICode::LowH # leftovers:allow
+      char('l')
     end
 
     class LowM < TTYString::CSICode # leftovers:allow
       char 'm'
 
-      def self.arg_re
-        # 0-255
-        /(?:\d|\d\d|1\d\d|2[0-4]\d|25[0-5])?/
-      end
-
-      def self.render(renderer)
-        super if renderer.clear_style
+      def action(arg = '0', *args)
+        screen.style(args.unshift(arg))
       end
-
-      def action(*args); end
     end
 
     class S < TTYString::CSICode # leftovers:allow
-      def action(rows = 1)
-        rows.times { screen.scroll_up }
+      def action(rows = '1')
+        integer(rows)&.times { screen.scroll_up }
       end
     end
 
     class T < TTYString::CSICode # leftovers:allow
-      def action(rows = 1)
-        rows.times { screen.scroll_down }
+      def action(rows = '1')
+        integer(rows)&.times { screen.scroll_down }
       end
     end
 
     class Tilde < TTYString::CSICode # leftovers:allow
-      char(/(?:200|201)~/)
+      char('~')
+
+      def action(arg)
+        case arg
+        when '200', '201'
+          # bracketed paste
+        else
+          parser.unknown
+        end
+      end
+    end
+
+    class Unknown < TTYString::CSICode # leftovers:allow
+      char(/[@-~]/)
+
+      def action(*)
+        parser.unknown
+      end
     end
   end
 end

data/lib/tty_string/cursor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class TTYString
+module TTYString
   # point on a screen. you can move it
   class Cursor
     attr_reader :row, :col

data/lib/tty_string/null_style.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TTYString
+  class NullStyle
+    class << self
+      def new(*)
+        self
+      end
+
+      def to_s(*)
+        ''
+      end
+    end
+  end
+end

data/lib/tty_string/parser.rb

@@ -3,18 +3,21 @@
 require 'strscan'
 require_relative 'code_definitions'
 require_relative 'csi_code_definitions'
-
+require_relative 'style'
+require_relative 'null_style'
 require_relative 'screen'
 
-class TTYString
+module TTYString
   # Reads the text string a
   class Parser < StringScanner
-    attr_accessor :clear_style
-    attr_reader :screen
+    attr_reader :style_handler, :screen
+
+    def render(style:, unknown:) # rubocop:disable Metrics/MethodLength
+      @style_handler = style
+      @unknown_handler = unknown
 
-    def render
       reset
-      @screen = Screen.new
+      @screen = Screen.new(initial_style: initial_style)
       read until eos?
       screen.to_s
     end
@@ -23,14 +26,37 @@ class TTYString
       screen.cursor
     end
 
+    def unknown # rubocop:disable Metrics/MethodLength
+      case unknown_handler
+      when RAISE
+        raise(
+          UnknownCodeError,
+          if block_given?
+            yield(matched)
+          else
+            "Unknown code #{matched.inspect}"
+          end
+        )
+      end
+    end
+
+    def initial_style
+      @initial_style ||= case style_handler
+      when RENDER then Style.new(parser: self)
+      else NullStyle
+      end
+    end
+
     private
 
+    attr_reader :unknown_handler
+
     def write(string)
       screen.write(string)
     end
 
     def read
-      TTYString::Code.descendants.any? { |c| c.render(self) } || default
+      Code.descendants.any? { |c| c.render(self) } || default
     end
 
     def default

data/lib/tty_string/screen.rb

@@ -1,29 +1,38 @@
 # frozen_string_literal: true
 
 require_relative 'cursor'
+require_relative 'cell'
+require_relative 'style'
 
-class TTYString
+module TTYString
   # a grid to draw on
   class Screen
     attr_reader :cursor
 
-    def initialize
+    def initialize(initial_style:)
       @cursor = Cursor.new
       @screen = []
+      @current_style = @initial_style = initial_style
     end
 
-    def to_s
-      screen.map { |c| Array(c).map { |x| x || ' ' }.join.rstrip }.join("\n")
+    def to_s # rubocop:disable Metrics/MethodLength
+      style_context = initial_style
+      screen.map do |row|
+        Array(row).map do |cell|
+          if cell
+            value = cell.to_s(style_context: style_context)
+            style_context = cell.style
+            value
+          else
+            ' '
+          end
+        end.join.rstrip
+      end.join("\n") + current_style.to_s(context: style_context)
     end
 
-    def []=((row, col), *value)
+    def []=((row, col), value)
       screen[row] ||= []
-      screen[row][col] = value.flatten(1)
-    end
-
-    def []((row, col))
-      screen[row] ||= []
-      screen[row][col]
+      screen[row][col] = value
     end
 
     def clear_at_cursor
@@ -74,18 +83,25 @@ class TTYString
       clear_line_forward
     end
 
-    def write(string)
-      return self[cursor] if string.empty?
+    def ensure_row
+      screen[row] ||= []
+    end
 
+    def write(string)
       string.each_char do |char|
-        self[cursor] = char
+        self[cursor] = Cell.new(char, style: current_style)
         cursor.right
       end
     end
 
+    def style(style_codes)
+      self.current_style = current_style.new(style_codes)
+    end
+
     private
 
-    attr_reader :screen
+    attr_reader :screen, :initial_style
+    attr_accessor :current_style
 
     def row
       cursor.row

data/lib/tty_string/style.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module TTYString
+  class Style # rubocop:disable Metrics/ClassLength
+    attr_reader :properties
+
+    def initialize(style_codes = ['0'], parser:, properties: {})
+      @properties = properties.dup
+      @parser = parser
+      parse_code(style_codes)
+    end
+
+    def new(style_codes)
+      self.class.new(style_codes, properties: properties, parser: parser)
+    end
+
+    def to_s(context:)
+      return '' if self == context
+
+      values = properties.map { |k, v| v if context.properties[k] != v }.compact.uniq
+      return '' if values.empty?
+
+      "\e[#{values.join(';')}m"
+    end
+
+    private
+
+    attr_reader :parser
+
+    # delete then write to keep the order
+    def set(*new_properties, code)
+      new_properties.each do |property|
+        properties.delete(property)
+        properties[property] = code
+      end
+    end
+
+    def slurp_color(enum, code)
+      case (subcode = enum.next)
+      when '2' then "#{code};#{subcode};#{color_param(enum)};#{color_param(enum)};#{color_param(enum)}"
+      when '5' then "#{code};#{subcode};#{color_param(enum)}"
+      else unknown(subcode)
+      end
+    end
+
+    def color_param(enum)
+      code = enum.next
+      return unknown(code) unless code.match?(/\A\d*\z/)
+
+      code_i = code.to_i
+      return unknown(code) unless code_i < 256
+
+      code_i
+    end
+
+    def unknown(style_code)
+      parser.unknown { |code| "Unknown style code #{style_code.inspect} in #{code.inspect}" }
+    end
+
+    def parse_code(style_codes) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+      enum = style_codes.each
+      loop do # rubocop:disable Metrics/BlockLength
+        case (code = enum.next)
+        when '0'
+          set(
+            :background,
+            :blink,
+            :bold,
+            :color,
+            :conceal,
+            :dim,
+            :encircle,
+            :font,
+            :frame,
+            :ideogram_overline,
+            :ideogram_stress,
+            :ideogram_underline,
+            :italic,
+            :overline,
+            :vertical_position,
+            :proportional,
+            :reverse,
+            :strike,
+            :underline_color,
+            :underline,
+            :double_underline_or_not_bold,
+            code
+          )
+        when '1'
+          set(:bold, code)
+        when '2'
+          set(:dim, code)
+        when '3'
+          set(:italic, code)
+        when '4', '24'
+          set(:underline, code)
+        when '5', '6', '25'
+          set(:blink, code)
+        when '7', '27'
+          set(:reverse, code)
+        when '8', '28'
+          set(:conceal, code)
+        when '9', '29'
+          set(:strike, code)
+        when '10'..'20'
+          set(:font, code)
+        when '21'
+          set(:double_underline_or_not_bold, code)
+        when '22'
+          set(:bold, :dim, code)
+        when '23'
+          set(:font, :italic, code)
+        when '26', '50'
+          set(:proportional, code)
+        when '30'..'37', '39', '90'..'97'
+          set(:color, code)
+        when '38'
+          set(:color, slurp_color(enum, code))
+        when '40'..'47', '49', '100'..'107'
+          set(:background, code)
+        when '48'
+          set(:background, slurp_color(enum, code))
+        when '51'
+          set(:frame, code)
+        when '52'
+          set(:encircle, code)
+        when '53', '55'
+          set(:overline, code)
+        when '54'
+          set(:frame, :encircle, code)
+        when '58'
+          set(:underline_color, slurp_color(enum, code))
+        when '59'
+          set(:underline_color, code)
+        when '60', '61'
+          set(:ideogram_underline, code)
+        when '62', '63'
+          set(:ideogram_overline, code)
+        when '64'
+          set(:ideogram_stress, code)
+        when '65'
+          set(:ideogram_stress, :ideogram_overline, :ideogram_underline, code)
+        when '73', '74', '75'
+          set(:vertical_position, code)
+        else
+          unknown(code)
+        end
+      end
+    rescue StopIteration
+      # go until the end
+    end
+  end
+end

data/lib/tty_string/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class TTYString
-  VERSION = '1.1.1'
+module TTYString
+  VERSION = '2.0.0'
 end

data/lib/tty_string.rb

@@ -4,27 +4,33 @@ require_relative 'tty_string/parser'
 
 # Renders a string taking into ANSI escape codes and \t\r\n etc
 # Usage: TTYString.parse("This\r\e[KThat") => "That"
-class TTYString
+module TTYString
+  class Error < StandardError; end
+  class UnknownCodeError < Error; end
+
+  RENDER = :render
+  RAISE = :raise
+  DROP = :drop
+
+  UNKNOWN_OPTIONS = [RAISE, DROP].freeze
+  private_constant :UNKNOWN_OPTIONS
+  STYLE_OPTIONS = [RENDER, DROP].freeze
+  private_constant :STYLE_OPTIONS
+
   class << self
-    def parse(input_string, clear_style: true)
-      new(input_string, clear_style: clear_style).to_s
+    def parse(input_string, style: DROP, unknown: DROP) # rubocop:disable Metrics/MethodLength
+      unless STYLE_OPTIONS.include?(style)
+        raise ArgumentError, '`style:` must be either TTYString::RENDER or TTYString::DROP (default)'
+      end
+      unless UNKNOWN_OPTIONS.include?(unknown)
+        raise ArgumentError, '`unknown:` must be either TTYString::RAISE or TTYString::DROP (default)'
+      end
+
+      Parser.new(input_string).render(style: style, unknown: unknown)
     end
 
     def to_proc
       method(:parse).to_proc
     end
   end
-
-  def initialize(input_string, clear_style: true)
-    @parser = Parser.new(input_string)
-    @parser.clear_style = clear_style
-  end
-
-  def to_s
-    parser.render
-  end
-
-  private
-
-  attr_reader :clear_style, :parser
 end

data/tty_string.gemspec

@@ -30,7 +30,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.4'
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'base64'
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'fast_ignore', '>= 0.15.1'
   spec.add_development_dependency 'leftovers', '>= 0.2.0'
   spec.add_development_dependency 'pry', '~> 0.12'

metadata

@@ -1,29 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: tty_string
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Dana Sherson
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-09 00:00:00.000000000 Z
+date: 2025-01-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fast_ignore
   requirement: !ruby/object:Gem::Requirement
@@ -178,7 +191,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.1
-description: 
 email:
 - robot@dana.sh
 executables: []
@@ -190,13 +202,16 @@ files:
 - LICENSE.txt
 - README.md
 - lib/tty_string.rb
+- lib/tty_string/cell.rb
 - lib/tty_string/code.rb
 - lib/tty_string/code_definitions.rb
 - lib/tty_string/csi_code.rb
 - lib/tty_string/csi_code_definitions.rb
 - lib/tty_string/cursor.rb
+- lib/tty_string/null_style.rb
 - lib/tty_string/parser.rb
 - lib/tty_string/screen.rb
+- lib/tty_string/style.rb
 - lib/tty_string/version.rb
 - tty_string.gemspec
 homepage: https://github.com/robotdana/tty_string
@@ -206,7 +221,6 @@ metadata:
   homepage_uri: https://github.com/robotdana/tty_string
   source_code_uri: https://github.com/robotdana/tty_string
   changelog_uri: https://github.com/robotdana/tty_string/blob/main/CHANGELOG.md
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -221,8 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Render a string using ANSI TTY codes
 test_files: []