wreq 1.0.0-aarch64-linux

data/lib/wreq_ruby/response.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+unless defined?(Wreq)
+  module Wreq
+    # HTTP response object containing status, headers, and body.
+    #
+    # This class wraps a native Rust implementation providing efficient
+    # access to HTTP response data including status codes, headers, body
+    # content, and streaming capabilities.
+    #
+    # @example Basic response handling
+    #   response = client.get("https://api.example.com")
+    #   puts response.status.as_int  # => 200
+    #   puts response.text
+    #
+    # @example JSON response
+    #   response = client.get("https://api.example.com/data")
+    #   data = response.json
+    #
+    # @example Streaming response
+    #   response = client.get("https://example.com/large-file")
+    #   response.stream.each do |chunk|
+    #     # Process chunk
+    #   end
+    class Response
+      # Get the HTTP status code as an integer.
+      #
+      # @return [Integer] Status code (e.g., 200, 404, 500)
+      # @example
+      #   response.code  # => 200
+      def code
+      end
+
+      # Get the HTTP status code object.
+      #
+      # @return [Wreq::StatusCode] Status code wrapper with helper methods
+      # @example
+      #   status = response.status
+      #   status.success?  # => true
+      def status
+      end
+
+      # Get the HTTP protocol version used.
+      #
+      # @return [Wreq::Version] HTTP version (HTTP/1.1, HTTP/2, etc.)
+      # @example
+      #   response.version  # => Wreq::Version::HTTP_11
+      def version
+      end
+
+      # Get the final URL after redirects.
+      #
+      # @return [String] The final URL
+      # @example
+      #   response.url  # => "https://example.com/final-page"
+      def url
+      end
+
+      # Get the content length if known.
+      #
+      # @return [Integer, nil] Content length in bytes, or nil if unknown
+      # @example
+      #   response.content_length  # => 1024
+      def content_length
+      end
+
+      # Get the local socket address.
+      #
+      # @return [String, nil] Local address (e.g., "127.0.0.1:54321"), or nil
+      # @example
+      #   response.local_addr  # => "192.168.1.100:54321"
+      def local_addr
+      end
+
+      # Get the remote socket address.
+      #
+      # @return [String, nil] Remote address (e.g., "93.184.216.34:443"), or nil
+      # @example
+      #   response.remote_addr  # => "93.184.216.34:443"
+      def remote_addr
+      end
+
+      # Get the response bytes as a binary string.
+      # @return [String] Response body as binary data
+      # @example
+      #   binary_data = response.bytes
+      #   puts binary_data.size  # => 1024
+      def bytes
+      end
+
+      # Get the response body as text.
+      #
+      # @return [String] Response body decoded as UTF-8 text
+      # @example
+      #   html = response.text
+      #   puts html
+      # @raise [Wreq::DecodingError] if body cannot be decoded as binary
+      def text
+      end
+
+      # Get the response body as text with a specific charset.
+      # This method allows you to specify a default encoding
+      # to use when decoding the response body.
+      # # @param default_encoding [String] Default encoding to use (e.g., "UTF-8")
+      # # @return [String] Response body decoded as text using the specified encoding
+      # @example
+      #   html = response.text_with_charset("ISO-8859-1")
+      #   puts html
+      # @raise [Wreq::DecodingError] if body cannot be decoded with the specified encoding
+      def text_with_charset(default_encoding)
+      end
+
+      # Parse the response body as JSON.
+      #
+      # @return [Object] Parsed JSON (Hash, Array, String, Integer, Float, Boolean, nil)
+      # @raise [Wreq::DecodingError] if body is not valid JSON
+      # @example
+      #   data = response.json
+      #   puts data["key"]
+      def json
+      end
+
+      # Get a streaming iterator for the response body, yielding each chunk.
+      #
+      # This method allows you to process large HTTP responses efficiently,
+      # by yielding each chunk of the body as it arrives, without loading
+      # the entire response into memory.
+      #
+      # @return An iterator over response body chunks (binary String)
+      # @yield [chunk] Each chunk of the response body as a binary String
+      # @example Save response to file
+      #   File.open("output.bin", "wb") do |f|
+      #     response.chunks { |chunk| f.write(chunk) }
+      #   end
+      # @example Count total bytes streamed
+      #   total = 0
+      #   response.chunks { |chunk| total += chunk.bytesize }
+      #   puts "Downloaded #{total} bytes"
+      #
+      # Note: The returned Receiver is only for reading response bodies, not for uploads.
+      def chunks
+      end
+
+      # Close the response and free associated resources.
+      #
+      # @return [void]
+      # @example
+      #   response.close
+      def close
+      end
+    end
+  end
+end
+
+# ======================== Ruby API Extensions ========================
+
+module Wreq
+  class Response
+    # Returns a compact string representation of the response.
+    #
+    # Format: #<Wreq::Response STATUS content-type="..." body=SIZE>
+    #
+    # @return [String] Compact formatted response information
+    # @example
+    #   puts response.to_s
+    #   # => #<Wreq::Response 200 content-type="application/json" body=456B>
+    def to_s
+      parts = ["#<Wreq::Response"]
+
+      # Status code
+      parts << code.to_s
+
+      # Content-Type header if present
+      if headers.respond_to?(:get)
+        content_type = headers.get("content-type")
+        parts << "content-type=#{content_type.inspect}" if content_type
+      end
+
+      # Body size
+      if content_length
+        parts << "body=#{format_bytes(content_length)}"
+      end
+
+      parts.join(" ") + ">"
+    end
+
+    private
+
+    def format_bytes(bytes)
+      return "0B" if bytes.zero?
+
+      units = ["B", "KB", "MB", "GB"]
+      size = bytes.to_f
+      unit_index = 0
+
+      while size >= 1024 && unit_index < units.length - 1
+        size /= 1024.0
+        unit_index += 1
+      end
+
+      if unit_index == 0
+        "#{size.to_i}#{units[unit_index]}"
+      else
+        "#{size.round(1)}#{units[unit_index]}"
+      end
+    end
+  end
+end

