expect-pty 0.2.0 → 0.3.0

data/script/ci

@@ -6,9 +6,9 @@ cd "$(dirname "${BASH_SOURCE[0]}")/.."
 bundle exec rake
 bundle exec ruby examples/dialogue.rb
 
-mkdir -p pkg/ci
+mkdir -p tmp/ci
 gem_version="$(ruby -Ilib -rexpect/version -e 'print Expect::VERSION')"
-gem_file="pkg/ci/expect-pty-${gem_version}.gem"
+gem_file="tmp/ci/expect-pty-${gem_version}.gem"
 if git rev-parse --git-dir >/dev/null 2>&1; then
   export SOURCE_DATE_EPOCH="$(git log -1 --format=%ct)"
 fi
@@ -28,7 +28,6 @@ spec = Gem.loaded_specs.fetch("expect-pty")
 # 临时目录可能经由符号链接访问，先统一为实际路径再检查。
 install_root = File.realpath(ENV.fetch("GEM_HOME"))
 abort "gem was loaded outside the isolated install" unless File.realpath(spec.full_gem_path).start_with?("#{install_root}/")
-
 child = 'STDOUT.sync = true; puts "ready"; puts "reply:#{$stdin.gets&.strip}"'
 Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, log_stdout: false) do |session|
   abort "installed gem did not receive the PTY prompt" unless session.expect("ready", timeout: 5)
@@ -39,6 +38,6 @@ Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, log_stdout: false) do
   abort "installed gem child did not exit successfully" unless status&.success?
 end
 
-puts "Installed #{spec.full_name}: PTY dialogue and process cleanup passed"
+puts "Installed #{spec.full_name}: PTY and isolated installation passed"
 RUBY
 )

data/script/release.rb

@@ -16,11 +16,12 @@ class Release
   REPOSITORY = "gatework/expect-ruby"
   GEM_HOST = "https://rubygems.org"
 
-  def initialize(artifact: nil, dry_run: false)
+  def initialize(artifact: nil, dry_run: false, rubygems_only: false)
     @version = Expect::VERSION
     @tag = "v#{@version}"
-    @artifact = File.expand_path(artifact || "pkg/ci/expect-pty-#{@version}.gem")
+    @artifact = File.expand_path(artifact || "tmp/ci/expect-pty-#{@version}.gem")
     @dry_run = dry_run
+    @rubygems_only = rubygems_only
     @build = artifact.nil?
   end
 
@@ -34,7 +35,7 @@ class Release
 
     command("bash", "script/ci") if @build
     # 独占目录中的副本贯穿校验和上传，其他构建不会改变本次发布的字节。
-    directory = File.join("pkg", "release", @version)
+    directory = File.join("tmp", "release", @version)
     FileUtils.mkdir_p(directory)
     directory = Dir.mktmpdir("candidate-", directory)
     candidate = File.join(directory, "expect-pty-#{@version}.gem")
@@ -49,9 +50,13 @@ class Release
     puts "Verified #{@tag}: #{@sha256}\nArtifact: #{@artifact}"
     return puts "Dry run complete: #{@artifact}" if @dry_run
 
-    verify_remote_source
-    verify_registry_checksum(registry_version)
-    publish_github
+    if @rubygems_only
+      verify_local_source
+    else
+      verify_remote_source
+      verify_registry_checksum(registry_version)
+      publish_github
+    end
     publish_rubygems
   end
 
@@ -97,10 +102,14 @@ class Release
     JSON.parse(output)
   end
 
+  def verify_local_source
+    return if capture("git", "rev-parse", "HEAD") == @commit && capture("git", "status", "--porcelain").empty?
+
+    raise "Source changed during verification; commit the changes and start again"
+  end
+
   def verify_remote_source
-    unless capture("git", "rev-parse", "HEAD") == @commit && capture("git", "status", "--porcelain").empty?
-      raise "Source changed during verification; commit the changes and start again"
-    end
+    verify_local_source
 
     comparison = github("compare/#{@commit}...main")
     raise "Push this commit to #{REPOSITORY}/main first" unless %w[ahead identical].include?(comparison.fetch("status"))
@@ -249,7 +258,10 @@ end
 if $PROGRAM_NAME == __FILE__
   options = {}
   parser = OptionParser.new do |arguments|
-    arguments.banner = "Usage: ruby script/release.rb [--dry-run] [--artifact PATH]"
+    arguments.banner = "Usage: ruby script/release.rb [--rubygems-only] [--dry-run] [--artifact PATH]"
+    arguments.on("--rubygems-only", "Publish only to RubyGems using the existing gem login; no GitHub access") do
+      options[:rubygems_only] = true
+    end
     arguments.on("--artifact PATH", "Publish an already verified gem without rebuilding") do |path|
       options[:artifact] = File.expand_path(path)
     end

