tui-td 0.2.10 → 0.2.12

data/lib/tui_td/screenshot.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/BlockNesting, Metrics/ParameterLists, Metrics/ClassLength, Metrics/CollectionLiteralLength
+
 require "chunky_png"
 require_relative "ansi_utils"
 require_relative "cairo_renderer"
@@ -200,7 +202,7 @@ module TUITD
       "╧" => [true, false, true, true, :double],
       "╨" => [true, false, true, true, :double],
       "╪" => [true, true, true, true, :double],
-      "╫" => [true, true, true, true, :double]
+      "╫" => [true, true, true, true, :double],
     }.freeze
 
     private_constant :FONT
@@ -219,8 +221,10 @@ module TUITD
 
       @grid.each_with_index do |row, ri|
         next unless row
+
         row.each_with_index do |cell, ci|
           next unless cell
+
           render_cell(image, ri, ci, cell)
         end
       end
@@ -256,15 +260,15 @@ module TUITD
       end
 
       char_ord = char.ord
-      if char_ord == 10095 # '❯'
+      if char_ord == 10_095 # '❯'
         draw_chevron(image, px, py, fg_rgb)
         draw_underline(image, px, py, CELL_W, fg_rgb) if underline
         return
-      elsif char_ord == 9210 || char_ord == 9679 # '⏺' or '●'
+      elsif [9210, 9679].include?(char_ord) # '⏺' or '●'
         draw_circle(image, px, py, fg_rgb)
         draw_underline(image, px, py, CELL_W, fg_rgb) if underline
         return
-      elsif char_ord >= 0x2800 && char_ord <= 0x28ff # Braille spinner
+      elsif char_ord.between?(0x2800, 0x28ff) # Braille spinner
         draw_braille(image, px, py, char, fg_rgb)
         draw_underline(image, px, py, CELL_W, fg_rgb) if underline
         return
@@ -399,7 +403,7 @@ module TUITD
 
     def glyph_rows(char)
       idx = (char.ord - 32) * 16
-      return nil if idx < 0 || idx + 15 >= FONT.length
+      return nil if idx.negative? || idx + 15 >= FONT.length
 
       FONT[idx, 16]
     end
@@ -408,7 +412,7 @@ module TUITD
       color = ChunkyPNG::Color.rgb(*fg_rgb)
 
       rows.each_with_index do |byte, dy|
-        next if byte == 0
+        next if byte.zero?
 
         slant = italic ? dy / 8 : 0
 
@@ -429,7 +433,7 @@ module TUITD
 
     def box_drawing?(char)
       char_ord = char.ord
-      char_ord >= 0x2500 && char_ord <= 0x257F
+      char_ord.between?(0x2500, 0x257F)
     end
 
     def draw_box_character(image, px, py, char, fg_rgb)
@@ -438,10 +442,18 @@ module TUITD
       unless config
         char_ord = char.ord
         if [0x2500, 0x2501, 0x2504, 0x2505, 0x2508, 0x2509, 0x254c, 0x254d, 0x2550].include?(char_ord)
-          style = [0x2501, 0x2505, 0x2509, 0x254d].include?(char_ord) ? :heavy : (char_ord == 0x2550 ? :double : :light)
+          style = if [0x2501, 0x2505, 0x2509, 0x254d].include?(char_ord)
+                    :heavy
+                  else
+                    (char_ord == 0x2550 ? :double : :light)
+                  end
           config = [false, false, true, true, style]
         elsif [0x2502, 0x2503, 0x2506, 0x2507, 0x250a, 0x250b, 0x254e, 0x254f, 0x2551].include?(char_ord)
-          style = [0x2503, 0x2507, 0x250b, 0x254f].include?(char_ord) ? :heavy : (char_ord == 0x2551 ? :double : :light)
+          style = if [0x2503, 0x2507, 0x250b, 0x254f].include?(char_ord)
+                    :heavy
+                  else
+                    (char_ord == 0x2551 ? :double : :light)
+                  end
           config = [true, true, false, false, style]
         else
           config = [true, true, true, true, :light]
@@ -454,24 +466,31 @@ module TUITD
 
       color = ChunkyPNG::Color.rgb(*fg_rgb)
 
-      if style == :double
+      case style
+      when :double
         if left
