tui-td 0.2.14 → 0.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81e8cf766200bdb7f86334be97036e68f36df7e352618e823185976ebb07a629
-  data.tar.gz: 1632047e8e7b668d0aee6fcf3b14ff16b01d5c23d4cca1f126315d6fe8c1606b
+  metadata.gz: 48cd9df54d8ad7bc1d41b8d4cfd961462ecff6e8056c4fd37e46abb56fa50f38
+  data.tar.gz: c77b9a6eb3a048806d17d4f5b2245dcf82dd1c5e818a247db48912e9b590d78d
 SHA512:
-  metadata.gz: a0f08cd1cc35c05466f5f5b77f45f674635d390db8a68bf9a75e316e2cc70f681daf718211a8563b765ccbfe1b7689d38e28378311dc2ad9afa3bf57a946a172
-  data.tar.gz: 5f6385932f9c350c3186dfe44a3c47bc0c169c86189feb90c8a54dc6ddfdb54f0b97489ffe812da557cc2e6828b384b28cd81ca286be977221586c4f0788fe33
+  metadata.gz: ce4bdb6d4397369717686756508ec43219340ed4a0cc0ec8a4851018a19dc19bbdec3050147238a221cd4b282c92d848df1d71a1377b4915bfb42282af400d95
+  data.tar.gz: 6053e73dd915f8839d92ef8b046578bae6fbf481b0fda21872851e7e9052816833ce62ab5d6a4d15a685ce517f161fe31e75d5a9309a0dacb3521a3df4e893af

data/CHANGELOG.md

@@ -1,5 +1,90 @@
 # CHANGELOG
 
+## 0.2.17
+
+### Added
+
+- Named snapshot testing: `match_snapshot("name")` — first run creates golden master,
+  subsequent runs compare. Supports `type: :text` (chars_only), `:full`, `:png`, `:html`, `:all`.
+- `ignore_rows:` parameter — skip specific rows during snapshot comparison
+- `region:` parameter — restrict comparison to a row range (e.g., `region: 0..6`)
+  Combinable with `ignore_rows:` for fine-grained control.
+- `UPDATE_SNAPSHOTS=1` — environment variable to auto-update all snapshots
+- `TUITD.configure { |c| c.snapshot_dir = "..." }` — configurable snapshot directory
+- `Driver#find_text(pattern, match:)` — convenience delegation to State#find_text
+- `Driver#snapshot` — returns a State snapshot for in-memory comparison
+- JSON test steps: `snapshot`, `assert_snapshot` with `type:` and `wait:` options
+- MCP tools: `tui_save_snapshot`, `tui_assert_snapshot`, `tui_element_actions`,
+  `tui_annotate_element`, `tui_diff`
+- Drive mode: `snapshot <name>`, `diff <name>` commands
+- `TUITD::Snapshot` class — core abstraction for save/load/compare of named snapshots
+- `TUITD::Configuration` class — global gem configuration
+
+### Changed
+
+- `match_snapshot` matcher: now accepts String names (named snapshots) in addition to
+  legacy State objects. New kwargs: `type:`, `wait:`, `ignore_rows:`, `region:`.
+- `tui_find_text` MCP tool: added `match:` parameter (`partial`, `exact`, `regex`)
+- `tui_find_elements` MCP tool: added `checked:`/`disabled:` filters, new roles
+- `tui_diff` MCP tool: fixed deep key symbolization for snapshot hash compatibility
+- Dependency: tans-parser `~> 0.1.3`
+
+## 0.2.16
+
+### Added
+
+- Driver#find_text: convenience delegation to State#find_text with match: modes
+- Driver#snapshot: return a State snapshot for later diff comparison
+- match_snapshot RSpec matcher: compare current state against saved snapshot,
+  supports chars_only: true to ignore color/style changes
+- MCP tui_diff tool: compare current terminal state against a previous snapshot,
+  returns cell-level differences
+- MCP tui_annotate_element tool: manually register UI element annotations that
+  are picked up by tui_find_elements
+- Drive mode: snapshot and diff commands for interactive state comparison
+
+### Changed
+
+- Tighten tans-parser dependency to ~> 0.1.3 (includes State#diff,
+  State#annotate_role, improved dialog/statusbar detection)
+
+## 0.2.15
+
+### Added
+
+- Integration with tans-parser 0.1.2: new UI element roles (:input, :label, :menu, :tab)
+- Filter kwargs on get_by_role: text:, checked:, disabled:
+- Singular convenience methods: button(), checkbox(), input(), label(), menu(), tab(),
+  dialog(), statusbar(), progress_bar()
+- Element action methods: click, type(text), press_key(key)
+- Element predicates: checked?, disabled?
+- Element bounds accessor
+- disabled field on Element
+- ScopedSelector via Selector#within(element, &block) with full query API
+- State#find_text match modes: :partial (default), :exact, :regex
+- RSpec matchers: have_input, have_label, have_menu, have_tab, have_statusbar,
+  have_progress_bar
+- JSON test steps: assert_input, assert_label, assert_menu, assert_tab,
+  assert_statusbar, assert_progress_bar
+- MCP tool: tui_element_actions — returns click/type/press_key action hashes
+- Enhanced MCP tui_find_elements: checked/disabled filters, new roles, (disabled)/
+  (focused) output
+- Enhanced MCP tui_find_text: match: parameter for exact/regex mode
+- CLI drive mode: elements command now shows inputs, labels, menus, tabs
+- Updated help texts (tui-td help test, tui-td help rspec) with new steps and matchers
+
+### Changed
+
+- RSpec matchers (have_button, have_checkbox, have_role) now use tans-parser filter
+  kwargs instead of manual .select post-filtering
+- JSON test runner check_role helper uses tans-parser filter kwargs
+- have_checkbox now supports .unchecked chain
+
+### Removed
+
+- Custom coordinate-based Selector#within (replaced by tans-parser's element-based
+  within with ScopedSelector)
+
 ## 0.2.14
 
 ### Fixed

