tui-td 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eb2dc4db4af2ddbcbe377f8a3d6bddf8e1a45f3c78c85a25d8480d1e740e9f7
-  data.tar.gz: 31a65006ceb299ba4487446932bf74305ecb92d4241288f82d7d11a0283e6bf6
+  metadata.gz: 07ef26981840d9171eb2082a6c638c6f43869c05ffdb11c7fff857b058ce87e7
+  data.tar.gz: 47d8dd453c1a393ad2f838b67226f92d50b97d5647fb775e36e95f9e381105e9
 SHA512:
-  metadata.gz: 706d849d8c35380fabf149bcf6cee5441d92a71b228d7ac4bc0bbba3852be4443496d9d6ae79afd15daa5217b9ede798d6ce2d15dee2cbeb5f6a0901b5269722
-  data.tar.gz: 9595ce52cd78959dfb49f314d3272d6cf2c065dd215467e204c862b48da2a88525ab8a9dad0ab98ccdd7b7fc142e700eab4ca65ea6a8c2b90d53aefbe8eca922
+  metadata.gz: 94ce617f9370428126bf1b565ca67787a455f6d64cd6273fc69c2cecc83ca293b07272cf3f227787ba4e56ae4bf914447752689115979d1d19863fd5d1e17545
+  data.tar.gz: fdc72eaff712400c026469730cce5fe88daf65b2cca7fa25a071d79a1a2d53b648f5cd80dc8f2b11fe952ce1c9b4aeed9dde5e372715c22d877487d1db25cb52

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # CHANGELOG
 
+# CHANGELOG
+
+## 0.2.11
+
+- Add RuboCop (rubocop-rake, rubocop-rspec), Reek, and Bundler-Audit linters
+- Pre-commit hook runs all three checks automatically
+- Fix dead code after `raise` in test_runner.rb
+- Rename `is_cursor?` to `cursor_at?` in html_renderer.rb
+- Merge duplicate `describe "#find_text"` blocks in state_spec.rb
+- Fix ANSI parser `FormatStringToken` warnings
+
 ## 0.2.10
 
 - Three new MCP tools: `tui_wait_for_exit` (wait for process to end), `tui_exit_status` (get exit code), `tui_find_text` (search terminal state for text/regex matches)

data/lib/tui_td/ansi_parser.rb

@@ -12,14 +12,15 @@ module TUITD
   #
   # Output: {rows: [[{char, fg, bg, bold, italic, underline}]], cursor: {row, col}, size: {rows, cols}}
   #
+  # rubocop:disable Metrics/ModuleLength
   module ANSIParser
     SGR_COLORS = {
-      0  => :reset,
-      1  => :bold,
-      3  => :italic,
-      4  => :underline,
-      5  => :blink,
-      7  => :reverse,
+      0 => :reset,
+      1 => :bold,
+      3 => :italic,
+      4 => :underline,
+      5 => :blink,
+      7 => :reverse,
       22 => :normal,
       23 => :no_italic,
       24 => :no_underline,
@@ -62,16 +63,16 @@ module TUITD
     }.freeze
 
     SGR_16_TO_NAME = {
-      0  => "black",
-      1  => "red",
-      2  => "green",
-      3  => "yellow",
-      4  => "blue",
-      5  => "magenta",
-      6  => "cyan",
-      7  => "white",
-      8  => "bright_black",
-      9  => "bright_red",
+      0 => "black",
+      1 => "red",
+      2 => "green",
+      3 => "yellow",
+      4 => "blue",
+      5 => "magenta",
+      6 => "cyan",
+      7 => "white",
+      8 => "bright_black",
+      9 => "bright_red",
       10 => "bright_green",
       11 => "bright_yellow",
       12 => "bright_blue",
@@ -81,40 +82,41 @@ module TUITD
     }.freeze
 
     DEC_MAP = {
-      '`' => '◆',
-      'a' => '▒',
-      'b' => "\u2409",
-      'c' => "\u240C",
-      'd' => "\u240D",
-      'e' => "\u240A",
-      'f' => '°',
-      'g' => '±',
-      'h' => "\u2424",
-      'i' => "\u240B",
-      'j' => '┘',
-      'k' => '┐',
-      'l' => '┌',
-      'm' => '└',
-      'n' => '┼',
-      'o' => '⎺',
-      'p' => '⎻',
-      'q' => '─',
-      'r' => '⎼',
-      's' => '⎽',
-      't' => '├',
-      'u' => '┤',
-      'v' => '┴',
-      'w' => '┬',
-      'x' => '│',
-      'y' => '≤',
-      'z' => '≥',
-      '{' => 'π',
-      '|' => '≠',
-      '}' => '£',
-      '~' => '·'
+      "`" => "◆",
+      "a" => "▒",
+      "b" => "\u2409",
+      "c" => "\u240C",
+      "d" => "\u240D",
+      "e" => "\u240A",
+      "f" => "°",
+      "g" => "±",
+      "h" => "\u2424",
+      "i" => "\u240B",
+      "j" => "┘",
+      "k" => "┐",
+      "l" => "┌",
+      "m" => "└",
+      "n" => "┼",
+      "o" => "⎺",
+      "p" => "⎻",
+      "q" => "─",
+      "r" => "⎼",
+      "s" => "⎽",
+      "t" => "├",
+      "u" => "┤",
+      "v" => "┴",
+      "w" => "┬",
+      "x" => "│",
+      "y" => "≤",
+      "z" => "≥",
+      "{" => "π",
+      "|" => "≠",
+      "}" => "£",
+      "~" => "·",
     }.freeze
 
     # Parse raw terminal output into a structured state Hash
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockNesting
     def self.parse(raw, rows = 40, cols = 120)
       grid = Array.new(rows) do
         Array.new(cols) { default_cell.dup }