data/test/edge_case_test.rb

@@ -13,6 +13,74 @@ class EdgeCaseTest < ExpectTest
     assert result.timeout?
   end
 
+  def test_zero_width_continuation_waits_for_new_input_before_matching_again
+    session, = pipe_session
+    session.buffer = "ready"
+    calls = 0
+
+    result = bounded(1) do
+      session.expect_result(timeout: 0.01) do
+        on(/(?=ready)/) do
+          calls += 1
+          Expect.continue
+        end
+      end
+    end
+
+    assert result.timeout?
+    assert_equal 1, calls
+  end
+
+  def test_stalled_pattern_can_match_again_after_new_input
+    session, writer = pipe_session
+    session.buffer = "ready"
+    first_match = Queue.new
+    background do
+      first_match.pop
+      writer.write("!")
+    end
+    calls = 0
+
+    result = bounded(1) do
+      session.expect_result(timeout: 0.5) do
+        on(/(?=ready)/) do
+          calls += 1
+          first_match << true if calls == 1
+          calls == 1 ? Expect.continue : nil
+        end
+      end
+    end
+
+    assert result.matched?
+    assert_equal 2, calls
+    assert_equal "ready!", session.buffer
+  end
+
+  def test_stalled_pattern_can_match_again_after_timeout_callback_changes_buffer
+    session, = pipe_session
+    session.buffer = "ready"
+    calls = 0
+    timeouts = 0
+
+    result = bounded(1) do
+      session.expect_result(timeout: 0.01) do
+        on(/(?=ready)/) do
+          calls += 1
+          calls == 1 ? Expect.continue : nil
+        end
+        timeout do
+          timeouts += 1
+          session.buffer = "ready!"
+          timeouts == 1 ? Expect.continue : nil
+        end
+      end
+    end
+
+    assert result.matched?
+    assert_equal 2, calls
+    assert_equal 1, timeouts
+  end
+
   def test_stdout_works_with_utf8_banner_and_ascii_regexp
     session, writer = pipe_session
     writer.write("欢迎登录\nprompt>")
@@ -130,11 +198,44 @@ class EdgeCaseTest < ExpectTest
   end
 
   def test_gc_reclaims_abandoned_child
+    assert_gc_reclaims_abandoned_child
+  end
+
+  def test_gc_reclaims_abandoned_child_with_log_callback_capturing_session
+    assert_gc_reclaims_abandoned_child(log_callback: true)
+  end
+
+  def test_invalid_options_raise_before_spawning
+    assert_raises(ArgumentError) { Expect.new(typo: true) }
+    session, = pipe_session
+    assert_raises(ArgumentError) { session.expect(0, "x") }
+    assert_raises(ArgumentError) { session.expect(["-unknown", "x"], timeout: 0) }
+    assert_raises(ArgumentError) { session.on_sequence("") }
+  end
+
+  def test_entrypoint_can_coexist_with_standard_library_expect
+    entrypoint = File.expand_path("../lib/expect/pty.rb", __dir__)
+    script = <<~RUBY
+      require "rbconfig"
+      require File.join(RbConfig::CONFIG.fetch("rubylibdir"), "expect.rb")
+      require ARGV.fetch(0)
+      puts [IO.method_defined?(:expect), defined?(Expect), Expect::VERSION].join(":")
+    RUBY
+    environment = { "RUBYOPT" => nil, "RUBYLIB" => nil, "BUNDLE_GEMFILE" => nil }
+    output, status = Open3.capture2e(environment, RbConfig.ruby, "-e", script, entrypoint)
+    assert status.success?, output
+    assert_equal "true:constant:#{Expect::VERSION}\n", output
+  end
+
+  private
+
+  def assert_gc_reclaims_abandoned_child(log_callback: false)
     script = <<~RUBY
       require "expect"
       require "rbconfig"
       def abandoned
         session = Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", "sleep 60", log_stdout: false)
+        session.log_to { |bytes| [session.pid, bytes] } if #{log_callback}
         session.pid
       end
       # Ruby 的保守 GC 可能扫描到创建线程栈上残留的引用；先结束该线程，确保会话确实不可达。
@@ -158,26 +259,4 @@ class EdgeCaseTest < ExpectTest
     assert status.success?, output
     assert_equal "reaped\n", output
   end