-          (px..(cx + 2)).each { |x| image[x, py + 6] = color }
-          (px..(cx + 2)).each { |x| image[x, py + 10] = color }
+          (px..(cx + 2)).each do |x|
+            image[x, py + 6] = color
+            image[x, py + 10] = color
+          end
         end
         if right
           ((cx - 2)..(px + 7)).each { |x| image[x, py + 6] = color }
           ((cx - 2)..(px + 10)).each { |x| image[x, py + 10] = color }
         end
         if up
-          (py..(cy + 2)).each { |y| image[px + 2, y] = color }
-          (py..(cy + 2)).each { |y| image[px + 6, y] = color }
+          (py..(cy + 2)).each do |y|
+            image[px + 2, y] = color
+            image[px + 6, y] = color
+          end
         end
         if down
-          ((cy - 2)..(py + 15)).each { |y| image[px + 2, y] = color }
-          ((cy - 2)..(py + 15)).each { |y| image[px + 6, y] = color }
+          ((cy - 2)..(py + 15)).each do |y|
+            image[px + 2, y] = color
+            image[px + 6, y] = color
+          end
         end
-      elsif style == :heavy
+      when :heavy
         if left
           (px..cx).each do |x|
             image[x, cy - 1] = color
@@ -500,42 +519,34 @@ module TUITD
             image[cx + 1, y] = color
           end
         end
-      elsif style == :light_rounded
+      when :light_rounded
         case char
         when "╭"
-          (px + 5..px + 7).each { |x| image[x, py + 8] = color }
-          (py + 10..py + 15).each { |y| image[px + 4, y] = color }
+          ((px + 5)..(px + 7)).each { |x| image[x, py + 8] = color }
+          ((py + 10)..(py + 15)).each { |y| image[px + 4, y] = color }
           image[px + 4, py + 9] = color
           image[px + 5, py + 9] = color
         when "╮"
-          (px..px + 3).each { |x| image[x, py + 8] = color }
-          (py + 10..py + 15).each { |y| image[px + 4, y] = color }
+          (px..(px + 3)).each { |x| image[x, py + 8] = color }
+          ((py + 10)..(py + 15)).each { |y| image[px + 4, y] = color }
           image[px + 4, py + 9] = color
           image[px + 3, py + 9] = color
         when "╯"
-          (px..px + 3).each { |x| image[x, py + 8] = color }
-          (py..py + 6).each { |y| image[px + 4, y] = color }
+          (px..(px + 3)).each { |x| image[x, py + 8] = color }
+          (py..(py + 6)).each { |y| image[px + 4, y] = color }
           image[px + 4, py + 7] = color
           image[px + 3, py + 7] = color
         when "╰"
-          (px + 5..px + 7).each { |x| image[x, py + 8] = color }
-          (py..py + 6).each { |y| image[px + 4, y] = color }
+          ((px + 5)..(px + 7)).each { |x| image[x, py + 8] = color }
+          (py..(py + 6)).each { |y| image[px + 4, y] = color }
           image[px + 4, py + 7] = color
           image[px + 5, py + 7] = color
         end
       else # :light
-        if left
-          (px..cx).each { |x| image[x, cy] = color }
-        end
-        if right
-          (cx..(px + 7)).each { |x| image[x, cy] = color }
-        end
-        if up
-          (py..cy).each { |y| image[cx, y] = color }
-        end
-        if down
-          (cy..(py + 15)).each { |y| image[cx, y] = color }
-        end
+        (px..cx).each { |x| image[x, cy] = color } if left
+        (cx..(px + 7)).each { |x| image[x, cy] = color } if right
+        (py..cy).each { |y| image[cx, y] = color } if up
+        (cy..(py + 15)).each { |y| image[cx, y] = color } if down
       end
     end
 
@@ -551,7 +562,7 @@ module TUITD
       ri = cursor_info[:row] || cursor_info["row"] || 0
       ci = cursor_info[:col] || cursor_info["col"] || 0
 
-      return if ri < 0 || ri >= @rows || ci < 0 || ci >= @cols
+      return if ri.negative? || ri >= @rows || ci.negative? || ci >= @cols
 
       style_val = @state[:cursor_style] || cursor_info[:style] || cursor_info["style"] || 1
 
@@ -568,6 +579,7 @@ module TUITD
             x = px + dx
             y = py + dy
             next if x >= image.width || y >= image.height