data/README.md

@@ -286,7 +286,13 @@ tui-td test examples/echo_test.json
 | `assert_button` | `"text"` | Assert a button with given text is visible (`[ OK ]`, `(Cancel)`, `<Submit>`) |
 | `assert_dialog` | — | Assert a dialog (box-drawing region) is visible |
 | `assert_checkbox` | `"label", "checked": true` | Assert a checkbox with given label (and optionally checked state) |
-| `assert_role` | `":button", "text": "OK"` | Generic role assertion (`:button`, `:checkbox`, `:dialog`, `:statusbar`, `:progress`) |
+| `assert_role` | `":button", "text": "OK"` | Generic role assertion (`:button`, `:checkbox`, `:dialog`, `:statusbar`, `:progress`, `:input`, `:label`, `:menu`, `:tab`) |
+| `assert_input` | `"text"` (optional) | Assert an input field (`[____]`) is visible |
+| `assert_label` | `"text"` | Assert a label (text ending with colon) is visible |
+| `assert_menu` | `"text"` (optional) | Assert a menu bar or dropdown item is visible |
+| `assert_tab` | `"text"` | Assert a tab (`[Tab1]`) is visible |
+| `assert_statusbar` | — | Assert a status bar (bottom row with background) is visible |
+| `assert_progress_bar` | `"text"` (optional) | Assert a progress bar (`[####]`) is visible |
 | `close` | — | Close the TUI |
 
 Example with `html` step for before/after snapshots:
@@ -364,9 +370,65 @@ end
 | `have_button("OK")` | Assert a button with given text is visible |
 | `have_dialog` | Assert a dialog (box-drawing region) is visible |
 | `have_checkbox("Label").checked` | Assert a checkbox with given label (chain `.checked`) |
-| `have_role(:button, text: "OK")` | Generic role assertion with optional text filter |
+| `have_role(:button, text: "OK", checked: true, disabled: false)` | Generic role assertion with optional text, checked, disabled filters |
+| `have_input` | Assert an input field (`[____]`) is visible |
+| `have_label("Name")` | Assert a label (text ending with colon) is visible |
+| `have_menu` | Assert a menu bar or dropdown item is visible |
+| `have_tab("File")` | Assert a tab is visible |
+| `have_statusbar` | Assert a status bar (bottom row with background) is visible |
+| `have_progress_bar("50%")` | Assert a progress bar (`[####]`) is visible |
 | `have_exit_status(N)` | Assert the driver process exit status equals N |
 
