expect-pty 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f85e305b108edbac5d96859d034af4221948535a6f160296072eb1c8189c8cfc
-  data.tar.gz: 83fa7073bac3d7b17ad16f8fb6bf0bbf34d14379378d9813585b64be5ffd2e52
+  metadata.gz: cbcc16796d1be757cc45df5ed803aa8d3518601923eaa3765d512cd3000baaf7
+  data.tar.gz: 47943a69f86cfc7ba7564eea3f2ec7e0f71a30910e398535fbe734cff8cba54f
 SHA512:
-  metadata.gz: 3b4cd1a931adbe60f6d12be3fa49adc43ba9605bbd9c7730661ed435f49b68d3cbaac64a2b3a753134a1350a1edaeaa8c363a27eba837af2ac38663dc336d4ac
-  data.tar.gz: 74de2bb39b847334e691ea6d6e47f0bce3417ac6755c1aa91ccdc85cf5b00c21924df9a60a2ad09b525038200d6c4877bad2af826fdff5f8998093b5b7ee457f
+  metadata.gz: b9d0688944e25cd879072059ecdf8556676bc32c0b83634dbac773f002dad67485e9dad95034a52b306dbf0e1a3e38eff1e67efb0fcd382cd45c8b0c06bf79bd
+  data.tar.gz: 62aed043158e01a8023111d441fb9c484d697763157e18db97c6c01e9bbb7c55af7fb55ea3e311a4bcae2e191209a1401a42b139523d0e7d4c0873be78c2800c

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.8.2 - 2026-10-11
+
+- 修复对象转换、日志回调或背压读取关闭会话后仍继续写入借用 IO 的问题，空写入也会检查关闭状态。
+- 修复转接接收回调耗尽总期限后仍读取后续来源的问题，保留零超时的首次轮询行为。
+- 加快多来源 EOF 连续派发，并减少诊断重新启用后持续脱敏的临时分配，保留来源顺序与秘密过滤。
+
 ## 0.8.1 - 2026-10-11
 
 - 修复自动应答已在缓冲开头确定获胜模式，却被后续无关正则的编码错误阻断的问题，保留未消费尾部。

data/docs/API.md

@@ -126,6 +126,7 @@ end
 `write(*objects)` 按 to_s 写字节并返回字节数，`<<` 返回 Session，`puts` 遵循 Ruby IO 换行与数组规则并返回 nil。
 `send_slow(*objects, delay:)` 按字符延迟发送并收取回复。背压超时抛出 `Expect::WriteTimeout`，`bytes_written` 仅标识本次调用已确认进度，
 嵌套写入异常放在 cause。成功短写不受 write_timeout 的总耗时限制。
+对象转换、发送诊断或背压读取的回调若关闭会话，后续写入抛出 IOError；借用 IO 仍归调用方所有，空写入同样检查关闭状态。
 `send_slow` 的进度累计本次调用中此前完整字符与失败字符实际接受的字节；转换对象和记录回复的内层写入进度不计入。
 首字符 write 的异常无需修正进度时保留原对象；需要累计或排除内层进度时包装并保留 cause。
 `to_io`、`writer`、`slave` 暴露句柄；`pid`、`command`、`tty_name`、`fileno`、`tty?`、`alive?`、`exit_code` 查询会话属性。
@@ -154,7 +155,8 @@ DEBUG 关闭期间仍推进分片脱敏，但这些字节不会在重新启用
 `pending_output?` 表示尚未交付数据；再次转接同源会话继续发送，不重放成功前缀；更换 outputs 不改变已排队字节的目标。
 同源递归转接抛出 ReentrancyError；转义回调可嵌套匹配，所有来源状态按对象身份隔离。
 接收字节交付期间，logger/transcript/outputs 的回调不能递归读取同一会话的新输入，否则抛出 ReentrancyError；
-匹配已有缓冲及读取独立会话仍可用。正数转接总期限会在扫描和继续回调返回后检查；零超时仍处理缓冲并首次轮询。
+匹配已有缓冲及读取独立会话仍可用。正数转接总期限会在扫描、继续回调返回后及读取每个就绪来源前检查；接收回调耗尽预算后不再读取后续来源。
+已读分片的交付仍完整完成，零超时仍处理缓冲并首次轮询。
 
 `interact(input: $stdin, escape: nil, output: nil, timeout: nil, raw: true)` 临时建立双向转接，退出后恢复
 outputs、转义和本地终端模式。

data/lib/expect/matcher.rb

@@ -18,7 +18,8 @@ module Expect
       # 相对期限可因接收或 continue 重算，总期限始终固定；两者共用单调时钟。
       @hard_deadline = deadline
       @deadline = next_deadline
-      @handled_eof = {}.compare_by_identity
+      # 按声明顺序维护仍参与本轮等待的来源；EOF 删除后不再从完整列表重复跳过已处理项。
+      @active_sessions = @sessions.each_with_object({}.compare_by_identity) { |session, active| active[session] = true }
       @stalled_matches = {}.compare_by_identity
       @polled = false
       @expired_eof_continuation = false
@@ -84,7 +85,7 @@ module Expect
       earliest = nil
       groups.each do |sessions, patterns|
         sessions.each do |session|
-          next if @handled_eof.key?(session)
+          next unless @active_sessions.key?(session)
 
           buffer = buffers ? (buffers[session] ||= session.scan_buffer) : session.scan_buffer
           stalled = @stalled_matches[session]
@@ -169,19 +170,19 @@ module Expect
 
     # 找出尚未派发 EOF 事件的会话，保证每个源只处理一次结束事件。
     def unhandled_eof
