wreq 1.2.3-x64-mingw-ucrt

data/lib/wreq_ruby/header.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+unless defined?(Wreq)
+  module Wreq
+    # HTTP headers collection.
+    #
+    # Provides efficient access to HTTP headers with case-insensitive lookups.
+    # Headers are created by the native extension and cannot be directly instantiated.
+    #
+    # All header names are case-insensitive. Multiple values for the same header
+    # are supported through the `get_all` method.
+    #
+    # @example Accessing response headers
+    #   response = Wreq.get("https://example.com")
+    #   headers = response.headers
+    #   content_type = headers["Content-Type"]
+    #   content_type = headers.get("content-type")  # Same, case-insensitive
+    #
+    # @example Getting all values for a header
+    #   accept_values = headers.get_all("Accept")
+    #   # => ["application/json", "text/html"]
+    #
+    # @example Modifying headers
+    #   headers.set("X-Custom-Header", "value")
+    #   headers["Authorization"] = "Bearer token"
+    #   headers.append("Accept", "application/xml")
+    #
+    # @example Iterating headers
+    #   headers.each do |name, value|
+    #     puts "#{name}: #{value}"
+    #   end
+    #
+    # @example Converting to hash
+    #   hash = headers.to_h
+    #   hash["content-type"]  # => "text/html"
+    class Headers
+      # Create a new empty Headers collection.
+      #
+      # @return [Wreq::Headers] New headers instance
+      # @example
+      #   headers = Wreq::Headers.new
+      #   headers.set("Content-Type", "application/json")
+      def self.new
+      end
+
+      # Get a header value by name (case-insensitive).
+      #
+      # Returns the first value if multiple values exist for the same header.
+      #
+      # @param name [String] Header name (case-insensitive)
+      # @return [String, nil] Header value, or nil if not found
+      # @example
+      #   headers.get("Content-Type")       # => "application/json"
+      #   headers.get("content-type")       # => "application/json" (same)
+      #   headers.get("X-Nonexistent")      # => nil
+      def get(name)
+      end
+
+      # Get all values for a header name (case-insensitive).
+      #
+      # Useful when a header can have multiple values (e.g., Accept, Set-Cookie).
+      #
+      # @param name [String] Header name (case-insensitive)
+      # @return [Array<String>] All values for this header (empty array if not found)
+      # @example
+      #   headers.get_all("Accept")
+      #   # => ["application/json", "text/html", "application/xml"]
+      #   headers.get_all("X-Nonexistent")  # => []
+      def get_all(name)
+      end
+
+      # Set a header value, replacing any existing values.
+      #
+      # @param name [String] Header name
+      # @param value [String] Header value
+      # @return [void]
+      # @raise [Wreq::BuilderError] if name or value contains invalid characters
+      # @example
+      #   headers.set("Content-Type", "application/json")
+      #   headers.set("X-Custom-Header", "my-value")
+      def set(name, value)
+      end
+
+      # Append a header value without replacing existing values.
+      #
+      # Adds a new value for the header, preserving any existing values.
+      # Useful for headers that can have multiple values.
+      #
+      # @param name [String] Header name
+      # @param value [String] Header value to append
+      # @return [void]
+      # @raise [Wreq::BuilderError] if name or value contains invalid characters
+      # @example
+      #   headers.set("Accept", "application/json")
+      #   headers.append("Accept", "text/html")
+      #   headers.get_all("Accept")  # => ["application/json", "text/html"]
+      def append(name, value)
+      end
+
+      # Remove all values for a header name.
+      #
+      # @param name [String] Header name (case-insensitive)
+      # @return [String, nil] The removed value (first one if multiple), or nil
+      # @example
+      #   headers.remove("Authorization")  # => "Bearer token"
+      #   headers.remove("X-Nonexistent")  # => nil
+      def remove(name)
+      end
+
+      # Check if a header exists (case-insensitive).
+      #
+      # @param name [String] Header name
+      # @return [Boolean] true if the header exists
+      # @example
+      #   headers.contains?("Content-Type")  # => true
+      #   headers.contains?("X-Missing")     # => false
+      def contains?(name)
+      end
+
+      # Check if a header key exists (alias for {#contains?}).
+      #
+      # @param name [String] Header name
+      # @return [Boolean] true if the header exists
+      # @example
+      #   headers.key?("Accept")  # => true
+      def key?(name)
+      end
+
+      # Get the number of headers.
+      #
+      # @return [Integer] Total number of unique header names
+      # @example
+      #   headers.length  # => 12
+      def length
+      end
+
+      # Check if there are no headers.
+      #
+      # @return [Boolean] true if no headers exist
+      # @example
+      #   headers.empty?  # => false
+      def empty?
+      end
+
+      # Remove all headers.
+      #
+      # @return [void]
+      # @example
+      #   headers.clear
+      #   headers.empty?  # => true
+      def clear
+      end
+
+      # Get all header names.
+      #
+      # @return [Array<String>] Array of header names (lowercase)
+      # @example
+      #   headers.keys
+      #   # => ["content-type", "accept", "user-agent", "authorization"]
+      def keys
+      end
+
+      # Get all header values.
+      #
+      # Returns one value per header (the first if multiple values exist).
+      #
+      # @return [Array<String>] Array of header values
+      # @example
+      #   headers.values
+      #   # => ["application/json", "text/html", "Mozilla/5.0", "Bearer token"]
+      def values
+      end
+
+      # Iterate over headers.
+      #
+      # Yields each header name and value pair. If a header has multiple values,
+      # only the first is yielded.
+      #
+      # @yieldparam name [String] Header name (lowercase)
+      # @yieldparam value [String] Header value
+      # @return [Enumerator, self] Returns enumerator if no block given, self otherwise
+      # @example With block
+      #   headers.each do |name, value|
+      #     puts "#{name}: #{value}"
+      #   end
+      # @example Without block
+      #   enum = headers.each
+      #   enum.to_a  # => [["content-type", "text/html"], ...]
+      def each
+      end
+
+      # Convert headers to a string representation.
+      def to_s
+      end
+    end
+  end
+end
+
+module Wreq
+  class Headers
+    def inspect
+      "#<Wreq::Headers [#{length} headers]>"
+    end
+  end
+end