+
             original_color = image[x, y]
             r = 255 - ChunkyPNG::Color.r(original_color)
             g = 255 - ChunkyPNG::Color.g(original_color)
@@ -579,9 +591,11 @@ module TUITD
         2.times do |h_offset|
           y = py + CELL_H - 1 - h_offset
           next if y >= image.height
+
           CELL_W.times do |dx|
             x = px + dx
             next if x >= image.width
+
             image[x, y] = color
           end
         end
@@ -589,9 +603,11 @@ module TUITD
         2.times do |w_offset|
           x = px + w_offset
           next if x >= image.width
+
           CELL_H.times do |dy|
             y = py + dy
             next if y >= image.height
+
             image[x, y] = color
           end
         end
@@ -603,7 +619,7 @@ module TUITD
       (0..3).each do |i|
         image[px + 2 + i, py + 4 + i] = color
         image[px + 3 + i, py + 4 + i] = color # bold/thick chevron
-        
+
         image[px + 5 - i, py + 8 + i] = color
         image[px + 6 - i, py + 8 + i] = color # bold/thick chevron
       end
@@ -623,6 +639,7 @@ module TUITD
           x = cx + dx
           y = cy + dy
           next if x < px || x >= px + CELL_W || y < py || y >= py + CELL_H
+
           image[x, y] = color
         end
       end
@@ -639,17 +656,18 @@ module TUITD
         [5, 6],  # Dot 5
         [5, 9],  # Dot 6
         [2, 12], # Dot 7
-        [5, 12]  # Dot 8
+        [5, 12], # Dot 8
       ]
       dot_coords.each_with_index do |(dx, dy), idx|
-        if (mask & (1 << idx)) != 0
-          2.times do |ddy|
-            2.times do |ddx|
-              x = px + dx + ddx
-              y = py + dy + ddy
-              next if x >= image.width || y >= image.height
-              image[x, y] = color
-            end
+        next unless mask.anybits?(1 << idx)
+
+        2.times do |ddy|
+          2.times do |ddx|
+            x = px + dx + ddx
+            y = py + dy + ddy
+            next if x >= image.width || y >= image.height
+
+            image[x, y] = color
           end
         end
       end
@@ -659,7 +677,7 @@ module TUITD
       color = ChunkyPNG::Color.rgb(*fg_rgb)
       (5..8).each do |dy|
         width = dy - 5
-        (4 - width..4 + width).each do |dx|
+        ((4 - width)..(4 + width)).each do |dx|
           image[px + dx, py + dy] = color
         end
       end
@@ -669,7 +687,7 @@ module TUITD
       color = ChunkyPNG::Color.rgb(*fg_rgb)
       (5..8).each do |dy|
         width = 8 - dy
-        (4 - width..4 + width).each do |dx|
+        ((4 - width)..(4 + width)).each do |dx|
           image[px + dx, py + dy] = color
         end
       end
@@ -874,6 +892,6 @@ module TUITD
       image[px + 3, py + 8] = color
       image[px + 4, py + 8] = color
     end
-
   end
 end
+# rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/BlockNesting, Metrics/ParameterLists, Metrics/ClassLength, Metrics/CollectionLiteralLength

data/lib/tui_td/state.rb

@@ -1,121 +1,7 @@
 # frozen_string_literal: true
 
-module TUITD
-  # Represents the parsed state of a terminal screen.
-  # Provides high-level query methods for AI consumption.
-  class State
-    attr_reader :rows, :cols, :grid, :cursor, :cursor_visible, :cursor_style, :mouse_mode, :mouse_format
-
-    def initialize(data)
-      raise ArgumentError, "State data must include :size key" unless data[:size]
-      raise ArgumentError, "State data must include :rows key" unless data[:rows]
-
-      @rows = data[:size][:rows]
-      @cols = data[:size][:cols]
-      @grid = data[:rows]
-      @cursor = data[:cursor]
-
-      cursor_info = data[:cursor].is_a?(Hash) ? data[:cursor] : {}
-      @cursor_visible = data.key?(:cursor_visible) ? data[:cursor_visible] : (cursor_info[:visible] != false)
-      @cursor_style = data.key?(:cursor_style) ? data[:cursor_style] : (cursor_info[:style] || 1)
-
-      @mouse_mode = data[:mouse_mode] || :none
-      @mouse_format = data[:mouse_format] || :normal
-    end
-
-    # Get plain text of the entire terminal (no ANSI)
-    def plain_text
-      @grid.map { |row| row.map { |c| c[:char] }.join.rstrip }.join("\n")
-    end
-
-    # Get text at a specific position
-    def text_at(row, col, length = @cols - col)
-      return "" if row >= @rows || col >= @cols
-      @grid[row][col, length].map { |c| c[:char] }.join
-    end
-
-    # Search for text across the entire terminal
-    def find_text(pattern)
-      results = []
-      @grid.each_with_index do |row, ri|
-        text = row.map { |c| c[:char] }.join
-        pos = 0
-        while (match = text.index(pattern, pos))
-          results << { row: ri, col: match, text: pattern, full_line: text }
-          pos = match + 1
-        end
-      end
-      results
-    end
-
-    # Get the color at a specific cell
-    def foreground_at(row, col)
-      return nil if row >= @rows || col >= @cols
-      @grid[row][col][:fg]
-    end
-
-    def background_at(row, col)
-      return nil if row >= @rows || col >= @cols
-      @grid[row][col][:bg]
-    end
+require "tans-parser"
 
