wreq 1.2.7 → 1.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d852c54ebc9e5ea5e94dee83399d2d59f8df824cc68bc74065e94eb0885e99a6
-  data.tar.gz: def648deb12f7339b3de1271dee582cb9e9c03f9cf6cf483bc8031f3815861b5
+  metadata.gz: 556005991e7cd3da728dada73a12c7fc016fa08e0701f7bc027e3da8c40003fd
+  data.tar.gz: dea7a13e0c20655b7aee8404e51c60c37b293c18bf453eac304e0bd9b9759f78
 SHA512:
-  metadata.gz: f25d1ee505f44c8ce4c81b8f12f91a87d7ec6b5c324aa1c2478a6d9a2e18e4604036f46bd9cf711b951007ae53cb6811dd0b7e77973631d179dfd070f2c240ce
-  data.tar.gz: 890f1c4514804666a60f40735d9a678c26edbf0c2d17d057990e61d3209e39aca819c2ebf26cff8e4a3f1a2f7661b94467f109d24f469c3e93007f6c5bcdbf7a
+  metadata.gz: c3f420c02de369f78abed9022089a2e221a8b5da7e71775aadce38cc23482615ba51405f447e855422f68f27b13af8534011816e0065eac42954bba1d1b8ce7a
+  data.tar.gz: 84876653e4a2233f2d0502b4eb3118a318178051b0dc52669aa26b94d85f741b23cff1f520d30c5891a32f630736adcd0c97dbd308e8530985234c5c017ea3a8

data/Cargo.lock

@@ -1549,7 +1549,7 @@ dependencies = [
 
 [[package]]
 name = "wreq-ruby"
-version = "1.2.7"
+version = "1.2.8"
 dependencies = [
  "arc-swap",
  "bytes",

data/Cargo.toml

@@ -5,7 +5,7 @@ authors = ["SearchApi <support@searchapi.io>"]
 homepage = "https://github.com/SearchApi/wreq-ruby"
 repository = "https://github.com/SearchApi/wreq-ruby"
 edition = "2024"
-version = "1.2.7"
+version = "1.2.8"
 rust-version = "1.95"
 
 [lib]

data/lib/wreq_ruby/error.rb

@@ -2,6 +2,10 @@
 
 unless defined?(Wreq)
   module Wreq
+    # Keep interruption outside StandardError so a broad transport rescue
+    # never swallows a Ruby interrupt.
+    class InterruptError < Interrupt; end
+
     # System-level and runtime errors
 
     # Memory allocation failed.

data/src/client/body/stream.rs

@@ -113,7 +113,7 @@ impl BodySender {
     /// # Errors
     ///
     /// Returns `IOError` after either channel side has closed. An interrupted
-    /// wait raises Ruby's standard `Interrupt` exception.
+    /// wait raises `Wreq::InterruptError`.
     pub fn push(ruby: &Ruby, rb_self: &Self, data: RString) -> Result<(), Error> {
         // Clone during the shared borrow, then release it before waiting
         // for capacity. Request attachment needs a mutable borrow.

data/src/error.rs

@@ -84,14 +84,18 @@ define_exception!(DECODING_ERROR, "DecodingError", exception_runtime_error);
 // Configuration and builder errors
 define_exception!(BUILDER_ERROR, "BuilderError", exception_runtime_error);
 
+// Keep interruption outside StandardError so a broad transport rescue
+// never swallows a Ruby interrupt.
+define_exception!(INTERRUPT_ERROR, "InterruptError", exception_interrupt);
+
 /// Memory error constant
 pub fn memory_error(ruby: &Ruby) -> MagnusError {
     MagnusError::new(ruby.get_inner(&MEMORY), RACE_CONDITION_ERROR_MSG)
 }
 
-/// Create Ruby's standard thread interruption error.
+/// Create a `Wreq::InterruptError` when Ruby interrupts a request.
 pub fn interrupt_error(ruby: &Ruby) -> MagnusError {
-    MagnusError::new(ruby.exception_interrupt(), "request interrupted")
+    MagnusError::new(ruby.get_inner(&INTERRUPT_ERROR), "request interrupted")
 }
 
 /// Map a Tokio runtime initialization failure to `Wreq::BuilderError`.
@@ -312,5 +316,12 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), MagnusError> {
         "BuilderError",
         exception_runtime_error
     );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        INTERRUPT_ERROR,
+        "InterruptError",
+        exception_interrupt
+    );
     Ok(())
 }

data/src/rt.rs

@@ -29,7 +29,7 @@ enum BlockOnError<E> {
 /// # Errors
 ///
 /// Returns `Wreq::BuilderError` if the Tokio runtime cannot be initialized,
-/// Ruby's standard `Interrupt` if Ruby interrupts the request, or the error produced
+/// `Wreq::InterruptError` if Ruby interrupts the request, or the error produced
 /// by `map_err` if the future fails.
 pub fn try_block_on<F, T, E, M>(ruby: &Ruby, future: F, map_err: M) -> Result<T, magnus::Error>
 where

data/test/error_handling_test.rb

@@ -1,6 +1,37 @@
 require "test_helper"
+require "socket"
+require "timeout"
 
 class ErrorHandlingTest < Minitest::Test
+  def test_interrupt_error_stays_outside_standard_error
+    assert_equal Interrupt, Wreq::InterruptError.superclass
+    refute_operator Wreq::InterruptError, :<, StandardError
+  end
+
+  def test_request_interruption_raises_interrupt_error
+    request_thread = nil
+    with_hanging_server do |url, accepted|
+      request_thread = Thread.new do
+        Wreq.get(url, timeout: 60)
+      rescue Interrupt, StandardError => error
+        error
+      end
+      request_thread.report_on_exception = false
+
+      Timeout.timeout(5) { accepted.pop }
+      request_thread.wakeup
+
+      assert request_thread.join(5), "Interrupted request thread should stop"
+
+      error = request_thread.value
+      assert_instance_of Wreq::InterruptError, error
+      refute_kind_of StandardError, error
+    end
+  ensure
+    request_thread&.kill
+    request_thread&.join(1)
+  end
+
   def test_network_error_handling
     # Try to connect to a non-existent domain
     response = Wreq.get("https://definitely-not-a-real-domain-12345.com")
@@ -89,4 +120,27 @@ class ErrorHandlingTest < Minitest::Test
       end
     end
   end
+
+  private
+
+  def with_hanging_server
+    server = TCPServer.new("127.0.0.1", 0)
+    accepted = Queue.new
+    thread = Thread.new do
+      socket = server.accept
+      accepted << true
+      sleep
+    rescue IOError, SystemCallError
+      nil
+    ensure
+      socket&.close unless socket&.closed?
+    end
+    thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{server.addr[1]}/", accepted
+  ensure
+    server&.close unless server&.closed?
+    thread&.kill
+    thread&.join(1)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.2.8
 platform: ruby
 authors:
 - SearchApi