wreq 1.2.6-x86_64-linux → 1.2.8-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92e7474db16ed2402299619c5810018fad110426be40b823dc661427febd1dec
-  data.tar.gz: 2bfa63ed7bba9967543083ebb792fa33b81398f37e9cf71fea5e718a50da56c7
+  metadata.gz: ed61b521403984486ad993107d84945937f51ee755729da7be3109885259746f
+  data.tar.gz: cd42e0c9fd6a2647ee66623a1d955ddcfd45ea0328c61a8329ae5a7926b45610
 SHA512:
-  metadata.gz: 8f46547e76ac3ab622c91cab11918bb720955841d9862b6a672f113cd47113f7b96f4a2b5e2ad0b66e039962c3e0ee0f5e4a7a789b1f24a0b6278c2c78840bd4
-  data.tar.gz: 856a9592e1fcb72a7c868e144040e10bd796cf7bd47b96e9755ed29fc2bcc683c36d4c0b1f2114692ef6cdf25c2b10560b41675faf1a6647e661b3e9220e3ab9
+  metadata.gz: 8c8a3d6af46a2461345a41c265a6b66ffe2769797f7fd9d7247a83e5ff5729219b62f632d862a55b6c12d20f8d56ba3f483532627660ed81daf833be7cc5d3ba
+  data.tar.gz: 793557a664cb7d0ee16e9f22fceae0fdde52e479ada83da5c6af566493fd286ae9b34be2a099ffafdd730c5446704a934a369ebe5f800342dd4a187463f635f9

data/.cargo/config.toml

@@ -0,0 +1,4 @@
+# Rake creates or removes this host-specific file when switching platforms.
+include = [
+  { path = "windows.toml", optional = true },
+]

data/Rakefile

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "script/rust_env"
+
+# Cargo needs RubyInstaller's UCRT tools when Rake builds the native extension
+# on Windows. Other platforms keep their existing native Cargo environment.
+Wreq::RustEnv.activate
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 require "rb_sys/extensiontask"

data/crates/wreq-util/README.md

@@ -43,7 +43,7 @@ async fn main() -> wreq::Result<()> {
         .build()?;
 
     // Use the API you're already familiar with
-    let resp = client.get("https://www.google.com").send().await?;
+    let resp = client.get("https://pingly.us.kg/api/all").send().await?;
     println!("{}", resp.text().await?);
     Ok(())
 }

data/docs/windows-gnu-tokio-crash.md

@@ -57,14 +57,60 @@ DLL Name: KERNEL32.dll
 problematic `Sleep` reference can come from Rust std, MinGW, or pthread-related
 linking paths, not only from `windows-sys`.
 
-Verified with:
+Windows builds use the `x86_64-pc-windows-gnu` target and the RubyInstaller
+UCRT toolchain. The Rakefile configures that environment automatically, so the
+extension and tests can be built with:
 
 ```powershell
-.\script\build_windows_gnu.ps1 -SkipBundleInstall -SkipToolInstall -RunTests
+rustup target add x86_64-pc-windows-gnu
+ridk exec pacman -S --needed --noconfirm `
+    mingw-w64-ucrt-x86_64-gcc `
+    mingw-w64-ucrt-x86_64-clang `
+    mingw-w64-ucrt-x86_64-cmake `
+    mingw-w64-ucrt-x86_64-pkgconf
+bundle exec rake test
 ```
 