-
-  def test_invalid_options_raise_before_spawning
-    assert_raises(ArgumentError) { Expect.new(typo: true) }
-    session, = pipe_session
-    assert_raises(ArgumentError) { session.expect(0, "x") }
-    assert_raises(ArgumentError) { session.expect(["-unknown", "x"], timeout: 0) }
-    assert_raises(ArgumentError) { session.on_sequence("") }
-  end
-
-  def test_entrypoint_can_coexist_with_standard_library_expect
-    entrypoint = File.expand_path("../lib/expect/pty.rb", __dir__)
-    script = <<~RUBY
-      require "rbconfig"
-      require File.join(RbConfig::CONFIG.fetch("rubylibdir"), "expect.rb")
-      require ARGV.fetch(0)
-      puts [IO.method_defined?(:expect), defined?(Expect), Expect::VERSION].join(":")
-    RUBY
-    environment = { "RUBYOPT" => nil, "RUBYLIB" => nil, "BUNDLE_GEMFILE" => nil }
-    output, status = Open3.capture2e(environment, RbConfig.ruby, "-e", script, entrypoint)
-    assert status.success?, output
-    assert_equal "true:constant:#{Expect::VERSION}\n", output
-  end
 end

data/test/interact_test.rb

@@ -25,6 +25,71 @@ class InteractTest < ExpectTest
     [master, slave, source]
   end
 