@@ -156,7 +158,7 @@ module TUITD
         if processed[i] == "\e" && processed[i + 1] == "["
           # Find end of CSI sequence
           j = i + 2
-          j += 1 while j < processed.length && !processed[j].match?(/[A-HJ-KP-SX@\`fhlmnRrsuq]/)
+          j += 1 while j < processed.length && !processed[j].match?(/[A-HJ-KP-SX@`fhlmnRrsuq]/)
           seq = processed[i..j]
 
           dsr, new_saved, action = _apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
@@ -211,27 +213,19 @@ module TUITD
             end
           end
 
-          if action.key?(:cursor_visible)
-            cursor_visible = action[:cursor_visible]
-          end
+          cursor_visible = action[:cursor_visible] if action.key?(:cursor_visible)
 
-          if action.key?(:cursor_style)
-            cursor_style = action[:cursor_style]
-          end
+          cursor_style = action[:cursor_style] if action.key?(:cursor_style)
 
-          if action.key?(:mouse_mode)
-            mouse_mode = action[:mouse_mode]
-          end
+          mouse_mode = action[:mouse_mode] if action.key?(:mouse_mode)
 
-          if action.key?(:mouse_format)
-            mouse_format = action[:mouse_format]
-          end
+          mouse_format = action[:mouse_format] if action.key?(:mouse_format)
 
           i = j + 1
-        elsif processed[i] == "\n" || processed[i] == "\r\n"
+        elsif ["\n", "\r\n"].include?(processed[i])
           cursor[:row] += 1
           cursor[:col] = 0
-          i += processed[i..i + 1] == "\r\n" ? 2 : 1
+          i += processed[i..(i + 1)] == "\r\n" ? 2 : 1
         elsif processed[i] == "\r"
           cursor[:col] = 0
           i += 1
@@ -240,7 +234,7 @@ module TUITD
           cursor[:col] = cols - 1 if cursor[:col] >= cols
           i += 1
         elsif processed[i] == "\b"
-          cursor[:col] -= 1 if cursor[:col] > 0
+          cursor[:col] -= 1 if cursor[:col].positive?
           i += 1
         elsif processed[i] == "\a"
           # Bell — ignore
@@ -270,13 +264,13 @@ module TUITD
               cursor[:col] = saved_cursor[:col]
             end
             i += 2
-          elsif processed[i + 1] == "(" && (processed[i + 2] == "0" || processed[i + 2] == "B")
+          elsif processed[i + 1] == "(" && %w[0 B].include?(processed[i + 2])
             g0_charset = (processed[i + 2] == "0" ? :dec : :ascii)
             i += 3