+The first Rake invocation also writes a machine-local `.cargo/windows.toml`.
+The checked-in `.cargo/config.toml` loads it automatically, so Cargo and Rust
+language servers use the same GNU target and RubyInstaller tools without
+editor-specific settings.
+
+## RubyInstaller development tools
+
+RubyInstaller adds Ruby itself to `PATH`, but it does not enable the bundled
+MSYS2 development environment globally. Running `ridk enable` adds tools such
+as GCC, CMake, and Make to the current terminal only. This is normally useful
+because it avoids conflicts with other Windows toolchains.
+
+Rust language servers start Cargo directly and do not run `ridk enable` or the
+Rakefile first. Add RubyInstaller's `ucrt64\bin` and `usr\bin` directories to
+the user `PATH` so Cargo can load GCC, libclang, and their dependent DLLs from
+any editor:
+
+```powershell
+$rubyRoot = ruby -rrbconfig -e "print RbConfig::CONFIG.fetch('prefix')"
+$required = @(
+    (Join-Path $rubyRoot "msys64\ucrt64\bin"),
+    (Join-Path $rubyRoot "msys64\usr\bin")
+)
+$userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+$entries = @($userPath -split ";" | Where-Object {
+    $_ -and $_ -notin $required
+})
+$entries = $required + $entries
+[Environment]::SetEnvironmentVariable("Path", ($entries -join ";"), "User")
+```
+
+Restart the editor after changing `PATH` so its language server inherits the
+updated environment. Run `bundle exec rake compile` once after installing or
+switching Ruby so `.cargo/windows.toml` points to the active RubyInstaller.
+Run a Rake command after switching the same checkout between Windows and WSL;
+Windows generates this local configuration, while other platforms remove it.
+
 Result:
 
 ```text
-160 runs, 775 assertions, 0 failures, 0 errors
+254 runs, 1198 assertions, 0 failures, 0 errors
+2 Rust tests passed
 ```

data/extconf.rb

@@ -1,4 +1,8 @@
 require "mkmf"