-      @sessions.find { |session| session.eof? && !@handled_eof.key?(session) }
+      @active_sessions.each_key.find(&:eof?)
     end
 
     # 将剩余字节交给 EOF 回调；需要继续时等待其他源，全部结束则立即返回。
     def handle_eof(session)
       result = session.record_eof
-      @handled_eof[session] = true
+      @active_sessions.delete(session)
       actions = @patterns.eof_patterns_for(session).map { |pattern| pattern.call(session) }
       return result unless actions.any? { |action| continuing?(action) }
 
       reset_timeout = actions.any? { |action| CONTINUE.equal?(action) }
       @deadline = next_deadline if reset_timeout
-      return result if @handled_eof.size == @sessions.size
+      return result if @active_sessions.empty?
 
       # 期限已过时不再扫描文本，但先派发已知 EOF；最后一个源结束不能被误报为超时。
       @expired_eof_continuation = !reset_timeout && expired?
@@ -234,7 +235,7 @@ module Expect
     end
 
     # 返回本次仍需监听的会话，供读取选择和超时回调使用。
-    def active_sessions = @sessions.reject { |session| @handled_eof.key?(session) }
+    def active_sessions = @active_sessions.keys
 
     # 只有约定的继续符号会驱动下一轮，普通回调返回值不会改变等待流程。
     def continuing?(action) = CONTINUE.equal?(action) || CONTINUE_WITHOUT_RESET.equal?(action)

data/lib/expect/redactor.rb

@@ -59,6 +59,7 @@ module Expect
       output = release(@pending.bytesize)
       # 已结束的流没有尚待抑制的字节，后续可见分片恢复普通路径；再次 suppress 时重新建立字节图。
       @suppressed = nil
+      @suppressed_until = nil
       @masking = false
       output
     end
@@ -73,7 +74,10 @@ module Expect
     def append_chunk(data, visible:)
       raise ArgumentError, "data must be a String" unless data.is_a?(String)
 
-      @suppressed ||= "\0" * @pending.bytesize unless visible
+      unless visible || data.empty?
+        @suppressed ||= "\0" * @pending.bytesize
+        @suppressed_until = @pending.bytesize + data.bytesize
+      end
       @suppressed << ((visible ? "\0" : "\1") * data.bytesize) if @suppressed
       @pending << data.b
       @hidden << ("\0" * data.bytesize)
@@ -144,7 +148,11 @@ module Expect
       remaining = @pending.bytesize - length
       @pending = @pending.byteslice(length, remaining)
       @hidden = @hidden.byteslice(length, remaining)
-      @suppressed = @suppressed.byteslice(length, remaining) if @suppressed
+      if @suppressed
+        # 只追踪最后一个抑制字节的排空边界，避免每轮扫描字节图；跨块秘密掩码不受影响。
+        @suppressed_until -= length
+        @suppressed = @suppressed_until.positive? ? @suppressed.byteslice(length, remaining) : nil
+      end
       @scanned_bytes = remaining
       output
     end

data/lib/expect/relay.rb

@@ -122,6 +122,8 @@ module Expect
       end
       readers.each do |session|
         next unless ready ? ready.key?(session.to_io) : readable.first.equal?(session.to_io)
+        # 前一个接收回调可耗尽总预算；本块交付完成后暂停新的读取，零超时仍允许首次批量轮询。
+        break if dispatch_expired?
 
         begin
           if @buffers.key?(session)

data/lib/expect/session.rb

@@ -178,16 +178,19 @@ module Expect
 
     # 按 Ruby to_s 规则原样写入所有字节，返回字节数；背压等待受 write_timeout 限制。
     def write(*objects)
-      raise IOError, "closed Expect session" if closed? || writer.closed?
+      check_writable!
 
       begin
         # 单对象不需要中间数组与 join 副本；to_s、诊断和部分写入仍经过同一条路径。
         data = objects.size == 1 ? objects.first.to_s.b : objects.map { |object| object.to_s.b }.join
+        check_writable!
         trace_data(:sending, data)
       rescue WriteTimeout
         # 转换或诊断中的嵌套写入不属于当前命令；此时尚未向 writer 发送任何字节。
         raise WriteTimeout.new("write interrupted before sending data", bytes_written: 0)
       end
+      # 转换与诊断均可关闭借用会话；即使底层 IO 仍打开，也不能把关闭后的发送报告为成功。
+      check_writable!
       deadline = write_timeout && (Expect.monotonic + write_timeout)
       offset = 0
       while offset < data.bytesize
@@ -467,6 +470,8 @@ module Expect
 
     # EINTR 未确认交付时不移动游标；其他写入计数必须落在当前块范围内。
     def write_chunk(data, offset, deadline)
+      # 背压读取会执行接收回调；每次重试重新检查，关闭会话不等于关闭调用方拥有的 writer。
+      check_writable!
       chunk = data.byteslice(offset, READ_SIZE)
       count = writer.write_nonblock(chunk, exception: false)
       return count if count == :wait_writable
@@ -481,6 +486,11 @@ module Expect
       nil
     end
 
+    # 同一状态检查覆盖入口、用户转换/诊断之后和背压恢复；只检查，不取得借用 IO 所有权。
+    def check_writable!
+      raise IOError, "closed Expect session" if closed? || writer.closed?
+    end
+
     # 背压等待同时排空读端，期限不因 EINTR 重算，异常始终报告外层写入进度。
     def wait_writable(offset, deadline)
       remaining = deadline && [deadline - Expect.monotonic, 0].max

data/lib/expect/version.rb

@@ -2,5 +2,5 @@
 
 module Expect
   # Gem 与库共用的版本号；独立文件使 gemspec 无需加载完整会话实现。
-  VERSION = "0.8.1"
+  VERSION = "0.8.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expect-pty
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - expect-pty contributors