data/lib/wreq_ruby/http.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Wreq
+  # HTTP method enumeration backed by Rust.
+  #
+  # Variants are exposed as constants under this class.
+  # Each constant is an instance of {Wreq::Method}.
+  #
+  # @example Using predefined constants
+  #   method = Wreq::Method::GET
+  #   method.class #=> Wreq::Method
+  #
+  # @example In request context
+  #   Wreq.request(url: "https://api.example.com", method: Wreq::Method::POST)
+  class Method
+    # Constants are set by the native extension at initialization.
+    # These stubs are for documentation only.
+    unless const_defined?(:GET)
+      GET = nil # @return [Wreq::Method] HTTP GET method
+      HEAD = nil # @return [Wreq::Method] HTTP HEAD method
+      POST = nil # @return [Wreq::Method] HTTP POST method
+      PUT = nil # @return [Wreq::Method] HTTP PUT method
+      DELETE = nil # @return [Wreq::Method] HTTP DELETE method
+      OPTIONS = nil # @return [Wreq::Method] HTTP OPTIONS method
+      TRACE = nil # @return [Wreq::Method] HTTP TRACE method
+      PATCH = nil # @return [Wreq::Method] HTTP PATCH method
+    end
+  end
+
+  # HTTP version enumeration backed by Rust.
+  #
+  # @example Using predefined constants
+  #   version = Wreq::Version::HTTP_11
+  #   version.class #=> Wreq::Version
+  class Version
+    # Constants are set by the native extension at initialization.
+    # These stubs are for documentation only.
+    unless const_defined?(:HTTP_11)
+      HTTP_09 = nil # @return [Wreq::Version] HTTP/0.9
+      HTTP_10 = nil # @return [Wreq::Version] HTTP/1.0
+      HTTP_11 = nil # @return [Wreq::Version] HTTP/1.1
+      HTTP_2 = nil # @return [Wreq::Version] HTTP/2
+      HTTP_3 = nil # @return [Wreq::Version] HTTP/3
+    end
+
+    # Returns a string representation of the HTTP version.
+    # @return [String] HTTP version as string
+    unless method_defined?(:to_s)
+      def to_s
+      end
+    end
+
+    # Compares HTTP versions by semantic value, not object identity.
+    #
+    # This method is implemented by the native extension.
+    # When comparing with non-{Wreq::Version} objects, it returns false.
+    #
+    # @param other [Object] object to compare against
+    # @return [Boolean] true when both represent the same HTTP version
+    # @example
+    #   Wreq::Version::HTTP_11 == response.version
+    unless method_defined?(:==)
+      def ==(other)
+      end
+    end
+  end
+
+  # HTTP status code wrapper.
+  #
+  # This class wraps standard HTTP status codes and provides
+  # convenient methods to check the response category.
+  #
+  # The actual implementation is provided by Rust for performance.
+  #
+  # @example Check if response is successful
+  #   status = response.status
+  #   if status.success?
+  #     puts "Request succeeded with code: #{status.as_int}"
+  #   end
+  #
+  # @example Check different status categories
+  #   status.informational?  # 1xx
+  #   status.success?        # 2xx
+  #   status.redirection?    # 3xx
+  #   status.client_error?   # 4xx
+  #   status.server_error?   # 5xx
+  unless const_defined?(:StatusCode)
+    class StatusCode
+      # Returns the status code as an integer.
+      #
+      # @return [Integer] the numeric HTTP status code (100-599)
+      def as_int
+      end
+
+      # Checks if status code is informational (1xx).
+      #
+      # Informational responses indicate that the request was received
+      # and the process is continuing.
+      #
+      # @return [Boolean] true if status is 100-199
+      def informational?
+      end
+
+      # Checks if status code indicates success (2xx).
+      #
+      # Success responses indicate that the request was successfully
+      # received, understood, and accepted.
+      #
+      # @return [Boolean] true if status is 200-299
+      def success?
+      end
+
+      # Checks if status code indicates redirection (3xx).
+      #
+      # Redirection responses indicate that further action needs to be
+      # taken to complete the request.
+      #
+      # @return [Boolean] true if status is 300-399
+      def redirection?
+      end
+
+      # Checks if status code indicates client error (4xx).
+      #
+      # Client error responses indicate that the request contains bad
+      # syntax or cannot be fulfilled.
+      #
+      # @return [Boolean] true if status is 400-499
+      def client_error?
+      end
+
+      # Checks if status code indicates server error (5xx).
+      #
+      # Server error responses indicate that the server failed to
+      # fulfill a valid request.
+      #
+      # @return [Boolean] true if status is 500-599
+      def server_error?
+      end
+
+      # Returns a string representation of the status code.
+      # @return [String] Status code as string
+      def to_s
+      end
+    end
+  end
+end
+
+module Wreq
+  class StatusCode
+    def inspect
+      "#<Wreq::StatusCode #{self}>"
+    end
+  end
+
+  class Version
+    def inspect
+      "#<Wreq::Version #{self}>"
+    end
+  end
+end

