expect-pty 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0742e1462f3858067396edb88d2e401ba621869882091cddee3237cedd86eaf5
-  data.tar.gz: d054194b5f0f54740d86ccdca2d684d7ee8faeae77dbbf50595cc0b3516d4308
+  metadata.gz: bd51e466710a92cea41212f9cb4477f73f586ff44f53fa57676be9562b59f037
+  data.tar.gz: a848149d3069fafefffe5618c9293eed72b569dab3879a783edee292271a25c2
 SHA512:
-  metadata.gz: 5a3be17c347139230dfe4395292ef7eeb58d0f432445c6d234542e3d83ac0f87e0e08d3131dc6842f4f1639a7a979868b84dd51ea9c9b206809901e232faac0d
-  data.tar.gz: e3f6508feaaa07172147b4c26bbc850e22bc918f377213ae4b1403947446cd15141f6d43860d26c28dac62a95628b72df1e09ae9ea2819781eef5cdb7fa93d54
+  metadata.gz: 19709a17b0f7a69db8d8eac19e6bec88259bd37475394a4a0d27e1406a33244bef839cc6627696c8b72a1df5b873b27c2ef55004003a07e66b3e82323d5322be
+  data.tar.gz: f2806cb9db50e6b82bfe0c72a7affd28f1ab50b716688c1dc027aa75fff5c049fffe2f20348695b32a06cb41f1ec2fba426ccef8b4789a2304a388a1908d0e93

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 0.9.4 - 2026-10-19
+
+- 将字面未命中进度归一为内部 LiteralScan，供匹配与转接复用；大缓冲分块转接不再反复搜索已排除的范围，保留跨块转义与回调修改规则的行为。
+- 转接活跃来源改用按对象身份维护的有序索引，避免批量 EOF 继续处理时反复遍历剩余来源。
+- 修复句柄关闭和进程回收同时失败时后一个系统错误覆盖首个错误的问题；后续致命中断仍原样传播，失败资源可重试清理。
+
+- 新增公开的 `Session#buffer_bytesize`，以常数时间查询当前主缓冲字节数，避免容量检查创建正文快照；原 `buffer` 的防御性复制契约不变。
+
 ## 0.9.3 - 2026-10-18
 
 - 结果的 inspect 与 to_s 仅输出匹配序号和错误状态，避免诊断、字符串插值泄露匹配文本、捕获内容或异常消息；原始结果字段保持不变。

data/docs/API.md

@@ -134,7 +134,7 @@ end
 | outputs                | []     | 复制可写目标数组，原样转发接收字节   |
 
 操作参数 `raw`、`consume`、`reset_timeout_on_read`、`graceful` 不持久化为会话设置。
-`buffer` 返回副本，`buffer=` 复制并应用上限，`clear_buffer` 移交并清空缓冲；`buffer_discarded_bytes` 累计窗口裁剪量，匹配消费不计入。
+`buffer` 返回副本；只检查容量时使用 `buffer_bytesize`，以常数时间取得当前未消费主缓冲的字节数，不复制正文、不读取 IO，也不包含 Relay 待写数据或历史窗口。`buffer=` 复制并应用上限，`clear_buffer` 移交并清空缓冲；`buffer_discarded_bytes` 累计窗口裁剪量，匹配消费不计入。
 显式替换/清空、实际裁剪和消费输入会清除正则转义历史；非消费匹配、未裁剪的等待与内部缓冲交接保持连续历史。
 正则转接历史默认保留至多 65,536 字节，设置 `buffer_limit` 后采用该上限。存在固定 UTF-8 正则时，历史预算至少为 3 字节，以保留四字节字符尚未接收完整的前缀；这不扩大普通匹配缓冲的上限，也不延迟协议转发。
 

data/lib/expect/interaction.rb

@@ -3,6 +3,7 @@
 require_relative "relay/writer"
 require_relative "relay"
 require_relative "literal_prefix"
+require_relative "literal_scan"
 
 # 为会话补充人工接管和多路 IO 转接；核心会话定义位于 session.rb。
 module Expect
@@ -81,14 +82,17 @@ module Expect
     # 将待处理输入排入唯一的转接发送队列；返回 :ready、:queued、:stopped 或 :timeout。
     # 字面序列暂存潜在前缀，正则序列结合历史匹配；final 为真时不再等待后续字节。
     # @api private
-    def self.queue_input(session, buffer, final: false, deadline: nil)
+    def self.queue_input(session, buffer, final: false, deadline: nil, literal_scan: nil)
       loop do
         sequences = session.sequences.except(:eof)
         history = session.relay_history
-        found, regexp_scanned, utf8_regexp = scan_sequences(buffer, sequences, history, final:)
+        found, regexp_scanned, utf8_regexp = scan_sequences(
+          buffer, sequences, history, final:, literal_scan:, generation: session.buffer_generation
+        )
         return :timeout if expired?(deadline)
 
         if found
