expect-pty 0.5.3 → 0.6.1

data/lib/expect/redactor.rb

@@ -7,7 +7,7 @@ class Expect
   class Redactor
     # 完整诊断文本只匹配完整秘密；流边界的疑似秘密前缀由 finish 的默认策略保护。
     def self.redact(data, patterns, replacement: "[FILTERED]")
-      filter = new(patterns, replacement: replacement)
+      filter = new(patterns, replacement:)
       filter.append(data) + filter.finish(partial: false)
     end
 
@@ -62,11 +62,18 @@ class Expect
 
     # 流关闭时无法再等待后续字节，默认隐藏与秘密开头一致的未完成尾部。
     def mark_partial_secrets
+      tail = @pending.byteslice(-1, 1)
+      return unless tail
+
       @patterns.each do |pattern|
-        [pattern.bytesize - 1, @pending.bytesize].min.downto(1) do |length|
-          next unless @pending.end_with?(pattern.byteslice(0, length))
+        length = [pattern.bytesize - 1, @pending.bytesize].min
+        # 前缀必须以当前尾字节结束；只收紧最高候选长度，密集候选仍沿用简单倒序扫描。
+        next unless length.positive? && (offset = pattern.rindex(tail, length - 1))
+
+        (offset + 1).downto(1) do |candidate|
+          next unless @pending.end_with?(pattern.byteslice(0, candidate))
 
-          @hidden[-length, length] = "\1" * length
+          @hidden[-candidate, candidate] = "\1" * candidate
           break
         end
       end

data/lib/expect/relay.rb

@@ -3,6 +3,7 @@
 class Expect
   # 一次转接的共同读写循环；发送游标留在源会话中，调用结束后仍可继续。
   # 本对象只暂借未处理输入；读缓冲、发送进度与转义回调分开保存，避免重入时重复交付。
+  # @api private
   class Relay
     OWNERSHIP_MUTEX = Mutex.new
     private_constant :OWNERSHIP_MUTEX
@@ -20,123 +21,143 @@ class Expect
 
     # 每轮先处理转义和已排队输出，再共同选择读写；停止返回来源会话，总期限到达返回 nil。
     # 真实 IO 的写入由非阻塞游标推进，用户日志和回调仍同步执行，须由调用方保证及时返回。
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- 共享读写循环统一维护来源和目标期限。
     def run
       prepare_sources
       outputs.each(&:restart_timeout)
       polled = false
       loop do
-        idle = []
-        queued = false
-        @active.dup.each do |session|
-          next if session.pending_output?
-
-          if (callback = session.__send__(:relay_callback))
-            session.__send__(:relay_callback=, nil)
-            return session unless callback.first&.call
-          end
+        stopped, idle, queued = dispatch_sources
+        return stopped if stopped
 
-          result = Expect.__send__(:relay_buffer, session, @buffers, final: session.eof?) do |data|
-            session.__send__(:queue_output, data)
-          end
-          return session unless result
+        return nil if @active.empty?
 
-          if result == :pending
-            queued = true
-            next
-          end
+        return finish_timeout(idle) if polled && expired?
+
+        progress = advance_outputs || queued
+
+        polled = true
+        return finish_timeout(idle) if select_and_read(progress) == :timeout
+      end
+    ensure
+      restore_sources
+    end
 
-          idle << session
-          next unless session.eof?
+    private
 
-          callback = session.__send__(:sequences)[:eof]
-          return session unless callback&.call
+    # 先交付转义前缀再派发回调；EOF 只在待发送数据处理完后生效。
+    def dispatch_sources
+      idle = []
+      queued = false
+      @active.dup.each do |session|
+        next if session.pending_output?
 
-          @active.delete(session)
+        if (callback = session.relay_callback)
+          session.relay_callback = nil
+          return [session, idle, queued] unless callback.first&.call
         end
-        return nil if @active.empty?
 
-        return finish_timeout(idle) if polled && expired?
+        result = Interaction.relay_buffer(session, @buffers, final: session.eof?) do |data|
+          session.queue_output(data)
+        end
+        return [session, idle, queued] unless result
 