-    def style_at(row, col)
-      return nil if row >= @rows || col >= @cols
-      cell = @grid[row][col]
-      { bold: cell[:bold], italic: cell[:italic], underline: cell[:underline] }
-    end
-
-    def to_ai_json
-      h = extract_highlights
-      cursor_info = @cursor.is_a?(Hash) ? @cursor : {}
-      r = cursor_info[:row] || cursor_info["row"] || 0
-      c = cursor_info[:col] || cursor_info["col"] || 0
-      styled_count = h.count { |hl| hl[:bold] || hl[:italic] || hl[:underline] || hl[:fg] || hl[:bg] }
-
-      summary = +"Cursor at [#{r},#{c}]. "
-      summary << "#{styled_count} styled row#{styled_count == 1 ? '' : 's'}"
-      fgs = h.flat_map { |hl| hl[:fg] }.compact.uniq
-      bgs = h.flat_map { |hl| hl[:bg] }.compact.uniq
-      summary << ", colors: fg=#{fgs.sort.join(',')}" unless fgs.empty?
-      summary << ", bg=#{bgs.sort.join(',')}" unless bgs.empty?
-      summary << "."
-
-      {
-        size: { rows: @rows, cols: @cols },
-        cursor: cursor_info,
-        text: plain_text,
-        highlights: h,
-        summary: summary,
-      }
-    end
-
-    private
-
-    def extract_highlights
-      highlights = []
-      @grid.each_with_index do |row, ri|
-        row_text = row.map { |c| c[:char] }.join
-        next if row_text.strip.empty?
-
-        fgs = row.map { |c| c[:fg] || c["fg"] || "default" }
-                 .uniq.reject { |c| c == "default" }
-        bgs = row.map { |c| c[:bg] || c["bg"] || "default" }
-                 .uniq.reject { |c| c == "default" }
-        bold = row.any? { |c| c[:bold] || c["bold"] }
-        italic = row.any? { |c| c[:italic] || c["italic"] }
-        underline = row.any? { |c| c[:underline] || c["underline"] }
-
-        next if fgs.empty? && bgs.empty? && !bold && !italic && !underline
-
-        h = { row: ri, text: row_text }
-        h[:bold] = true if bold
-        h[:italic] = true if italic
-        h[:underline] = true if underline
-        h[:fg] = fgs.size == 1 ? fgs.first : fgs unless fgs.empty?
-        h[:bg] = bgs.size == 1 ? bgs.first : bgs unless bgs.empty?
-        highlights << h
-      end
-      highlights
-    end
-  end
+module TUITD
+  State = TansParser::State
 end

data/lib/tui_td/test_runner.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/BlockLength, Metrics/ClassLength
+
 require "json"
+require "shellwords"
 
 module TUITD
   # Executes TUI tests defined in JSON format.
@@ -39,10 +42,6 @@ module TUITD
       @on_step = on_step
     rescue JSON::ParserError => e
       raise Error, "Invalid JSON: #{e.message}"
-      @plan[:steps] = @plan[:steps].map { |s| s.transform_keys(&:to_sym) }
-      @plan[:before_all] = @plan[:before_all]&.map { |s| s.transform_keys(&:to_sym) }
-      @plan[:after_all] = @plan[:after_all]&.map { |s| s.transform_keys(&:to_sym) }
-      @on_step = on_step
     end
 
     def run