-          elsif processed[i + 1] == ")" && (processed[i + 2] == "0" || processed[i + 2] == "B")
+          elsif processed[i + 1] == ")" && %w[0 B].include?(processed[i + 2])
             g1_charset = (processed[i + 2] == "0" ? :dec : :ascii)
             i += 3
-          elsif processed[i + 1] && processed[i + 1].match?(/[()*+\-.\/]/)
+          elsif processed[i + 1]&.match?(%r{[()*+\-./]})
             # Other ISO 2022 charset sequences (e.g. G2/G3 or other charsets)
             i += 3
           else
@@ -288,16 +282,14 @@ module TUITD
             cell = grid[cursor[:row]][cursor[:col]]
             current_charset = (active_charset == :g1 ? g1_charset : g0_charset)
             mapped_char = char
-            if current_charset == :dec && DEC_MAP.key?(char)
-              mapped_char = DEC_MAP[char]
-            end
+            mapped_char = DEC_MAP[char] if current_charset == :dec && DEC_MAP.key?(char)
             cell[:char] = mapped_char
             cell.merge!(attrs)
             cursor[:col] += 1
             cursor[:col] = cols - 1 if cursor[:col] >= cols
           end
           i += char_len
-        else
+        else # rubocop:disable Lint/DuplicateBranch
           i += 1
         end
 
@@ -305,19 +297,19 @@ module TUITD
         region_top = scroll_region[:top]
         region_bottom = scroll_region[:bottom]
 
-        if cursor[:row] > region_bottom
-          scroll_lines = [cursor[:row] - region_bottom, rows].min
-          # Shift lines within the scroll region up
-          (region_top..(region_bottom - scroll_lines)).each do |ri|
-            src = ri + scroll_lines
-            grid[ri] = src <= region_bottom ? grid[src] : Array.new(cols) { default_cell.dup }
-          end
-          # Fill bottom of scroll region with blank lines
-          ((region_bottom - scroll_lines + 1)..region_bottom).each do |ri|
-            grid[ri] = Array.new(cols) { default_cell.dup }
-          end
-          cursor[:row] = region_bottom
+        next unless cursor[:row] > region_bottom
+
+        scroll_lines = [cursor[:row] - region_bottom, rows].min
+        # Shift lines within the scroll region up
+        (region_top..(region_bottom - scroll_lines)).each do |ri|
+          src = ri + scroll_lines
+          grid[ri] = src <= region_bottom ? grid[src] : Array.new(cols) { default_cell.dup }
         end
+        # Fill bottom of scroll region with blank lines
+        ((region_bottom - scroll_lines + 1)..region_bottom).each do |ri|
+          grid[ri] = Array.new(cols) { default_cell.dup }
+        end
+        cursor[:row] = region_bottom
       end
 
       {
@@ -326,21 +318,23 @@ module TUITD
           row: cursor[:row],
           col: cursor[:col],
           visible: cursor_visible,
-          style: cursor_style
+          style: cursor_style,
         },
         rows: grid,
         pending_dsr: pending_dsr,
         cursor_visible: cursor_visible,
         cursor_style: cursor_style,
         mouse_mode: mouse_mode,
-        mouse_format: mouse_format
+        mouse_format: mouse_format,
       }
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockNesting
 
     # Rebuild ANSI output from a state hash (for rendering/screenshot)
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def self.build_frame(state)
       rows = state.dig(:size, :rows) || state["size"]["rows"]
-      cols = state.dig(:size, :cols) || state["size"]["cols"]
+      state.dig(:size, :cols) || state["size"]["cols"]
       grid = state[:rows] || state["rows"]
       cursor = state[:cursor] || state["cursor"]
       mouse_mode = state[:mouse_mode] || state["mouse_mode"] || :none
@@ -351,7 +345,7 @@ module TUITD
       out << "\e[2J\e[H"
 
       grid.each_with_index do |row, ri|
-        row.each_with_index do |cell, ci|
+        row.each_with_index do |cell, _ci|
           char = cell[:char] || cell["char"] || " "
           fg = cell[:fg] || cell["fg"] || "default"
           bg = cell[:bg] || cell["bg"] || "default"
@@ -380,9 +374,7 @@ module TUITD
 
       # Reconstruct cursor visibility
       cursor_vis = true