data/script/build_platform_gem.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Build a platform-specific gem with pre-compiled native extensions.
+#
+# Usage: ruby script/build_platform_gem.rb PLATFORM
+# Example: ruby script/build_platform_gem.rb arm64-darwin
+#
+# Expects compiled .bundle/.so files in version-specific directories:
+#   lib/wreq_ruby/3.3/wreq_ruby.bundle
+#   lib/wreq_ruby/3.4/wreq_ruby.bundle
+#   lib/wreq_ruby/4.0/wreq_ruby.bundle
+
+require "rubygems/package"
+require "fileutils"
+
+platform = ARGV.fetch(0) { abort "Usage: #{$0} PLATFORM" }
+
+spec = Gem::Specification.load("wreq.gemspec")
+spec.platform = Gem::Platform.new(platform)
+spec.extensions = []
+# Keep in sync with Rakefile cross_compiling block
+spec.required_ruby_version = Gem::Requirement.new(">= 3.3", "< 4.1.dev")
+
+# Add version-specific compiled extensions
+binaries = Dir.glob("lib/wreq_ruby/[0-9]*/*.{bundle,so}")
+abort "No compiled binaries found in lib/wreq_ruby/*/. Did compilation succeed?" if binaries.empty?
+spec.files += binaries
+
+FileUtils.mkdir_p("pkg")
+gem_file = Gem::Package.build(spec)
+FileUtils.mv(gem_file, "pkg/")
+
+puts "Built: pkg/#{File.basename(gem_file)}"