+          literal_scan&.reset
           result = handle_escape(session, buffer, history, found)
           return result unless result == :ready
           return :timeout if expired?(deadline)
@@ -108,7 +112,10 @@ module Expect
         end
         # 排队前缀与尾部可共享原字节；替换窗口而非删除前缀，避免逐块复制整个余量。
         # 保留缓冲对象身份，嵌套 Matcher 仍把尾部交回 Relay 借用的同一个对象。
-        buffer.replace(buffer.byteslice(count..)) if count.positive?
+        if count.positive?
+          buffer.replace(buffer.byteslice(count..))
+          literal_scan&.advance(count)
+        end
         return count.positive? ? :queued : :ready
       end
     end
@@ -134,7 +141,7 @@ module Expect
     end
 
     # 单轮正则共用一个组合文本；回调返回后下一轮重新取得规则和历史。
-    def self.scan_sequences(buffer, sequences, history, final:)
+    def self.scan_sequences(buffer, sequences, history, final:, literal_scan: nil, generation: nil)
       text = nil
       utf8_regexp = false
       earliest = nil
@@ -153,7 +160,7 @@ module Expect
           # 历史前缀已实时转发，不能撤回；负偏移表示本次只需消费转义尚未转发的部分。
           offset -= history.bytesize
         else
-          offset = buffer.index(key)
+          offset = literal_scan ? literal_scan.index(buffer, key, generation:) : buffer.index(key)
           next unless offset
 
           length = key.bytesize

data/lib/expect/literal_scan.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Expect
+  # 一个连续字节窗口的字面未命中进度；不持有输入、会话或 IO。
+  # Matcher 的窗口只追加，Relay 还会移出安全前缀，两者共用绝对字节坐标。
+  # @api private
+  class LiteralScan
+    def initialize
+      @misses = {}.compare_by_identity
+      @consumed = 0
+      @generation = nil
+    end
+
+    # 返回相对当前窗口的字节位置；新输入只重扫可能跨越旧尾部的重叠区。
+    # literal 须为冻结的二进制 String，generation 变化表示窗口被替换、裁剪或外部消费。
+    def index(buffer, literal, generation:)
+      if @generation != generation
+        reset
+        @generation = generation
+      end
+      ending = @consumed + buffer.bytesize
+      previous = @misses[literal]
+      return nil if previous == ending
+
+      offset = previous ? [previous - @consumed - literal.bytesize + 1, 0].max : 0
+      position = buffer.index(literal, offset)
+      if position
+        @misses.delete(literal)
+      else
+        @misses[literal] = ending
+      end
+      position
+    end
+
+    # Relay 仅移出已扫描的安全前缀；未命中范围仍有效，无须逐规则调整偏移。
+    def advance(count)
+      @consumed += count
+    end
+
+    # 转义消费或外部修改建立新边界，后续扫描不能复用旧输入的结论。
+    def reset
+      @misses.clear
+      @consumed = 0
+      @generation = nil
+    end
+  end
+  private_constant :LiteralScan
+end

data/lib/expect/matcher.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "literal_scan"
+
 module Expect
   # 驱动一次单会话或多会话匹配，管理模式优先级、EOF 和共享期限，不接管 IO 所有权。
   # 调度只在扫描、回调和 IO 操作之间检查期限，不强行中断用户代码或单次正则计算。
@@ -124,27 +126,10 @@ module Expect
     # 仅复用同一缓冲代次中的字面未命中。保留模式长度减一的重叠区，覆盖跨读取命中。
     # 不保存整个文本，也不对正则推断扫描窗口；回调替换、消费或转接恢复会改变代次。
     def locate_literal(session, pattern, buffer)
-      @literal_misses ||= {}.compare_by_identity
-      misses = (@literal_misses[session] ||= {}.compare_by_identity)
-      previous = misses[pattern]
-      generation = session.buffer_generation
-      # 模式已冻结；缓冲代次未变意味着只有尾部追加。
-      offset = if previous && previous[0] == generation
-                 return nil if previous[1] == buffer.bytesize
-
-                 [previous[1] - pattern.value.bytesize + 1, 0].max
-               else
-                 0
-               end
-      position = pattern.locate(buffer, offset:)
-      if position
-        misses.delete(pattern)
-      else
-        entry = (misses[pattern] ||= [])
-        entry[0] = generation
-        entry[1] = buffer.bytesize
-      end
-      position
+      @literal_scans ||= {}.compare_by_identity
+      scan = (@literal_scans[session] ||= LiteralScan.new)
+      offset = scan.index(buffer, pattern.value, generation: session.buffer_generation)
+      [offset, pattern.value.bytesize, []] if offset
     end
 
     # 先记录并消费匹配，再执行回调；回调可选择结束、重置期限或保留期限继续。