+  def socket_session
+    local, peer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(local, peer)
+    session = Expect.open(local)
+    @sessions << session
+    [session, peer]
+  end
+
+  def test_changed_interact_regexp_does_not_match_previously_forwarded_input
+    session, peer = socket_session
+    input, keyboard = pipe_session
+    keyboard.write("old")
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert_equal "old", peer.read_nonblock(100)
+
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /old/, timeout: 0)
+    keyboard.write("oldtail")
+    stopped = session.interact(input: input.to_io, output: StringIO.new, escape: /old/, timeout: 0.1)
+    assert_same input.to_io, stopped.to_io
+    assert_equal "tail", stopped.buffer
+  end
+
+  def test_same_interact_regexp_keeps_cross_call_history_and_unread_tail
+    session, peer = socket_session
+    input, keyboard = pipe_session
+    keyboard.write("ST")
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert_equal "ST", peer.read_nonblock(100)
+
+    keyboard.write("OPtail")
+    stopped = session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0.1)
+    assert_same input.to_io, stopped.to_io
+    assert_equal "tail", stopped.buffer
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert_equal "tail", peer.read_nonblock(100)
+  end
+
+  def test_repeated_interact_keeps_split_crlf_on_the_same_terminal
+    session, = socket_session
+    master, slave, source = local_terminal
+    session.buffer = "first\r"
+    assert_nil session.interact(input: source, output: slave, timeout: 0)
+    assert_equal "first\r", master.read_nonblock(100)
+
+    session.buffer = "\nsecond"
+    assert_nil session.interact(input: source, output: slave, timeout: 0)
+    assert_equal "\nsecond", master.read_nonblock(100)
+  end
+
+  def test_changed_interact_regexp_preserves_pending_output_and_tail
+    session, peer = socket_session
+    input, keyboard = pipe_session
+    loop { break if session.writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
+    keyboard.write("old")
+    assert_nil session.interact(input: input, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert input.pending_output?
+    input.buffer = "tail"
+    loop { break if peer.read_nonblock(65_536, exception: false) == :wait_readable }
+
+    assert_nil session.interact(input: input, output: StringIO.new, escape: /old/, timeout: 0.01)
+    refute input.pending_output?
+    assert_empty input.buffer
+    assert_equal "oldtail", peer.read_nonblock(100)
+  end
+
   def test_real_terminal_handoff_ctrl_c_escape_and_resume
     session = shell_session
     log = StringIO.new
@@ -98,6 +163,43 @@ class InteractTest < ExpectTest
     keyboard&.kill&.join if keyboard&.alive?
   end
 
+  def test_interact_preserves_newline_processing_on_the_shared_local_terminal
+    session = child(<<~'RUBY', raw_pty: true)
+      STDOUT.sync = true
+      while STDIN.gets
+        STDOUT.write("first\nsecond\r")
+        STDIN.gets
+        STDOUT.write("\nFW# ")
+      end
+    RUBY
+    master, _, source = local_terminal
+    screen = Expect.open(master, write_timeout: 3)
+    @sessions << screen
+    driver = Thread.new do
+      screen.write("show\n")
+      ScriptProbe.check(screen.expect("first\r\nsecond\r", timeout: 3),
+                        "interact disabled output newline processing")
+      screen.write("continue\n")
+      ScriptProbe.check(screen.expect("\nFW# ", timeout: 3), "interact duplicated a split CRLF sequence")
+      screen.write(InteractProbe::ESCAPE)
+      true
+    rescue Exception # rubocop:disable Lint/RescueException -- Release interact when the assertion fails.
+      begin
+        screen.write(InteractProbe::ESCAPE)
+      rescue StandardError
+        nil
+      end
+      raise
+    end
+    driver.report_on_exception = false
+
+    assert_same source, session.interact(input: source, escape: InteractProbe::ESCAPE, output: source.to_io, timeout: 5)
+    assert driver.join(2), "terminal driver did not finish"
+    assert driver.value
+  ensure
+    driver&.kill&.join if driver&.alive?
+  end
+
   def test_remote_eof_restores_input_terminal_and_keeps_borrowed_io_open
     session = child('STDIN.gets; print "FINAL_REMOTE_OUTPUT"', raw_pty: true)
     _, slave, source = local_terminal

data/test/interconnect_test.rb

@@ -3,6 +3,113 @@
 require_relative "test_helper"
 
 class InterconnectTest < ExpectTest
+  def test_escape_callback_can_match_new_input_and_return_its_tail
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    result = nil
+    session.on_sequence("!") do
+      writer.write("ready tail")
+      result = session.expect("ready", timeout: 0.05)
+      false
+    end
+    session.buffer = "!"
+
+    assert_same(session, bounded { Expect.interconnect(session, timeout: 1) })
+    assert_equal 1, result
+    assert_equal " tail", session.buffer
+    assert_empty output.string
+    Expect.interconnect(session, timeout: 0)
+    assert_equal " tail", output.string
+  end
+
+  def test_escape_callback_can_match_previously_read_tail
+    session, = pipe_session
+    result = nil
+    session.on_sequence("!") do
+      result = session.expect("ready", timeout: 0)
+      false
+    end
+    session.buffer = "!ready tail"
+
+    assert_same session, Expect.interconnect(session, timeout: 1)
+    assert_equal 1, result
+    assert_equal " tail", session.buffer
+  end
+
+  def test_callback_match_failure_returns_unconsumed_bytes_to_relay
+    session, writer = pipe_session
+    session.on_sequence("!") do
+      writer.write("\xff".b)
+      session.expect(/ready/u, timeout: 0.05)
+    end
+    session.buffer = "!prefix"
+
+    assert_raises(EncodingError) { bounded { Expect.interconnect(session, timeout: 1) } }
+    assert_equal "prefix\xff".b, session.buffer
+    assert_nil session.__send__(:interaction_buffer)
+  end
+
+  def test_timeout_flush_leaves_blocked_output_pending_without_reading_after_deadline
+    reader, writer = IO.pipe
+    sink, sink_writer = IO.pipe
+    @ios.push(reader, writer, sink, sink_writer)
+    loop { break if sink_writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
+    session = Expect.open(reader, writer: sink_writer, write_timeout: 1)
+    @sessions << session
+    # A loopback listener must not wait or read more input after the deadline.
+    session.listeners = [session]
+    session.on_sequence("STOP")
+    session.buffer = "ST"
+    writer.write("tail")
+    original = IO.method(:select)
+    poll = true
+    select = lambda do |*arguments|
+      if poll
+        poll = false
+        nil
+      else
+        original.call(*arguments)
+      end
+    end
+
+    IO.stub(:select, select) { assert_nil Expect.interconnect(session, timeout: 0) }
+    assert session.pending_output?
+    assert_empty session.buffer
+    session.listeners = []
+    assert_equal 1, session.expect("tail", timeout: 0)
+  end
+
+  def test_backpressure_reads_still_apply_escape_sequences
+    source, = pipe_session
+    reader, writer = IO.pipe
+    sink, sink_writer = IO.pipe
+    @ios.push(reader, writer, sink, sink_writer)
+    loop { break if sink_writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
+    target = Expect.open(reader, writer: sink_writer, write_timeout: 1)
+    @sessions << target
+    output = StringIO.new
+    received = Queue.new
+    target.log_to { received << true }
+    target.listeners = [output]
+    target.on_sequence("STOP")
+    source.listeners = [target]
+    source.buffer = "request"
+    writer.write("beforeSTOPtail")
+    background do
+      received.pop
+      sink.readpartial(65_536)
+    end
+
+    assert_same(target, bounded { Expect.interconnect(target, source, timeout: 0.2) })
+    assert_equal "before", output.string
+    assert_equal "tail", target.buffer
+    target.log_output = nil
+    writer.write("ready")
+    assert_equal 1, target.expect("ready", timeout: 1)
+    assert_equal "tail", target.before
+  end
+
   def test_interconnect_forwards_and_strips_split_escape
     session, writer = pipe_session
     listener = StringIO.new
@@ -102,14 +209,17 @@ class InterconnectTest < ExpectTest
     assert_equal ["original"], source.instance_variable_get(:@sequences).keys
   end
 
-  def test_terminal_modes_restore_after_callback_exception
+  def test_interconnect_leaves_terminal_modes_to_the_caller
     session = child('print "!"; sleep 30')
-    mode = session.to_io.console_mode
     original = terminal_configuration(session)
-    session.on_sequence("!") { raise "stop" }
+    seen = nil
+    session.on_sequence("!") do
+      seen = terminal_configuration(session)
+      raise "stop"
+    end
     assert_raises(RuntimeError) { Expect.interconnect(session, timeout: 1) }
+    assert_equal original, seen
     assert_equal original, terminal_configuration(session)
-    refute_nil mode
   end
 
   def test_manual_stty_leaves_terminal_mode_to_caller
@@ -136,6 +246,50 @@ class InterconnectTest < ExpectTest
     assert_empty session.buffer
   end
 
+  def test_interconnect_retries_an_interrupted_select
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence("!")
+    writer.write("ready!")
+    original = IO.method(:select)
+    interrupted = true
+    select = lambda do |*arguments|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments)
+    end
+
+    IO.stub(:select, select) do
+      assert_same session, Expect.interconnect(session, timeout: 1)
+    end
+    assert_equal "ready", output.string
+  end
+
+  def test_interconnect_retries_an_interrupted_read
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence("!")
+    writer.write("ready!")
+    original = session.to_io.method(:read_nonblock)
+    interrupted = true
+    read = lambda do |*arguments, **options|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments, **options)
+    end
+
+    session.to_io.stub(:read_nonblock, read) do
+      assert_same session, Expect.interconnect(session, timeout: 1)
+    end
+    assert_equal "ready", output.string
+  end
+
   def test_regexp_escape_matches_and_preserves_trailing_input
     session, writer = pipe_session
     output = StringIO.new
@@ -169,6 +323,36 @@ class InterconnectTest < ExpectTest
     assert_equal "after", session.buffer
   end
 
+  def test_regexp_escape_history_has_a_finite_default_window
+    session, = pipe_session
+    session.on_sequence(/UNLIKELY_ESCAPE/)
+    buffers = { session => "".b }
+
+    5.times do
+      buffers[session] << ("x" * 16_384)
+      Expect.send(:relay_buffer, session, buffers)
+    end
+
+    assert_operator session.__send__(:relay_history).bytesize, :<=, 65_536
+    assert_empty buffers.fetch(session)
+  end
+
+  def test_utf8_regexp_escape_history_keeps_a_valid_leading_character
+    session, = pipe_session
+    session.on_sequence(/终止/u)
+    buffers = { session => "".b }
+
+    6.times do
+      buffers[session] << ("中" * 5461).b
+      assert Expect.send(:relay_buffer, session, buffers)
+    end
+
+    assert_operator session.__send__(:relay_history).bytesize, :<=, 65_536
+    assert session.__send__(:relay_history).dup.force_encoding(Encoding::UTF_8).valid_encoding?
+    buffers[session] << "终止".b
+    refute Expect.send(:relay_buffer, session, buffers)
+  end
+
   def test_regexp_escape_continuation_does_not_rematch_history
     session, writer = pipe_session
     seen = []
@@ -194,6 +378,21 @@ class InterconnectTest < ExpectTest
     assert_equal "abc", session.buffer
   end
 
+  def test_log_failure_preserves_received_bytes_for_recovery
+    session, writer = pipe_session
+    session.log_to { raise IOError, "log failed" }
+    writer.write("before!tail")
+
+    error = assert_raises(IOError) { Expect.interconnect(session, timeout: 1) }
+    assert_equal "log failed", error.message
+    assert_equal "before!tail", session.buffer
+    refute session.eof?
+
+    session.log_output = nil
+    assert_equal 1, session.expect("before!", timeout: 0)
+    assert_equal "tail", session.buffer
+  end
+
   def test_logs_received_bytes_once_across_expect_interconnect_and_expect
     session, writer = pipe_session
     log = StringIO.new