-      if cursor.is_a?(Hash)
-        cursor_vis = cursor[:visible] != false && cursor["visible"] != false
-      end
+      cursor_vis = cursor[:visible] != false && cursor["visible"] != false if cursor.is_a?(Hash)
       out << (cursor_vis ? "\e[?25h" : "\e[?25l")
 
       # Reconstruct cursor style
@@ -392,30 +384,33 @@ module TUITD
       end
 
       # Reconstruct mouse mode and format
-      if mouse_mode == :normal
-        out << "\e[?1000h"
-      elsif mouse_mode == :drag
-        out << "\e[?1002h"
-      elsif mouse_mode == :all
-        out << "\e[?1003h"
-      else
-        out << "\e[?1000l\e[?1002l\e[?1003l"
-      end
-
-      if mouse_format == :sgr
-        out << "\e[?1006h"
-      else
-        out << "\e[?1006l"
-      end
+      out << case mouse_mode
+             when :normal
+               "\e[?1000h"
+             when :drag
+               "\e[?1002h"
+             when :all
+               "\e[?1003h"
+             else
+               "\e[?1000l\e[?1002l\e[?1003l"
+             end
+
+      out << if mouse_format == :sgr
+               "\e[?1006h"
+             else
+               "\e[?1006l"
+             end
 
       out << "\e[0m"
       out
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ParameterLists
     def self._apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
       # Strip leading escape char if present
       cleaned = seq.sub(/^\e/, "")
-      match = cleaned.match(/^\[(\??)([\d;]*)( ?)([A-HJ-KP-SX@\`fhlmnRrsuq])$/)
+      match = cleaned.match(/^\[(\??)([\d;]*)( ?)([A-HJ-KP-SX@`fhlmnRrsuq])$/)
       return [false, nil, {}] unless match
 
       is_private = (match[1] == "?")
@@ -431,19 +426,19 @@ module TUITD
         _apply_sgr(params, attrs)
       when "A" # CUU — Cursor Up
         n = params[0] || 1
-        n = 1 if n == 0
+        n = 1 if n.zero?
         cursor[:row] = [cursor[:row] - n, 0].max
       when "B" # CUD — Cursor Down
         n = params[0] || 1
-        n = 1 if n == 0
+        n = 1 if n.zero?
         cursor[:row] = [cursor[:row] + n, rows - 1].min
       when "C" # CUF — Cursor Forward
         n = params[0] || 1
-        n = 1 if n == 0
+        n = 1 if n.zero?
         cursor[:col] = [cursor[:col] + n, cols - 1].min
       when "D" # CUB — Cursor Back
         n = params[0] || 1
-        n = 1 if n == 0
+        n = 1 if n.zero?
         cursor[:col] = [cursor[:col] - n, 0].max
       when "H", "f" # CUP — Cursor Position
         r = (params[0] || 1) - 1
@@ -474,6 +469,7 @@ module TUITD
         n = params[0] || 1
         n.times do |i|
           next unless cursor[:row] < rows && cursor[:col] + i < cols
+
           grid[cursor[:row]][cursor[:col] + i][:char] = " "
         end
       when "s" # DECSC — Save Cursor (CSI variant)
@@ -546,9 +542,14 @@ module TUITD
 
       [false, new_saved, action]
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ParameterLists
 
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def self._apply_sgr(params, attrs)
-      return attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false) if params.empty? || params == [0]
+      if params.empty? || params == [0]
+        return attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false,
+                            blink: false,)
+      end
 
       i = 0
       while i < params.length
@@ -572,11 +573,9 @@ module TUITD
           attrs[:underline] = false
         when 25
           attrs[:blink] = false
-        when 7
+        when 7, 27
           # Reverse — swap fg and bg
           attrs[:fg], attrs[:bg] = attrs[:bg], attrs[:fg]
-        when 27
-          attrs[:fg], attrs[:bg] = attrs[:bg], attrs[:fg]
         when 30..37
           attrs[:fg] = SGR_16_TO_NAME[p - 30] || "color#{p - 30}"
         when 38
@@ -586,8 +585,10 @@ module TUITD
             attrs[:fg] = "color#{color}"
             i += 2
           elsif params[i + 1] == 2