+## Snapshot Testing
+
+Named, persisted snapshot testing à la Playwright/Jest. First run creates a golden master — subsequent runs compare.
+
+### RSpec
+
+```ruby
+# Named snapshot (recommended)
+expect(driver).to match_snapshot("login_screen")
+expect(driver).to match_snapshot("login_screen", type: :all, wait: true)
+
+# Partial screen comparison
+expect(driver).to match_snapshot("banner", region: 0..6, chars_only: true)
+
+# Skip volatile rows (e.g., prompt line)
+expect(driver).to match_snapshot("main", ignore_rows: [5])
+
+# In-memory comparison (legacy)
+pre = driver.snapshot
+expect(driver).to match_snapshot(pre, chars_only: true)
+```
+
+### Configuration
+
+```ruby
+TUITD.configure do |c|
+  c.snapshot_dir = "spec/snapshots"   # default
+end
+
+# Update all snapshots
+UPDATE_SNAPSHOTS=1 bundle exec rspec
+```
+
+### JSON Test Steps
+
+```json
+{"snapshot": "login_screen", "type": "text"}
+{"assert_snapshot": "login_screen", "type": "png", "wait": true}
+```
+
+### Types
+
+| Type | Comparison | File |
+|------|-----------|------|
+| `:text` | chars only (ignores colors/styles) | `.json` |
+| `:full` | full cell comparison (chars + colors) | `.json` |
+| `:png` | screenshot byte-identical | `.png` |
+| `:html` | HTML render byte-identical | `.html` |
+| `:all` | all three at once | `.json` + `.png` + `.html` |
+
 ## MCP Server — AI Integration
 
 Start the MCP server to let any MCP client control TUIs:
@@ -390,8 +452,13 @@ tui-td serve
 | `tui_html_render` | Render terminal state as a self-contained HTML document. Returns HTML inline or saves to file. |
 | `tui_wait_for_exit` | Wait until the TUI process exits. Returns exit status. |
 | `tui_exit_status` | Get the exit status code (nil if still running). |
-| `tui_find_text` | Search for text or regex in terminal state. Returns positions of all matches. |
-| `tui_find_elements` | Detect UI elements (buttons, checkboxes, dialogs, etc.) with optional role/text filters. |
+| `tui_find_text` | Search for text or regex in terminal state. Supports match modes: `partial` (default), `exact`, `regex`. |
+| `tui_find_elements` | Detect UI elements (buttons, checkboxes, dialogs, inputs, labels, menus, tabs, etc.) with optional role, text, checked, and disabled filters. |
+| `tui_element_actions` | Get click/type/press_key action hashes for a detected UI element. For AI-driven interaction. |
+| `tui_diff` | Compare current state against a previous snapshot. Returns cell-level differences. |
+| `tui_annotate_element` | Manually register a UI element annotation. Picked up by tui_find_elements. |
+| `tui_save_snapshot` | Save the current terminal state as a named snapshot to disk. |
+| `tui_assert_snapshot` | Assert current state matches a saved named snapshot. Creates on first run. |
 | `tui_close` | Close the TUI and clean up. |
 
 ### MCP configuration
@@ -441,10 +508,13 @@ Add to your MCP client configuration:
 // 9. Find UI elements by role
 {"method": "tools/call", "params": {"name": "tui_find_elements", "arguments": {"role": "button"}}}
 
-// 10. Check exit status (or wait for exit)
+// 10. Get actions for an element
+{"method": "tools/call", "params": {"name": "tui_element_actions", "arguments": {"role": "button", "text": "OK"}}}
+
+// 11. Check exit status (or wait for exit)
 {"method": "tools/call", "params": {"name": "tui_exit_status", "arguments": {}}}
 