-        progress = advance_outputs || queued
+        if result == :pending
+          queued = true
+          next
+        end
+
+        idle << session
+        next unless session.eof?
+
+        callback = session.sequences[:eof]
+        return [session, idle, queued] unless callback&.call
+
+        @active.delete(session)
+      end
+      [nil, idle, queued]
+    end
+
+    # 共同等待来源与目标，每轮读每个就绪来源一次；EINTR 返回原期限循环。
+    def select_and_read(progress)
+      pending = outputs
+      readers = read_sources(pending)
+      deadlines = [@deadline, *pending.map(&:deadline)].compact
+      remaining = deadlines.empty? ? nil : [deadlines.min - Expect.monotonic, 0].max
+      # 有进展时轮询输入再继续发送，避免大块输出饿死其他来源。
+      remaining = 0 if progress
+      begin
+        ready = IO.select(readers.map(&:to_io), pending.filter_map(&:io).uniq(&:object_id), nil, remaining)
+        if ready
+          read_ready(readers, ready.first)
+        elsif !progress
+          return :timeout if expired?
+
+          pending.each(&:check_timeout!)
+        end
+      rescue Errno::EINTR
+        nil
+      end
+      nil
+    end
+
+    # 同源转接期间读取到借用缓冲；目标会话的背压读取沿用自身状态。
+    def read_ready(readers, readable)
+      return if readable.empty?
+
+      if readable.size > 1
+        ready = {}.compare_by_identity
+        readable.each { |io| ready[io] = true }
+      end
+      readers.each do |session|
+        next unless ready ? ready.key?(session.to_io) : readable.first.equal?(session.to_io)
 
-        pending = outputs
-        readers = read_sources(pending)
-        deadlines = [@deadline, *pending.map(&:deadline)].compact
-        remaining = deadlines.empty? ? nil : [deadlines.min - Expect.monotonic, 0].max
-        # 有进展时轮询输入再继续发送，避免大块输出饿死其他来源。
-        remaining = 0 if progress
         begin
-          polled = true
-          ready = IO.select(readers.map(&:to_io), pending.filter_map(&:io).uniq, nil, remaining)
-          if ready
-            readers.each do |session|
-              next unless ready[0].include?(session.to_io)
-
-              begin
-                if @buffers.key?(session)
-                  session.__send__(:read_available, propagate: false, buffer: @buffers.fetch(session), trim: false)
-                else
-                  session.__send__(:read_available, propagate: false)
-                end
-              rescue Errno::EINTR
-                next
-              end
-            end
-          elsif !progress
-            return finish_timeout(idle) if expired?
-
-            pending.each(&:check_timeout!)
+          if @buffers.key?(session)
+            session.read_available(propagate: false, buffer: @buffers.fetch(session), trim: false)
+          else
+            session.read_available(propagate: false)
           end
         rescue Errno::EINTR
           next
         end
       end
-    ensure
-      restore_sources
     end
 
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    private
-
     # 锁仅保护标记检查/登记，不跨 IO 或用户回调；任一来源被占用时整组拒绝，不动缓冲和期限。
     def prepare_sources
       OWNERSHIP_MUTEX.synchronize do
-        if @sessions.any? { |session| session.__send__(:relay_owner) }
-          raise ReentrancyError, "source session already has an active relay"
-        end
+        raise ReentrancyError, "source session already has an active relay" if @sessions.any?(&:relay_owner)
 
-        @sessions.each { |session| session.__send__(:relay_owner=, @token) }
+        @sessions.each { |session| session.relay_owner = @token }
       end
       @sessions.each do |session|
-        @previous[session] = session.__send__(:interaction_buffer)
+        @previous[session] = session.interaction_buffer
         @buffers[session] = session.clear_buffer
-        session.__send__(:interaction_buffer=, @buffers.fetch(session))
+        session.interaction_buffer = @buffers.fetch(session)
       end
     end
 
     # 未处理输入还给会话，已排队字节仍归游标；构造中断也只恢复已转移的缓冲及自己的标记。
     def restore_sources
-      @previous.each { |session, buffer| session.__send__(:interaction_buffer=, buffer) }
-      @buffers.each { |session, buffer| session.__send__(:restore_relay_buffer, buffer) }
+      @previous.each { |session, buffer| session.interaction_buffer = buffer }
+      @buffers.each { |session, buffer| session.restore_relay_buffer(buffer) }
     ensure
       OWNERSHIP_MUTEX.synchronize do
         @sessions.each do |session|
-          session.__send__(:relay_owner=, nil) if session.__send__(:relay_owner).equal?(@token)
+          session.relay_owner = nil if session.relay_owner.equal?(@token)
         end
       end
     end
 
     # 只收集尚未完成的目标，供共同 select 以及最早写入期限计算使用。
-    def outputs = @sessions.flat_map { |session| session.__send__(:relay_outputs) }.reject(&:done?)
+    def outputs = @sessions.flat_map(&:relay_outputs).reject(&:done?)
 
     # 每个目标每轮最多推进一个片段；移除已完成游标，并告知主循环是否值得立即继续轮询。
     def advance_outputs(check_timeout: true)
       progress = false
       @sessions.each do |session|
-        pending = session.__send__(:relay_outputs)
-        pending.each { |output| progress = output.advance(check_timeout: check_timeout) || progress }
+        pending = session.relay_outputs
+        pending.each { |output| progress = output.advance(check_timeout:) || progress }
         pending.reject!(&:done?)
       end
       progress