-            r, g, b = params[i + 2], params[i + 3], params[i + 4]
-            attrs[:fg] = format("#%02x%02x%02x", r, g, b)
+            r = params[i + 2]
+            g = params[i + 3]
+            b = params[i + 4]
+            attrs[:fg] = format("#%<r>02x%<g>02x%<b>02x", r: r, g: g, b: b)
             i += 4
           end
         when 39
@@ -601,8 +602,10 @@ module TUITD
             attrs[:bg] = "color#{color}"
             i += 2
           elsif params[i + 1] == 2
-            r, g, b = params[i + 2], params[i + 3], params[i + 4]
-            attrs[:bg] = format("#%02x%02x%02x", r, g, b)
+            r = params[i + 2]
+            g = params[i + 3]
+            b = params[i + 4]
+            attrs[:bg] = format("#%<r>02x%<g>02x%<b>02x", r: r, g: g, b: b)
             i += 4
           end
         when 49
@@ -615,6 +618,7 @@ module TUITD
         i += 1
       end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
     def self._erase_down(cursor, grid, rows, cols)
       r = cursor[:row]
@@ -654,7 +658,7 @@ module TUITD
       (c...cols).each { |ci| grid[r][ci][:char] = " " if r < grid.length }
     end
 
-    def self._erase_line_left(cursor, grid, cols)
+    def self._erase_line_left(cursor, grid, _cols)
       r = cursor[:row]
       c = cursor[:col]
       (0..c).each { |ci| grid[r][ci][:char] = " " if r < grid.length }
@@ -665,23 +669,23 @@ module TUITD
       cols.times { |ci| grid[r][ci][:char] = " " if r < grid.length }
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def self._color_code(name, prefix)
       case name
       when "default" then nil
       when /^#([0-9a-fA-F]{6})$/
-        r = $1[0..1].to_i(16)
-        g = $1[2..3].to_i(16)
-        b = $1[4..5].to_i(16)
+        r = ::Regexp.last_match(1)[0..1].to_i(16)
+        g = ::Regexp.last_match(1)[2..3].to_i(16)
+        b = ::Regexp.last_match(1)[4..5].to_i(16)
         "#{prefix};2;#{r};#{g};#{b}"
       when /^(bright_)?(.+)$/
-        base_name = $2
+        base_name = ::Regexp.last_match(2)
         index = SGR_16_TO_NAME.key(base_name)
-        index += 8 if $1 && index && index < 8
+        index += 8 if ::Regexp.last_match(1) && index && index < 8
         index ? "#{prefix};5;#{index}" : nil
-      else
-        nil
       end
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def self.default_cell
       { char: " ", fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false }
@@ -689,26 +693,28 @@ module TUITD
 
     # Extract a single UTF-8 character at position i in a binary string.
     # Returns [char_string, byte_length] or nil if the byte is not printable/valid.
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Naming/MethodParameterName
     def self._utf8_char_at(str, i)
       byte = str.getbyte(i)
       return nil unless byte
 
       if byte < 0x80
         # Single-byte ASCII
-        return nil unless byte >= 0x20  # only printable, skip control chars
+        return nil unless byte >= 0x20 # only printable, skip control chars
+
         return [byte.chr, 1]
       end
 
       # Multi-byte UTF-8
       len = if byte & 0xE0 == 0xC0
               2
-      elsif byte & 0xF0 == 0xE0
+            elsif byte & 0xF0 == 0xE0
               3
-      elsif byte & 0xF8 == 0xF0
+            elsif byte & 0xF8 == 0xF0
               4
-      else
-              return nil  # continuation byte or invalid — let main loop advance
-      end
+            else
+              return nil # continuation byte or invalid — let main loop advance
+            end
       return nil if i + len > str.bytesize
 
       bytes = str.byteslice(i, len)
@@ -719,5 +725,7 @@ module TUITD
     rescue StandardError
       nil
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Naming/MethodParameterName
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/tui_td/ansi_utils.rb