data/lib/expect/relay.rb

@@ -12,7 +12,8 @@ module Expect
     # 这里只校验参数；run 取得所有来源后才转移缓冲，不关闭或接管任何外部 IO。
     def initialize(sessions, timeout)
       @sessions = sessions.uniq(&:object_id)
-      @active = @sessions.dup
+      # 按对象身份保留声明顺序；每个 EOF 仅删除自身，避免逐个重扫剩余来源。
+      @active = @sessions.each_with_object({}.compare_by_identity) { |session, active| active[session] = true }
       period = Expect.duration(timeout)
       @deadline = period && (Expect.monotonic + period)
       # 零超时保留首轮缓冲及一次轮询；正预算在扫描和每次回调之间重新检查。
@@ -20,6 +21,7 @@ module Expect
       @token = Object.new
       @buffers = {}.compare_by_identity
       @previous = {}.compare_by_identity
+      @literal_scans = {}.compare_by_identity
     end
 
     # 每轮先处理转义和已排队输出，再共同选择读写；停止返回来源会话，总期限到达返回 nil。
@@ -52,7 +54,7 @@ module Expect
     def dispatch_sources
       idle = []
       queued = false
-      @active.dup.each do |session|
+      @active.each_key do |session|
         return [:timeout, idle, queued] if dispatch_expired?
 
         next if session.pending_output?
@@ -72,7 +74,7 @@ module Expect
         callback = session.sequences[:eof]
         return [session, idle, queued] unless callback&.call
 
-        @active.delete_if { |active| active.equal?(session) }
+        @active.delete(session)
         return [:timeout, idle, queued] if dispatch_expired?
       end
       [nil, idle, queued]
@@ -82,11 +84,18 @@ module Expect
     def dispatch_input(session)
       if (callback = session.relay_callback)
         session.relay_callback = nil
+        @literal_scans[session]&.reset
         return :stopped unless callback.call
         return :timeout if dispatch_expired?
       end
 
-      Interaction.queue_input(session, @buffers.fetch(session), final: session.eof?, deadline: @dispatch_deadline)
+      # 正则与空规则不分配字面缓存；回调可追加规则，每轮按当前声明选择。
+      literal_scan = @literal_scans[session]
+      if !literal_scan && session.sequences.any? { |key, _handler| key.is_a?(String) }
+        literal_scan = (@literal_scans[session] ||= LiteralScan.new)
+      end
+      Interaction.queue_input(session, @buffers.fetch(session), final: session.eof?, deadline: @dispatch_deadline,
+                                                                literal_scan:)
     end
 
     # 共同等待来源与目标，每轮读每个就绪来源一次；EINTR 返回原期限循环。
@@ -198,7 +207,7 @@ module Expect
       targets = pending.each_with_object({}.compare_by_identity) do |output, index|
         index[output.target] = true if output.target.is_a?(Session)
       end
-      sources = @active.reject do |session|
+      sources = @active.each_key.reject do |session|
         session.pending_output? && !targets.key?(session)
       end
       (sources + targets.keys).uniq { |session| session.to_io.object_id }.reject(&:eof?)

data/lib/expect/session.rb

@@ -130,6 +130,10 @@ module Expect
     # 返回缓冲副本，防止调用方原地修改绕过裁剪规则。
     def buffer = @buffer.dup
 
+    # 读取当前未消费主缓冲的字节数，不复制正文、不读取 IO，也不包含转接中的待写数据。
+    # @return [Integer] 当前主缓冲占用的字节数。
+    def buffer_bytesize = @buffer.bytesize
+
     # Matcher 仅在无回调的当前扫描借用原字节，避免副本使下一次追加复制整个窗口。
     # 不得修改或跨读取、回调保留；公开 buffer 和继续回调的快照仍独立复制。
     # @api private
@@ -508,7 +512,7 @@ module Expect
         @pending_writes&.clear
         @relay_history&.clear
         @relay_callback = nil
-        status = close_child(timeout:, term_timeout:, force:)
+        status = cleanup.call { close_child(timeout:, term_timeout:, force:) }
         raise failure if failure
 
         status

data/lib/expect/version.rb

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

data/sig/expect.rbs

@@ -102,6 +102,8 @@ module Expect
 
     def buffer: () -> String
 
+    def buffer_bytesize: () -> Integer
+
     def buffer=: (String value) -> void
 
     def clear_buffer: () -> String

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: expect-pty
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - expect-pty contributors
 bindir: bin
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -82,6 +82,7 @@ files:
 - lib/expect/cleanup.rb
 - lib/expect/interaction.rb
 - lib/expect/literal_prefix.rb
+- lib/expect/literal_scan.rb
 - lib/expect/logging.rb
 - lib/expect/matcher.rb
 - lib/expect/pattern.rb