@@ -55,7 +54,7 @@ module TUITD
       hooks = [
         { label: :before_all, steps: @plan[:before_all] || [] },
         { label: :main, steps: @plan[:steps] },
-        { label: :after_all, steps: @plan[:after_all] || [] }
+        { label: :after_all, steps: @plan[:after_all] || [] },
       ]
 
       all_results = []
@@ -120,18 +119,19 @@ module TUITD
                   if match
                     Result.new(step: action, passed: true, message: "Style at [#{row},#{col}] matches #{expected}")
                   else
-                    Result.new(step: action, passed: false, message: "Style at [#{row},#{col}] is #{actual}, expected #{expected}")
+                    Result.new(step: action, passed: false,
+                               message: "Style at [#{row},#{col}] is #{actual}, expected #{expected}",)
                   end
 
                 when "screenshot"
                   ensure_driver!(driver)
-                  path = value.is_a?(String) ? value : "/tmp/tui_td_#{Time.now.to_i}.png"
+                  path = safe_output_path(value, "png")
                   driver.screenshot(path)
                   Result.new(step: action, passed: true, message: "Saved: #{path}")
 
                 when "html"
                   ensure_driver!(driver)
-                  path = value.is_a?(String) ? value : "/tmp/tui_td_#{Time.now.to_i}.html"
+                  path = safe_output_path(value, "html")
                   HtmlRenderer.new(driver.state_data).render(path)
                   Result.new(step: action, passed: true, message: "Saved: #{path}")
 
@@ -159,7 +159,6 @@ module TUITD
                 else
                   Result.new(step: action, passed: false, message: "Unknown action: #{action}")
                 end
-
           rescue StandardError => e
             r = Result.new(step: action, passed: false, message: "#{e.class}: #{e.message}")
           end
@@ -167,23 +166,23 @@ module TUITD
           all_results << r
           all_passed &&= r.passed
 
-          if @on_step
-            state_data = nil
-            begin
-              state_data = driver.state_data if driver
-            rescue StandardError
-              # ignore — state retrieval is best-effort
-            end
-            @on_step.call(
-              index: all_results.size - 1,
-              total: total_steps,
-              action: action,
-              value: value,
-              result: r,
-              driver: driver,
-              state_data: state_data
-            )
+          next unless @on_step
+
+          state_data = nil
+          begin
+            state_data = driver.state_data if driver
+          rescue StandardError
+            # ignore — state retrieval is best-effort
           end
+          @on_step.call(
+            index: all_results.size - 1,
+            total: total_steps,
+            action: action,
+            value: value,
+            result: r,
+            driver: driver,
+            state_data: state_data,
+          )
         end
       end
 
@@ -192,12 +191,25 @@ module TUITD
       {
         name: @plan[:name] || "(unnamed)",
         passed: all_passed,
-        results: all_results.map(&:to_h)
+        results: all_results.map(&:to_h),
       }
     end
 
+    ALLOWED_OUTPUT_DIRS = ["/tmp"].freeze
+
     private
 
+    def safe_output_path(value, ext)
+      default = File.join("/tmp", "tui_td_#{Time.now.to_i}.#{ext}")
+      resolved = File.expand_path(value.is_a?(String) ? value : default)
+
+      unless ALLOWED_OUTPUT_DIRS.any? { |dir| resolved.start_with?(File.expand_path(dir)) }
+        raise TUITD::Error, "Output path must be under one of: #{ALLOWED_OUTPUT_DIRS.join(", ")}"
+      end
+
+      resolved
+    end
+
     def ensure_driver!(driver)
       raise Error, "No session. Add a 'start' step first." if driver.nil?
     end
@@ -261,8 +273,10 @@ module TUITD
       if actual == expected
         Result.new(step: step.keys.first.to_s, passed: true, message: "#{label} at [#{row},#{col}] is #{expected}")
       else
-        Result.new(step: step.keys.first.to_s, passed: false, message: "#{label} at [#{row},#{col}] is #{actual}, expected #{expected}")
+        Result.new(step: step.keys.first.to_s, passed: false,
+                   message: "#{label} at [#{row},#{col}] is #{actual}, expected #{expected}",)
       end
     end
   end
 end
+# rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/BlockLength, Metrics/ClassLength