@@ -148,9 +169,11 @@ class Expect
     # 背压源暂停吸收新输入，限制排队增长；作为写入目标的会话仍需读取以解除双向等待。
     def read_sources(pending)
       # 输出目标可能也在等待我们读取；这些来源即使有待发送数据也必须继续排空。
-      targets = pending.map(&:target).grep(Expect)
+      targets = pending.filter_map do |output|
+        Session.for(output.target) if output.target.is_a?(Expect)
+      end
       sources = @active.reject { |session| session.pending_output? && !targets.include?(session) }
-      (sources + targets).uniq(&:to_io).reject(&:eof?)
+      (sources + targets).uniq { |session| session.to_io.object_id }.reject(&:eof?)
     end
 
     # 总期限结束时将可交付尾部转为发送游标，至多尝试一轮交付；余量由源会话保存。
@@ -164,7 +187,8 @@ class Expect
         buffer = @buffers.fetch(session)
         next if buffer.empty?
 
-        session.__send__(:queue_output, buffer.dup)
+        session.queue_output(buffer.dup)
+        Interaction.remember_output(session, buffer)
         buffer.clear
       end
       # 到期后只尝试一次非阻塞写入，剩余游标留给下一次 interconnect。

data/lib/expect/relay_writer.rb

@@ -3,6 +3,7 @@
 class Expect
   # 向单个转接目标写入数据，维护发送进度与期限；恢复时不重放已成功写出的前缀。
   # 只借用目标，不 dup 描述符，也不负责读取；所有就绪等待统一交给 Relay 调度。
+  # @api private
   class RelayWriter
     attr_reader :target, :deadline
 
@@ -41,7 +42,7 @@ class Expect
       if @offset < @data.bytesize
         bytes = @data.byteslice(@offset, READ_SIZE)
         count = io ? io.write_nonblock(bytes, exception: false) : target.write(bytes)
-        if count == :wait_writable
+        if io && count == :wait_writable
           check_timeout! if check_timeout
           return false
         end

data/lib/expect/result.rb

@@ -1,18 +1,42 @@
 # frozen_string_literal: true
 
 class Expect
-  # 保存一次等待的结果，保留 Struct 原生数组、Hash 转换和模式解构能力。
-  # number 仅在文本匹配时存在；error 为 :timeout、:eof 或原始 IO 异常，文本字段均为字节串。
-  # before/match/after 是产生结果时的快照，后续读取不追加到旧结果；captures 保留未参与捕获的 nil。
-  # 结果对象仍采用普通可变 Struct 语义；session 只引用来源，不取得 IO 或子进程所有权。
-  Result = Struct.new(:number, :error, :match, :before, :after, :session, :captures, keyword_init: true) do
-    # 是否命中文本模式；事件不会返回模式序号。
+  # 一次等待的不可变快照；session 与 error 只引用来源和原始异常，不取得其所有权。
+  # 文本和捕获值单独复制冻结，后续读取或调用者修改输入不会改变结果。
+  # @!method self.new(**fields)
+  #   按字段关键字或成员顺序的位置参数构造不可变结果。
+  # @!method self.[](**fields)
+  #   使用与 new 相同的参数构造不可变结果。
+  # @!method self.members
+  #   返回按声明顺序排列的字段名。
+  # @!method self.inspect
+  #   返回结果类的说明。
+  # @!method members
+  #   返回按声明顺序排列的字段名。
+  # @!method with(**fields)
+  #   复制结果并替换指定字段，新文本仍独立冻结。
+  # @!method to_h
+  #   返回字段 Hash；有块时按 Ruby Data 协议转换键值对。
+  # @!method deconstruct
+  #   按成员声明顺序返回字段数组。
+  # @!method deconstruct_keys(keys)
+  #   按指定键解构结果，nil 表示全部字段。
+  Result = Data.define(:number, :error, :match, :before, :after, :session, :captures) do
+    # 构造独立不可变快照，复制字符串和捕获数组。
+    # @param captures [Array<String, nil>] 按声明顺序保存捕获组，未参与的组保留 nil。
+    def initialize(number: nil, error: nil, match: nil, before: nil, after: nil, session: nil, captures: [])
+      super(number:, error:, session:, match: match&.dup&.freeze,
+            before: before&.dup&.freeze, after: after&.dup&.freeze,
+            captures: captures.map { |value| value&.dup&.freeze }.freeze)
+    end
+
+    # 是否命中文本；EOF 和超时没有模式序号。
     def matched? = !number.nil?
 
-    # 是否因本次等待期限到达而返回。
+    # 是否因等待期限到达而返回。
     def timeout? = error == :timeout
 
-    # 是否读取源已经结束；子进程是否退出仍应查询会话的 process_status。
+    # 是否读取源已经结束，子进程状态由会话单独查询。
     def eof? = error == :eof
   end
 end