data/lib/wreq_ruby/response.rb

@@ -0,0 +1,209 @@
+# 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 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("ISO-8859-1")
+      #   puts html
+      # @raise [Wreq::DecodingError] if body cannot be decoded with the specified encoding
+      def text(default_encoding: "UTF-8")
+      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
+
+      # Stream the response body, yielding each chunk to the given block.
+      #
+      # 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 [nil]
+      # @yield [chunk] Each chunk of the response body as a binary String
+      # @raise [LocalJumpError] if called without a block
+      # @raise [Wreq::TimeoutError, Wreq::BodyError, Wreq::ConnectionResetError, Wreq::RequestError]
+      #   if streaming fails while reading the response body
+      # @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"
+      #
+      # Exceptions raised inside the block are propagated to the caller.
+      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 the response body as a string.
+    #
+    # @return [String] Response body text
+    # @example
+    #   puts response.to_s
+    #   puts response
+    #   File.write("page.html", response)
+    def to_s
+      text
+    end
+
+    # Returns a compact string representation for debugging.
+    #
+    # Format: #<Wreq::Response STATUS content-type="..." body=SIZE>
+    #
+    # @return [String] Compact formatted response information
+    # @example
+    #   p response
+    #   # => #<Wreq::Response 200 content-type="application/json" body=456B>
+    def inspect
+      parts = ["#<Wreq::Response"]
+
+      parts << code.to_s
+
+      if headers.respond_to?(:get)
+        content_type = headers.get("content-type")
+        parts << "content-type=#{content_type.inspect}" if content_type
+      end
+
+      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)}"