data/test/client_cookie_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ClientCookieProviderTest < Minitest::Test
+  HOST = "http://localhost:8080"
+
+  def setup
+    @jar = Wreq::Jar.new
+    @client = Wreq::Client.new(
+      cookie_store: true,
+      cookie_provider: @jar,
+      allow_redirects: true
+    )
+  end
+
+  def test_custom_jar_captures_set_cookie_and_sends_back
+    # starts empty
+    assert_kind_of Array, @jar.get_all
+    assert_equal 0, @jar.get_all.length
+
+    # server sets cookie; client follows redirect; jar should store it
+    res1 = @client.get("#{HOST}/cookies/set?foo=bar")
+    assert_equal 200, res1.code
+
+    names = @jar.get_all.map(&:name)
+    assert_includes names, "foo"
+
+    # subsequent request should send the stored cookie automatically
+    res2 = @client.get("#{HOST}/cookies")
+    assert_equal 200, res2.code
+    body = res2.json
+    assert_kind_of Hash, body
+    assert_equal "bar", body.dig("cookies", "foo")
+  end
+
+  def test_prepopulated_jar_is_used_by_client
+    # pre-populate jar
+    @jar.add_cookie_str("pref=1; Path=/", "#{HOST}/")
+
+    res = @client.get("#{HOST}/cookies")
+    assert_equal 200, res.code
+    cookies = res.json["cookies"]
+    assert_equal "1", cookies["pref"]
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,136 @@
+require "test_helper"
+
+class ClientTest < Minitest::Test
+  def setup
+    @client = Wreq::Client.new
+  end
+
+  def test_client_creation
+    refute_nil @client
+    assert_instance_of Wreq::Client, @client
+  end
+
+  def test_client_with_configuration
+    client = Wreq::Client.new(
+      timeout: 30,
+      headers: {"User-Agent" => "wreq-ruby/test"}
+    )
+    refute_nil client
+    assert_instance_of Wreq::Client, client
+  end
+
+  def test_get_request
+    response = @client.get("http://localhost:8080/get")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_post_request
+    response = @client.post("http://localhost:8080/post",
+      json: {test: "wreq-ruby"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_put_request
+    response = @client.put("http://localhost:8080/put",
+      json: {data: "test"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_delete_request
+    response = @client.delete("http://localhost:8080/delete")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_patch_request
+    response = @client.patch("http://localhost:8080/patch",
+      json: {update: "field"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_request_with_query_params
+    response = @client.get("http://localhost:8080/get",
+      query: {"param" => "value"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "param"
+  end
+
+  def test_request_with_form_data
+    response = @client.post("http://localhost:8080/post",
+      form: {"field" => "value"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "field"
+  end
+
+  def test_request_with_raw_body
+    response = @client.post("http://localhost:8080/post",
+      body: "raw content",
+      headers: {"Content-Type" => "text/plain"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "raw content"
+  end
+
+  def test_basic_authentication
+    response = @client.get("http://localhost:8080/basic-auth/user/pass",
+      basic_auth: ["user", "pass"])
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_bearer_authentication
+    response = @client.get("http://localhost:8080/bearer",
+      bearer_auth: "test-token")
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "test-token"
+  end
+
+  def test_redirect_following
+    response = @client.get("http://localhost:8080/redirect/1",
+      allow_redirects: true)
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_redirect_blocking
+    response = @client.get("http://localhost:8080/redirect/1",
+      allow_redirects: false)
+    refute_nil response
+    assert_equal 302, response.code
+  end
+
+  def test_gzip_compression
+    response = @client.get("http://localhost:8080/gzip", gzip: true)
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_timeout_handling
+    # Test that short timeouts properly raise exceptions
+    assert_raises(Wreq::TimeoutError) do
+      @client.get("http://localhost:8080/delay/10", timeout: 1)
+    end
+
+    # Test that reasonable timeouts work normally
+    start_time = Time.now
+    response = @client.get("http://localhost:8080/delay/1", timeout: 5)
+    elapsed = Time.now - start_time
+
+    refute_nil response
+    assert_equal 200, response.code
+    assert elapsed < 5, "Request should complete within timeout"
+  end
+
+  def test_status_codes
+    response = @client.get("http://localhost:8080/status/404")
+    refute_nil response
+    assert_equal 404, response.code
+  end
+end

data/test/cookie_test.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class CookieTest < Minitest::Test
+  def setup
+    @jar = Wreq::Jar.new
+    @base_url = "https://example.com"
+  end
+
+  def test_jar_initially_empty
+    assert_instance_of Wreq::Jar, @jar
+    cookies = begin
+      Wreq::Jar.get_all(@jar)
+    rescue
+      @jar.get_all
+    end # support either binding style
+    assert_kind_of Array, cookies
+    assert_equal 0, cookies.length
+  end
+
+  def test_add_cookie_str_and_get_all
+    set_cookie = "sid=abc123; Path=/; Domain=example.com; HttpOnly; Secure"
+    @jar.add_cookie_str(set_cookie, @base_url)
+
+    cookies = @jar.get_all
+    assert_kind_of Array, cookies
+    assert_equal 1, cookies.length
+
+    c = cookies.first
+    assert_instance_of Wreq::Cookie, c
+    assert_equal "sid", c.name
+    assert_equal "abc123", c.value
+
+    # attributes parsed from Set-Cookie
+    assert_equal "/", c.path
+    assert_equal "example.com", c.domain
+
+    # predicate-ish flags
+    assert_equal true, (c.http_only || c.http_only?)
+    assert_equal true, (c.secure || c.secure?)
+  end
+
+  def test_add_multiple_and_remove
+    @jar.add_cookie_str("a=1; Path=/", @base_url)
+    @jar.add_cookie_str("b=2; Path=/", @base_url)
+    @jar.add_cookie_str("c=3; Path=/", @base_url)
+
+    cookies = @jar.get_all
+    assert_equal 3, cookies.length
+
+    # remove one by name
+    @jar.remove("b", @base_url)
+    names = @jar.get_all.map(&:name)
+    refute_includes names, "b"
+    assert_includes names, "a"
+    assert_includes names, "c"
+  end
+
+  def test_clear
+    @jar.add_cookie_str("x=1; Path=/", @base_url)
+    @jar.add_cookie_str("y=2; Path=/", @base_url)
+    refute_empty @jar.get_all
+
+    @jar.clear
+    assert_empty @jar.get_all
+  end
+
+  def test_max_age_and_expires_optional
+    # Max-Age only
+    @jar.clear
+    @jar.add_cookie_str("ma=1; Max-Age=3600; Path=/", @base_url)
+    c1 = @jar.get_all.find { |c| c.name == "ma" }
+    assert c1
+    # can be nil or Integer; just ensure responds and is truthy integer
+    if (v = c1.max_age)
+      assert_kind_of Integer, v
+      assert_operator v, :>=, 0
+    end
+
+    # Expires only
+    @jar.clear
+    t = Time.now + 3600
+    @jar.add_cookie_str("exp=1; Expires=#{t.gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")}; Path=/", @base_url)
+    c2 = @jar.get_all.find { |c| c.name == "exp" }
+    assert c2
+    # expires returns Float (unix seconds) or nil
+    if (e = c2.expires)
+      assert_kind_of Float, e
+      assert_operator e, :>, Time.now.to_f - 1_000_000 # sanity bound
+    end
+  end
+
+  # -------- Wreq::Cookie unit tests --------
+
+  def test_cookie_new_minimal
+    c = Wreq::Cookie.new("sid", "abc")
+
+    assert_instance_of Wreq::Cookie, c
+    assert_equal "sid", c.name
+    assert_equal "abc", c.value
+
+    assert_nil c.path
+    assert_nil c.domain
+    assert_nil c.max_age
+    assert_nil c.expires
+
+    assert_equal false, (c.http_only || c.http_only?)
+    assert_equal false, (c.secure || c.secure?)
+    assert_equal false, c.same_site_lax?
+    assert_equal false, c.same_site_strict?
+  end
+
+  def test_cookie_new_full_attributes
+    exp = Time.now.to_f + 7200.0
+    c = Wreq::Cookie.new("sess", "v",
+      domain: "example.com",
+      path: "/",
+      max_age: 3600,
+      expires: exp,
+      http_only: true,
+      secure: true,
+      same_site: Wreq::SameSite::Lax)
+
+    assert_equal "sess", c.name
+    assert_equal "v", c.value
+    assert_equal "example.com", c.domain
+    assert_equal "/", c.path
+
+    # Max-Age returns seconds as Integer
+    assert_equal 3600, c.max_age
+
+    # Expires returns Float seconds-since-epoch (with small tolerance)
+    assert c.expires
+    assert_kind_of Float, c.expires
+    assert_in_delta exp, c.expires, 2.0
+
+    assert_equal true, (c.http_only || c.http_only?)
+    assert_equal true, (c.secure || c.secure?)
+    # constructor currently sets SameSite to none
+    assert_equal true, c.same_site_lax?
+    assert_equal false, c.same_site_strict?
+  end
+
+  def test_same_site_flags_from_parsed_header
+    @jar.clear
+    @jar.add_cookie_str("s1=1; Path=/; SameSite=Strict", @base_url)
+    @jar.add_cookie_str("s2=1; Path=/; SameSite=Lax", @base_url)
+
+    cookies = @jar.get_all
+    h = cookies.to_h { |ck| [ck.name, [ck.same_site_strict?, ck.same_site_lax?]] }
+
+    assert_equal [true, false], h["s1"]
+    assert_equal [false, true], h["s2"]
+  end
+
+  def test_request_cookie_value_percent_encoding
+    raw_value = "hello world?"
+    client = Wreq::Client.new
+    resp = client.get(
+      "http://localhost:8080/cookies",
+      cookies: {"mykey" => raw_value}
+    )
+    assert_includes resp.text, "hello%20world%3F"
+  end
+end

data/test/emulation_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class EmulationTest < Minitest::Test
+  def test_all_emulation_device_constants_are_non_nil
+    Wreq::EmulationDevice.constants.each do |name|
+      const = Wreq::EmulationDevice.const_get(name)
+      assert_instance_of Wreq::EmulationDevice, const,
+        "#{name} should be EmulationDevice, got #{const.inspect}"
+    end
+  end
+
+  def test_all_emulation_os_constants_are_non_nil
+    Wreq::EmulationOS.constants.each do |name|
+      const = Wreq::EmulationOS.const_get(name)
+      assert_instance_of Wreq::EmulationOS, const,
+        "#{name} should be EmulationOS, got #{const.inspect}"
+    end
+  end
+end

data/test/error_handling_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class ErrorHandlingTest < Minitest::Test
+  def test_network_error_handling
+    # Try to connect to a non-existent domain
+    response = Wreq.get("https://definitely-not-a-real-domain-12345.com")
+    flunk "Expected network error but got response: #{response.code}"
+  rescue => e
+    assert_instance_of Wreq::ConnectionError, e
+    # Network errors should be caught and wrapped appropriately
+  end
+
+  def test_invalid_url_handling
+    # Invalid URL format
+    response = Wreq.get("not-a-valid-url")
+    flunk "Expected URL error but got response: #{response.code}"
+  rescue => e
+    assert_instance_of Wreq::BuilderError, e
+  end
+
+  def test_http_error_status_codes
+    # These should not raise errors, just return responses with error codes
+    [400, 401, 403, 404, 500, 502, 503].each do |status_code|
+      response = Wreq.get("http://localhost:8080/status/#{status_code}")
+      assert_equal status_code, response.code
+      # Should not raise an exception for HTTP error codes
+    end
+  end
+
+  def test_timeout_handling
+    # Test timeout with a delay that should definitely cause timeout
+
+    # Request with a very short timeout that should fail
+    response = Wreq.get("http://localhost:8080/delay/10", timeout: 1)
+    # If we get here, the request didn't timeout (unexpected)
+    flunk "Expected timeout error but got response: #{response.code}"
+  rescue => e
+    # Timeout error is expected
+    assert_instance_of Wreq::TimeoutError, e
+    # Could also check error message contains timeout-related keywords
+  end
+
+  def test_invalid_json_response
+    # Get a non-JSON response and try to parse as JSON
+    response = Wreq.get("http://localhost:8080/html")
+    assert_equal 200, response.code
+
+    # Should raise an error when trying to parse HTML as JSON
+    begin
+      response.json
+    rescue => e
+      assert_instance_of Wreq::DecodingError, e
+    end
+  end
+
+  def test_empty_response_json
+    response = Wreq.get("http://localhost:8080/status/204")
+    assert_equal 204, response.code
+    assert_equal "", response.text
+
+    # Empty body should raise error when parsing as JSON
+    begin
+      response.json
+    rescue => e
+      assert_instance_of Wreq::DecodingError, e
+    end
+  end
+
+  def test_proxy_error_handling
+    invalid_proxies = [
+      "http://invalid.proxy:8080",
+      "https://invalid.proxy:8080",
+      "socks4://invalid.proxy:8080",
+      "socks4a://invalid.proxy:8080",
+      "socks5://invalid.proxy:8080",
+      "socks5h://invalid.proxy:8080"
+    ]
+    target_urls = ["https://example.com", "http://example.com"]
+
+    invalid_proxies.each do |proxy|
+      target_urls.each do |url|
+        Wreq.get(url, proxy: proxy, timeout: 5)
+        flunk "Expected proxy connection error but got response"
+      rescue => e
+        assert_instance_of Wreq::ProxyConnectionError, e
+      end
+    end
+  end
+end