@@ -5,22 +5,22 @@ module TUITD
   # Used by Screenshot, HtmlRenderer, and other color-aware renderers.
   module ANSIUtils
     ANSI_RGB = {
-      "black"         => [0x00, 0x00, 0x00],
-      "red"           => [0xAA, 0x00, 0x00],
-      "green"         => [0x00, 0xAA, 0x00],
-      "yellow"        => [0xAA, 0x55, 0x00],
-      "blue"          => [0x00, 0x00, 0xAA],
-      "magenta"       => [0xAA, 0x00, 0xAA],
-      "cyan"          => [0x00, 0xAA, 0xAA],
-      "white"         => [0xAA, 0xAA, 0xAA],
-      "bright_black"  => [0x55, 0x55, 0x55],
-      "bright_red"    => [0xFF, 0x55, 0x55],
-      "bright_green"  => [0x55, 0xFF, 0x55],
+      "black" => [0x00, 0x00, 0x00],
+      "red" => [0xAA, 0x00, 0x00],
+      "green" => [0x00, 0xAA, 0x00],
+      "yellow" => [0xAA, 0x55, 0x00],
+      "blue" => [0x00, 0x00, 0xAA],
+      "magenta" => [0xAA, 0x00, 0xAA],
+      "cyan" => [0x00, 0xAA, 0xAA],
+      "white" => [0xAA, 0xAA, 0xAA],
+      "bright_black" => [0x55, 0x55, 0x55],
+      "bright_red" => [0xFF, 0x55, 0x55],
+      "bright_green" => [0x55, 0xFF, 0x55],
       "bright_yellow" => [0xFF, 0xFF, 0x55],
-      "bright_blue"   => [0x55, 0x55, 0xFF],
-      "bright_magenta"=> [0xFF, 0x55, 0xFF],
-      "bright_cyan"   => [0x55, 0xFF, 0xFF],
-      "bright_white"  => [0xFF, 0xFF, 0xFF],
+      "bright_blue" => [0x55, 0x55, 0xFF],
+      "bright_magenta" => [0xFF, 0x55, 0xFF],
+      "bright_cyan" => [0x55, 0xFF, 0xFF],
+      "bright_white" => [0xFF, 0xFF, 0xFF],
     }.freeze
 
     CUBE = [0x00, 0x5F, 0x87, 0xAF, 0xD7, 0xFF].freeze
@@ -39,17 +39,18 @@ module TUITD
       when "default"
         fallback
       when /^#([0-9a-fA-F]{6})$/
-        [$1[0..1].to_i(16), $1[2..3].to_i(16), $1[4..5].to_i(16)]
+        [::Regexp.last_match(1)[0..1].to_i(16), ::Regexp.last_match(1)[2..3].to_i(16),
+         ::Regexp.last_match(1)[4..5].to_i(16),]
       when /\Acolor(\d+)\z/
-        xterm_256($1.to_i)
+        xterm_256(::Regexp.last_match(1).to_i)
       when /\Abright_(.+)\z/
         ANSI_RGB[name] || fallback
-      else
+      else # rubocop:disable Lint/DuplicateBranch
         ANSI_RGB[name] || fallback
       end
     end
 
-    def xterm_256(index)
+    def xterm_256(index) # rubocop:disable Naming/VariableNumber
       if index < 16
         name = ANSI_INDEX[index]
         ANSI_RGB[name] || DEFAULT_FG
@@ -59,7 +60,7 @@ module TUITD
         b = CUBE[(index - 16) % 6]
         [r, g, b]
       else
-        v = 8 + (index - 232) * 10
+        v = 8 + ((index - 232) * 10)
         [v, v, v]
       end
     end
@@ -67,6 +68,7 @@ module TUITD
     def _dig(hash, *keys)
       keys.each do |k|
         return nil unless hash
+
         hash = hash[k] || hash[k.to_s]
       end
       hash

data/lib/tui_td/cairo_renderer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/ParameterLists
+
 module TUITD
   module CairoRenderer
     CELL_W = 8
@@ -76,9 +78,9 @@ module TUITD
           CELL_W.times do |dx|
             sum = 0
             scale.times do |sy|
-              row_off = (dy * scale + sy) * stride
+              row_off = ((dy * scale) + sy) * stride
               scale.times do |sx|
-                sum += data.getbyte(row_off + (dx * scale + sx) * 4 + 3)
+                sum += data.getbyte(row_off + (((dx * scale) + sx) * 4) + 3)
               end
             end
             alpha_grid[dy][dx] = sum / scale_sq
@@ -107,3 +109,4 @@ module TUITD
     end
   end
 end
+# rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/ParameterLists