-// 11. Clean up
+// 12. Clean up
 {"method": "tools/call", "params": {"name": "tui_close", "arguments": {}}}
 ```
 

data/lib/tui_td/cli.rb

@@ -41,6 +41,10 @@ module TUITD
         opts.separator "  state              Show terminal state as pretty JSON"
         opts.separator "  raw                Show raw ANSI output"
         opts.separator "  elements           Show detected UI elements (buttons, dialogs, etc.)"
+        opts.separator "  snapshot <name>    Save current state as named snapshot to disk"
+        opts.separator "  snapshot           Save current state in-memory (legacy)"
+        opts.separator "  diff <name>        Compare current state against named snapshot on disk"
+        opts.separator "  diff               Compare against in-memory snapshot (legacy)"
         opts.separator "  key <name>         Send keystroke (enter, tab, escape, up, down, left, right,"
         opts.separator "                     backspace, ctrl_c, ctrl_d)"
         opts.separator "  <text>             Send text to the TUI"
@@ -116,6 +120,8 @@ module TUITD
           _help_test
         when "rspec"
           _help_rspec
+        when "minitest"
+          _help_minitest
         when nil
           _help_main
         else
@@ -202,8 +208,53 @@ module TUITD
             puts "Buttons:    #{selector.buttons.map { |e| "#{e.text}@[#{e.row},#{e.col}]" }.join(", ")}"
             puts "Checkboxes: #{selector.checkboxes.map { |e| "#{e.text} (#{e.checked ? "✓" : "☐"})" }.join(", ")}"
             puts "Dialogs:    #{selector.dialogs.map { |e| "\"#{e.text}\" #{e.width}x#{e.height}" }.join(", ")}"
+            puts "Inputs:     #{selector.inputs.map { |e| "[__]@[#{e.row},#{e.col}]" }.join(", ")}"
+            puts "Labels:     #{selector.labels.map(&:text).join(", ")}"
+            puts "Menus:      #{selector.menus.map(&:text).join(", ")}"
+            puts "Tabs:       #{selector.tabs.map { |e| "#{e.text}#{" (focused)" if e.focused}" }.join(", ")}"
             puts "Statusbars: #{selector.statusbars.map(&:text).join(", ")}"
             puts "Progress:   #{selector.progress_bars.map(&:text).join(", ")}"
+          elsif input.start_with?("snapshot ")
+            name = input.split(" ", 2).last.strip
+            unless name.empty?
+              snap = Snapshot.new(name)
+              snap.save(driver.state_data)
+              puts "Snapshot '#{name}' saved to #{snap.path}."
+            end
+          elsif input == "snapshot"
+            @last_snapshot = State.new(driver.state_data)
+            puts "In-memory snapshot saved."
+          elsif input.start_with?("diff ")
+            name = input.split(" ", 2).last.strip
+            unless name.empty?
+              snap = Snapshot.new(name)
+              unless snap.exists?
+                puts "No snapshot '#{name}' found at #{snap.path}."
+                next
+              end
+              result = snap.compare(driver.state_data)
+              if result.passed?
+                puts "No differences. Snapshot '#{name}' matches."
+              else
+                puts result.message
+              end
+            end
+          elsif input == "diff"
+            if @last_snapshot
+              current = State.new(driver.state_data)
+              diffs = current.diff(@last_snapshot)
+              if diffs.empty?
+                puts "No differences."
+              else
+                puts "#{diffs.size} difference(s):"
+                diffs.first(10).each do |d|
+                  puts "  [#{d[:row]},#{d[:col]}] #{d[:before][:char].inspect} -> #{d[:after][:char].inspect}"
+                end
+                puts "  ..." if diffs.size > 10
+              end
+            else
+              puts "No snapshot saved. Use 'snapshot <name>' or 'snapshot' first."
+            end
           elsif input.start_with?("key ")
             driver.send_keys(input.split(" ", 2).last.to_sym)
           else
@@ -324,8 +375,9 @@ module TUITD
     def _help_main
       puts(OptionParser.new { |o| o.banner = "Usage: tui-td <command> [options]" })
       puts
-      puts "For more: tui-td help test   (JSON test step types)"
-      puts "          tui-td help rspec  (RSpec matchers)"
+      puts "For more: tui-td help test     (JSON test step types)"
+      puts "          tui-td help rspec    (RSpec matchers)"
+      puts "          tui-td help minitest (Minitest assertions)"
       exit 0
     end
 
@@ -433,7 +485,36 @@ module TUITD
 
           {"assert_role": ":button", "text": "OK"}
               Generic role assertion. Accepts :button, :checkbox, :dialog,
-              :statusbar, :progress. Optional "text" filter.
+              :statusbar, :progress, :input, :label, :menu, :tab.
+              Optional "text", "checked", and "disabled" filters.
+
+          {"assert_input": true} or {"assert_input": "text"}
+              Assert that an input field ([____]) is visible. Optional text
+              filter to match adjacent label.
+
+          {"assert_label": "Name"}
+              Assert that a label (text ending with colon) is visible.
+
+          {"assert_menu": true} or {"assert_menu": "File | Edit"}
+              Assert that a menu bar or dropdown item is visible.
+
+          {"assert_tab": "File"}
+              Assert that a tab ([Tab1]) is visible.
+
+          {"assert_statusbar": true}
+              Assert that a status bar (bottom row with background) is visible.
+
+          {"assert_progress_bar": true} or {"assert_progress_bar": "50%"}
+              Assert that a progress bar ([####   ]) is visible.
+
+          {"snapshot": "login_screen", "type": "text", "wait": true}
+              Save current terminal state as a named snapshot to disk.
+              type: "text" (default), "full", "png", "html", "all".
+
+          {"assert_snapshot": "login_screen", "type": "text", "wait": true}
+              Assert current state matches a saved named snapshot.
+              First run creates the golden master (passes automatically).
+              UPDATE_SNAPSHOTS=1 to force update all snapshots.
 
         Example test file: examples/echo_test.json
       HELP
@@ -518,9 +599,51 @@ module TUITD
 
         have_role(:button, text: "OK")
             Generic role matcher. Accepts :button, :checkbox, :dialog,
-            :statusbar, :progress. Optional text: filter.
+            :statusbar, :progress, :input, :label, :menu, :tab.
+            Optional text:, checked:, disabled: filters.
             Usage: expect(state).to have_role(:statusbar)
 
+        have_input
+            Passes if an input field ([____]) is visible.
+            Usage: expect(state).to have_input
+            Usage: expect(state).to have_input("Name")
+
+        have_label("Name")
+            Passes if a label (text ending with colon) is visible.
+            Usage: expect(state).to have_label("Name")
+
+        have_menu
+            Passes if a menu bar or dropdown item is visible.
+            Usage: expect(state).to have_menu
+
+        have_tab("File")
+            Passes if a tab is visible.
+            Usage: expect(state).to have_tab("File")
+
+        have_statusbar
+            Passes if a status bar (bottom row with background) is visible.
+            Usage: expect(state).to have_statusbar
+
+        have_progress_bar
+            Passes if a progress bar ([####   ]) is visible.
+            Usage: expect(state).to have_progress_bar
+
+        match_snapshot("<name>", type: :text, wait: false, region: 0..6, ignore_rows: [2])
+            Named, persisted snapshot testing. First run creates the snapshot
+            (passes automatically), subsequent runs compare.
+            Types: :text (chars_only, default), :full (chars+colors), :png, :html, :all.
+            region: restricts comparison to a row range (e.g., 0..6).
+            ignore_rows: skips specific rows during comparison.
+            UPDATE_SNAPSHOTS=1 to auto-update all snapshots.
+            Usage: expect(driver).to match_snapshot("login_screen")
+            Usage: expect(driver).to match_snapshot("banner", region: 0..6, chars_only: true)
+            Usage: expect(driver).to match_snapshot("main", ignore_rows: [5], wait: true)
+
+        match_snapshot(State, chars_only: false)  (legacy in-memory)
+            Passes if the current state matches a previously saved snapshot object.
+            Usage: pre = driver.snapshot; ... ; expect(driver).to match_snapshot(pre)
+            Usage: expect(state).to match_snapshot(snap, chars_only: true)
+
         Driver matchers (work on TUITD::Driver, not State)
         --------------------------------------------------
 
@@ -530,6 +653,108 @@ module TUITD
       HELP
       exit 0
     end
+
+    def _help_minitest
+      puts <<~HELP
+        Minitest Assertions
+        ===================
+
+        Include the assertions module in your Minitest test class:
+
+          require "tui_td/minitest/assertions"
+
+          class MyTUITest < Minitest::Test
+            include TUITD::Minitest::Assertions
+
+            def setup
+              @driver = TUITD::Driver.new("my_tui", rows: 24, cols: 80)
+              @driver.start
+            end
+
+            def teardown
+              @driver&.close
+            end
+          end
+
+        Auto-wait: When given a Driver, assertions wait up to 3 seconds.
+        When given a State, assertions check immediately.
+
+        Assertions
+        ----------
+
+        Text / Regex / Color / Style:
+
+        assert_text(driver, "Welcome")
+            Passes if text appears anywhere in the terminal.
+            Negate: refute_text(driver, "Error")
+
+        assert_regex(driver, /error|fail/)
+            Passes if regex pattern matches anywhere.
+            Negate: refute_regex(driver, /pattern/)
+
+        assert_fg(driver, "cyan", row: 0, col: 5)
+            Assert foreground color at position.
+
+        assert_bg(driver, "blue", row: 0, col: 0)
+            Assert background color at position.
+
+        assert_style(driver, row: 0, col: 0, bold: true, italic: false)
+            Assert style attributes at position.
+
+        assert_exit_status(driver, 0)
+            Assert the process exit status matches expected.
+
+        Selector assertions:
+
+        assert_button(driver, "OK")
+            Passes if a button with given text is visible.
+            Negate: refute_button(driver, "Cancel")
+
+        assert_dialog(driver)
+            Passes if a dialog (box-drawing region) is visible.
+            Negate: refute_dialog(driver)
+
+        assert_checkbox(driver, "Label", checked: true)
+            Passes if checkbox with given label (and optionally state) is visible.
+            Use checked: true, checked: false, or unchecked: true.
+
+        assert_role(driver, :button, text: "OK", checked: nil, disabled: nil)
+            Generic role assertion. Accepts :button, :checkbox, :dialog,
+            :statusbar, :progress, :input, :label, :menu, :tab.
+
+        assert_input(driver)
+        assert_input(driver, "Name")
+            Passes if an input field ([____]) is visible.
+
+        assert_label(driver, "Username")
+            Passes if a label (text ending with colon) is visible.
+
+        assert_menu(driver)
+            Passes if a menu bar or dropdown item is visible.
+
+        assert_tab(driver, "File")
+            Passes if a tab is visible.
+
+        assert_statusbar(driver)
+            Passes if a status bar (bottom row with background) is visible.
+
+        assert_progress_bar(driver, "50%")
+            Passes if a progress bar ([####   ]) is visible.
+
+        Snapshot:
+
+        assert_snapshot(driver, "login_screen", type: :text, wait: true)
+            Named snapshot testing. First run creates golden master,
+            subsequent runs compare.
+
+        assert_snapshot(driver, "banner", region: 0..6, chars_only: true)
+            Partial screen comparison with region:.
+
+        assert_snapshot(driver, "main", ignore_rows: [5])
+            Skip volatile rows with ignore_rows:.
+      HELP
+      exit 0
+    end
   end
 end
 # rubocop:enable Metrics/ClassLength, Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/BlockLength

data/lib/tui_td/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module TUITD
+  # Global configuration for tui-td.
+  #
+  # Usage:
+  #   TUITD.configure do |c|
+  #     c.snapshot_dir = "spec/snapshots"
+  #   end
+  #
+  class Configuration
+    attr_accessor :snapshot_dir
+
+    def initialize
+      @snapshot_dir = nil
+    end
+
+    # Check if UPDATE_SNAPSHOTS env var is set to update mode.
+    def update_snapshots?
+      %w[1 true].include?(ENV["UPDATE_SNAPSHOTS"].to_s)
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+  end
+end

data/lib/tui_td/driver.rb

@@ -211,6 +211,19 @@ module TUITD
       Screenshot.new(@state).render(output_path)
     end
 
+    # Search for text or regex pattern in the current terminal state.
+    # Delegates to TansParser::State#find_text.
+    # Supports match modes: :partial (default, substring), :exact, :regex.
+    def find_text(pattern, match: :partial)
+      TUITD::State.new(state_data).find_text(pattern, match: match)
+    end
+
+    # Return a snapshot of the current terminal state as a TUITD::State object.
+    # Can be compared later with match_snapshot or State#diff.
+    def snapshot
+      TUITD::State.new(state_data)
+    end
+
     # Close the driver and clean up
     def close
       _stop_reader_thread