+require_relative "script/rust_env"
+
+Wreq::RustEnv.activate
+
 # We use rb_sys for makefile generation only.
 # We can use `RB_SYS_CARGO_PROFILE` to choose Cargo profile
 # Read more https://github.com/oxidize-rb/rb-sys/blob/main/gem/README.md

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/script/rust_env.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "fileutils"
+
+module Wreq
+  module RustEnv
+    WINDOWS_GNU_TARGET = "x86_64-pc-windows-gnu"
+    WINDOWS_RUBY_PLATFORM = "x64-mingw-ucrt"
+
+    # Uses the UCRT toolchain shipped with the active RubyInstaller installation.
+    def self.activate
+      unless RbConfig::CONFIG["host_os"].match?(/mingw|mswin/)
+        FileUtils.rm_f(cargo_config_path)
+        return
+      end
+
+      ruby_platform = RbConfig::CONFIG.fetch("arch")
+      unless ruby_platform == WINDOWS_RUBY_PLATFORM
+        raise "Unsupported Windows Ruby platform: #{ruby_platform}. " \
+          "Use RubyInstaller UCRT (#{WINDOWS_RUBY_PLATFORM})."
+      end
+
+      ruby_root = RbConfig::CONFIG.fetch("prefix")
+      msys_root = File.join(ruby_root, "msys64")
+      ucrt_bin = File.join(msys_root, "ucrt64", "bin")
+      msys_bin = File.join(msys_root, "usr", "bin")
+
+      validate_tools(ucrt_bin, msys_bin)
+      write_cargo_config(ucrt_bin, msys_bin)
+      ENV["CARGO_BUILD_TARGET"] = WINDOWS_GNU_TARGET
+      ENV["LIBCLANG_PATH"] = ucrt_bin
+      ENV.delete("CMAKE_GENERATOR")
+      ENV["PATH"] = [ucrt_bin, msys_bin, ENV.fetch("PATH", nil)].compact.join(File::PATH_SEPARATOR)
+    end
+
+    # Reports missing RubyInstaller packages before Cargo starts compiling.
+    def self.validate_tools(ucrt_bin, msys_bin)
+      required = %w[gcc.exe g++.exe gcc-ar.exe clang.exe libclang.dll cmake.exe]
+        .map { |tool| File.join(ucrt_bin, tool) }
+        .append(File.join(msys_bin, "make.exe"))
+      missing = required.reject { |tool| File.file?(tool) }
+      unless %w[pkgconf.exe pkg-config.exe].any? { |tool| File.file?(File.join(ucrt_bin, tool)) }
+        missing << File.join(ucrt_bin, "pkgconf.exe")
+      end
+      return if missing.empty?
+
+      raise "Missing RubyInstaller UCRT tools: #{missing.join(", ")}. " \
+        "Install the Windows build dependencies documented in " \
+        "docs/windows-gnu-tokio-crash.md."
+    end
+
+    # Generates machine-local Cargo defaults that work in command lines and IDEs.
+    def self.write_cargo_config(ucrt_bin, msys_bin)
+      config = <<~TOML
+        # Generated by script/rust_env.rb for the active RubyInstaller.
+
+        [build]
+        target = "#{WINDOWS_GNU_TARGET}"
+
+        [target.#{WINDOWS_GNU_TARGET}]
+        linker = "#{File.join(ucrt_bin, "gcc.exe")}"
+
+        [env]
+        CC_x86_64_pc_windows_gnu = { value = "#{File.join(ucrt_bin, "gcc.exe")}", force = true }
+        CXX_x86_64_pc_windows_gnu = { value = "#{File.join(ucrt_bin, "g++.exe")}", force = true }
+        AR_x86_64_pc_windows_gnu = { value = "#{File.join(ucrt_bin, "gcc-ar.exe")}", force = true }
+        CMAKE = { value = "#{File.join(ucrt_bin, "cmake.exe")}", force = true }
+        CMAKE_GENERATOR = { value = "MSYS Makefiles", force = true }
+        CMAKE_MAKE_PROGRAM = { value = "#{File.join(msys_bin, "make.exe")}", force = true }
+        LIBCLANG_PATH = { value = "#{ucrt_bin}", force = true }
+      TOML
+
+      return if File.exist?(cargo_config_path) && File.binread(cargo_config_path) == config
+
+      FileUtils.mkdir_p(File.dirname(cargo_config_path))
+      File.binwrite(cargo_config_path, config)
+    end
+
+    # Returns the ignored Cargo configuration shared by Rake and language servers.
+    def self.cargo_config_path
+      File.expand_path("../.cargo/windows.toml", __dir__)
+    end
+  end
+end

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

data/wreq.gemspec

@@ -56,7 +56,7 @@ Gem::Specification.new do |spec|
   # Exclude non-Ruby files from RDoc to prevent parsing errors
   spec.rdoc_options = ["--exclude", "Cargo\\..*", "--exclude", "\\.rs$"]
 
-  spec.requirements = ["Rust >= 1.85"]
+  spec.requirements = ["Rust >= 1.97"]
   # use a Ruby version which:
   # - supports Rubygems with the ability of compilation of Rust gem
   # - not end of life

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.2.8
 platform: x86_64-linux
 authors:
 - SearchApi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-24 00:00:00.000000000 Z
+date: 2026-07-25 00:00:00.000000000 Z
 dependencies: []
 description: An easy and powerful Ruby HTTP client with advanced browser fingerprinting
   that accurately emulates Chrome, Edge, Firefox, Safari, Opera, and OkHttp with precise
@@ -20,6 +20,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - "./extconf.rb"
+- ".cargo/config.toml"
 - Gemfile
 - LICENSE
 - README.md
@@ -60,7 +61,7 @@ files:
 - lib/wreq_ruby/http.rb
 - lib/wreq_ruby/response.rb
 - script/build_platform_gem.rb
-- script/build_windows_gnu.ps1
+- script/rust_env.rb
 - test/body_sender_test.rb
 - test/client_cookie_test.rb
 - test/client_test.rb
@@ -112,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- Rust >= 1.85
+- Rust >= 1.97
 rubygems_version: 3.5.23
 signing_key: 
 specification_version: 4

data/script/build_windows_gnu.ps1

@@ -1,270 +0,0 @@
-param(
-    [switch]$SkipBundleInstall,
-    [switch]$SkipToolInstall,
-    [switch]$BuildGem,
-    [switch]$TestGem,
-    [switch]$RunTests,
-    [string]$SmokeUrl = $env:WREQ_SMOKE_URL
-)
-
-$ErrorActionPreference = "Stop"
-
-$target = "x86_64-pc-windows-gnu"
-$platform = "x64-mingw-ucrt"
-$gemPattern = "pkg\wreq-*-$platform.gem"
-if ([string]::IsNullOrWhiteSpace($SmokeUrl)) {
-    $SmokeUrl = "https://httpbin.io/get"
-}
-$rubyRoot = Split-Path (Split-Path (Get-Command ruby).Source -Parent) -Parent
-$ucrt = Join-Path $rubyRoot "msys64\ucrt64"
-$ucrtBin = Join-Path $ucrt "bin"
-$msysPackages = @(
-    "mingw-w64-ucrt-x86_64-gcc",
-    "mingw-w64-ucrt-x86_64-clang",
-    "mingw-w64-ucrt-x86_64-cmake",
-    "mingw-w64-ucrt-x86_64-pkgconf"
-)
-
-function Invoke-Step {
-    param(
-        [string]$Name,
-        [scriptblock]$Command
-    )
-
-    Write-Host "==> $Name"
-    # Native command failures do not honor ErrorActionPreference in Windows PowerShell.
-    $global:LASTEXITCODE = 0
-    & $Command
-    if ($LASTEXITCODE -ne 0) {
-        throw "$Name failed with exit code $LASTEXITCODE."
-    }
-}
-
-function Get-MissingUcrtTools {
-    $missing = @()
-
-    if (-not (Test-Path (Join-Path $ucrtBin "gcc.exe")) -or -not (Test-Path (Join-Path $ucrtBin "g++.exe"))) {
-        $missing += "gcc/g++"
-    }
-
-    if (-not (Test-Path (Join-Path $ucrtBin "clang.exe")) -or -not (Test-Path (Join-Path $ucrtBin "libclang.dll"))) {
-        $missing += "clang/libclang"
-    }
-
-    if (-not (Test-Path (Join-Path $ucrtBin "cmake.exe"))) {
-        $missing += "cmake"
-    }
-
-    if (-not (Test-Path (Join-Path $ucrtBin "pkgconf.exe")) -and -not (Test-Path (Join-Path $ucrtBin "pkg-config.exe"))) {
-        $missing += "pkgconf"
-    }
-
-    $missing
-}
-
-function Get-LatestPlatformGem {
-    $gem = Get-ChildItem -Path $gemPattern -ErrorAction SilentlyContinue |
-        Sort-Object LastWriteTime -Descending |
-        Select-Object -First 1
-
-    if (-not $gem) {
-        throw "No Windows GNU platform gem found at '$gemPattern'. Re-run with -BuildGem first."
-    }
-
-    $gem
-}
-
-function Invoke-RubySmoke {
-    param(
-        [string]$Name,
-        [string]$Code
-    )
-
-    Write-Host "Smoke: $Name"
-    ruby -e $Code
-    if ($LASTEXITCODE -ne 0) {
-        throw "$Name failed with exit code $LASTEXITCODE."
-    }
-}
-
-Invoke-Step "Check Ruby platform" {
-    $rubyArch = & ruby -rrbconfig -e "print RbConfig::CONFIG['arch']"
-    if ($rubyArch -ne $platform) {
-        throw "Expected Ruby platform '$platform', got '$rubyArch'. Use RubyInstaller UCRT for this build."
-    }
-
-    ruby -v
-    ruby -rrbconfig -rrubygems -e "puts RbConfig::CONFIG.values_at('arch', 'host', 'CC').join(%q{ }); puts Gem::Platform.local"
-}
-
-Invoke-Step "Install Rust target" {
-    $installedTargets = @(rustup target list --installed)
-    if ($installedTargets -contains $target) {
-        Write-Host "Rust target $target already installed; skipping rustup."
-        return
-    }
-
-    rustup target add $target
-    if ($LASTEXITCODE -ne 0) {
-        throw "Failed to install Rust target $target."
-    }
-}
-
-Invoke-Step "Check MSYS2 UCRT build tools" {
-    $missing = @(Get-MissingUcrtTools)
-    if ($missing.Count -eq 0) {
-        Write-Host "MSYS2 UCRT build tools already present; skipping pacman."
-        return
-    }
-
-    if ($SkipToolInstall) {
-        throw "Missing MSYS2 UCRT build tools: $($missing -join ', '). Re-run without -SkipToolInstall or install them with ridk."
-    }
-
-    Write-Host "Missing MSYS2 UCRT build tools: $($missing -join ', ')"
-    ridk exec pacman -S --needed --noconfirm @msysPackages
-    if ($LASTEXITCODE -ne 0) {
-        $stillMissing = @(Get-MissingUcrtTools)
-        if ($stillMissing.Count -eq 0) {
-            Write-Warning "pacman returned exit code $LASTEXITCODE, but all required tools are present; continuing."
-            $global:LASTEXITCODE = 0
-            return
-        }
-
-        throw "Failed to install MSYS2 UCRT build tools. Missing: $($stillMissing -join ', '). If pacman cannot lock its database, close other pacman/ridk shells, run PowerShell as Administrator, or install RubyInstaller in a user-writable directory."
-    }
-}
-
-Invoke-Step "Configure Windows GNU toolchain" {
-    $env:CARGO_BUILD_TARGET = $target
-    $env:LIBCLANG_PATH = $ucrtBin
-    $env:CC_x86_64_pc_windows_gnu = Join-Path $ucrtBin "gcc.exe"
-    $env:CXX_x86_64_pc_windows_gnu = Join-Path $ucrtBin "g++.exe"
-    $env:CMAKE = Join-Path $ucrtBin "cmake.exe"
-    Remove-Item Env:\CMAKE_GENERATOR -ErrorAction SilentlyContinue
-
-    rustc -Vv
-    Write-Host "LIBCLANG_PATH=$env:LIBCLANG_PATH"
-    Write-Host "CC_x86_64_pc_windows_gnu=$env:CC_x86_64_pc_windows_gnu"
-    Write-Host "CXX_x86_64_pc_windows_gnu=$env:CXX_x86_64_pc_windows_gnu"
-    Write-Host "CMAKE=$env:CMAKE"
-}
-
-if (-not $SkipBundleInstall) {
-    Invoke-Step "Install Ruby dependencies" {
-        bundle install
-    }
-}
-
-Invoke-Step "Compile native extension" {
-    ridk exec ruby -S bundle exec rake compile
-}
-
-Invoke-Step "Sync versioned extension" {
-    $rubyMinor = & ruby -e "print RUBY_VERSION[/\A\d+\.\d+/]"
-    $dest = "lib\wreq_ruby\$rubyMinor"
-    New-Item -ItemType Directory -Force $dest | Out-Null
-    Copy-Item "lib\wreq_ruby\wreq_ruby.so" (Join-Path $dest "wreq_ruby.so") -Force
-}
-
-Invoke-Step "Verify extension loads" {
-    ruby -Ilib -rwreq -e "puts Wreq::VERSION; puts Wreq::Client.new.class"
-}
-
-if ($RunTests) {
-    Invoke-Step "Run tests" {
-        ridk exec ruby -S bundle exec rake test
-    }
-}
-
-if ($BuildGem) {
-    Invoke-Step "Build local platform gem" {
-        $rubyMinor = & ruby -e "print RUBY_VERSION[/\A\d+\.\d+/]"
-        $dest = "lib\wreq_ruby\$rubyMinor"
-        New-Item -ItemType Directory -Force $dest | Out-Null
-        Copy-Item "lib\wreq_ruby\wreq_ruby.so" (Join-Path $dest "wreq_ruby.so") -Force
-
-        ruby script/build_platform_gem.rb $platform
-    }
-}
-
-if ($TestGem) {
-    Invoke-Step "Install and smoke test platform gem" {
-        $gem = Get-LatestPlatformGem
-        $gemHome = Join-Path ([System.IO.Path]::GetTempPath()) "wreq-gem-test-$PID"
-        $gemBin = Join-Path $gemHome "bin"
-        $testDir = Join-Path ([System.IO.Path]::GetTempPath()) "wreq-gem-test-cwd-$PID"
-
-        Remove-Item -Recurse -Force $gemHome, $testDir -ErrorAction SilentlyContinue
-        New-Item -ItemType Directory -Force $gemHome, $gemBin, $testDir | Out-Null
-
-        $oldGemHome = $env:GEM_HOME
-        $oldGemPath = $env:GEM_PATH
-        $oldGemrc = $env:GEMRC
-        $oldRubyopt = $env:RUBYOPT
-        $oldRubylib = $env:RUBYLIB
-        $oldBundleGemfile = $env:BUNDLE_GEMFILE
-        $oldBundleBinPath = $env:BUNDLE_BIN_PATH
-        $oldBundlerVersion = $env:BUNDLER_VERSION
-        $oldSmokeUrl = $env:WREQ_SMOKE_URL
-        $oldWreqGemHome = $env:WREQ_GEM_HOME
-
-        try {
-            $env:GEM_HOME = $gemHome
-            $env:GEM_PATH = $gemHome
-            $env:GEMRC = ""
-            $env:RUBYOPT = ""
-            $env:RUBYLIB = ""
-            $env:BUNDLE_GEMFILE = ""
-            $env:BUNDLE_BIN_PATH = ""
-            $env:BUNDLER_VERSION = ""
-            $env:WREQ_SMOKE_URL = $SmokeUrl
-            $env:WREQ_GEM_HOME = $gemHome
-
-            gem install --norc --local --install-dir $gemHome --bindir $gemBin --no-document --force --no-user-install $gem.FullName
-            if ($LASTEXITCODE -ne 0) {
-                throw "Failed to install $($gem.FullName)."
-            }
-
-            Push-Location $testDir
-            try {
-                Invoke-RubySmoke "Load installed platform gem" @'
-STDOUT.sync = true
-STDERR.sync = true
-require "wreq"
-spec = Gem.loaded_specs.fetch("wreq")
-expected = File.expand_path(ENV.fetch("WREQ_GEM_HOME"))
-actual = File.expand_path(spec.full_gem_path)
-raise "loaded #{actual}, expected under #{expected}" unless actual.start_with?(expected)
-puts "loaded #{spec.full_name}"
-puts actual
-puts "wreq #{Wreq::VERSION}"
-'@
-
-                Invoke-RubySmoke "Request through installed platform gem" @'
-STDOUT.sync = true
-STDERR.sync = true
-require "wreq"
-client = Wreq::Client.new
-resp = client.get(ENV.fetch("WREQ_SMOKE_URL"), timeout: 20)
-puts "HTTP #{resp.code}"
-raise "unexpected status #{resp.code}" unless resp.code == 200
-'@
-            } finally {
-                Pop-Location
-            }
-        } finally {
-            $env:GEM_HOME = $oldGemHome
-            $env:GEM_PATH = $oldGemPath
-            $env:GEMRC = $oldGemrc
-            $env:RUBYOPT = $oldRubyopt
-            $env:RUBYLIB = $oldRubylib
-            $env:BUNDLE_GEMFILE = $oldBundleGemfile
-            $env:BUNDLE_BIN_PATH = $oldBundleBinPath
-            $env:BUNDLER_VERSION = $oldBundlerVersion
-            $env:WREQ_SMOKE_URL = $oldSmokeUrl
-            $env:WREQ_GEM_HOME = $oldWreqGemHome
-            Remove-Item -Recurse -Force $gemHome, $testDir -ErrorAction SilentlyContinue
-        }
-    }
-}