wreq 1.0.0

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/src/client/body/form.rs

@@ -0,0 +1,2 @@
+/// Alias for form parameters.
+pub type Form = crate::client::param::Params;

data/src/client/body/json.rs

@@ -0,0 +1,16 @@
+use indexmap::IndexMap;
+use serde::{Deserialize, Serialize};
+
+/// Represents a JSON value for HTTP requests.
+/// Supports objects, arrays, numbers, strings, booleans, and null.
+#[derive(Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Json {
+    Object(IndexMap<String, Json>),
+    Boolean(bool),
+    Number(isize),
+    Float(f64),
+    String(String),
+    Null(Option<isize>),
+    Array(Vec<Json>),
+}

data/src/client/body/stream.rs

@@ -0,0 +1,148 @@
+use std::{
+    pin::Pin,
+    sync::RwLock,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_util::{Stream, StreamExt, TryFutureExt};
+use magnus::{Error, RString, TryConvert, Value};
+use tokio::sync::{
+    Mutex,
+    mpsc::{self},
+};
+
+use crate::{
+    error::{memory_error, mpsc_send_error_to_magnus},
+    rt,
+};
+
+/// A receiver for streaming HTTP response bodies.
+pub struct BodyReceiver(Mutex<Pin<Box<dyn Stream<Item = wreq::Result<Bytes>> + Send>>>);
+
+/// A sender for streaming HTTP request bodies.
+#[magnus::wrap(class = "Wreq::BodySender", free_immediately, size)]
+pub struct BodySender(RwLock<InnerBodySender>);
+
+struct InnerBodySender {
+    tx: Option<mpsc::Sender<Bytes>>,
+    rx: Option<mpsc::Receiver<Bytes>>,
+}
+
+// ===== impl BodyReceiver =====
+
+impl BodyReceiver {
+    /// Create a new [`BodyReceiver`] instance.
+    #[inline]
+    pub fn new(stream: impl Stream<Item = wreq::Result<Bytes>> + Send + 'static) -> BodyReceiver {
+        BodyReceiver(Mutex::new(Box::pin(stream)))
+    }
+}
+
+impl Iterator for BodyReceiver {
+    type Item = Bytes;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        rt::maybe_block_on(async {
+            self.0
+                .lock()
+                .await
+                .as_mut()
+                .next()
+                .await
+                .and_then(|r| r.ok())
+        })
+    }
+}
+
+// ===== impl BodySender =====
+
+impl BodySender {
+    /// Ruby: `Wreq::Sender.new(capacity = 8)`
+    pub fn new(args: &[Value]) -> Self {
+        let capacity: usize = if let Some(v) = args.first() {
+            usize::try_convert(*v).unwrap_or(8)
+        } else {
+            8
+        };
+
+        let (tx, rx) = mpsc::channel(capacity);
+        BodySender(RwLock::new(InnerBodySender {
+            tx: Some(tx),
+            rx: Some(rx),
+        }))
+    }
+
+    /// Ruby: `push(data)` where data is String or bytes
+    pub fn push(rb_self: &Self, data: RString) -> Result<(), Error> {
+        let bytes = data.to_bytes();
+        let inner = rb_self.0.read().unwrap();
+        if let Some(ref tx) = inner.tx {
+            rt::try_block_on(tx.send(bytes).map_err(mpsc_send_error_to_magnus))?;
+        }
+        Ok(())
+    }
+
+    /// Ruby: `close` to close the sender
+    pub fn close(&self) {
+        let mut inner = self.0.write().unwrap();
+        inner.tx.take();
+        inner.rx.take();
+    }
+}
+
+impl TryFrom<&BodySender> for ReceiverStream<Bytes> {
+    type Error = magnus::Error;
+
+    fn try_from(sender: &BodySender) -> Result<Self, Self::Error> {
+        sender
+            .0
+            .write()
+            .unwrap()
+            .rx
+            .take()
+            .map(ReceiverStream::new)
+            .ok_or_else(memory_error)
+    }
+}
+
+/// A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].
+pub struct ReceiverStream<T> {
+    inner: mpsc::Receiver<T>,
+}
+
+impl<T> ReceiverStream<T> {
+    /// Create a new [`ReceiverStream`].
+    #[inline]
+    pub fn new(recv: mpsc::Receiver<T>) -> Self {
+        Self { inner: recv }
+    }
+}
+
+impl<T> Stream for ReceiverStream<T> {
+    type Item = T;
+
+    #[inline]
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.inner.poll_recv(cx)
+    }
+
+    /// Returns the bounds of the stream based on the underlying receiver.
+    ///
+    /// For open channels, it returns `(receiver.len(), None)`.
+    ///
+    /// For closed channels, it returns `(receiver.len(), Some(used_capacity))`
+    /// where `used_capacity` is calculated as `receiver.max_capacity() -
+    /// receiver.capacity()`. This accounts for any [`Permit`] that is still
+    /// able to send a message.
+    ///
+    /// [`Permit`]: struct@tokio::sync::mpsc::Permit
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if self.inner.is_closed() {
+            let used_capacity = self.inner.max_capacity() - self.inner.capacity();
+            (self.inner.len(), Some(used_capacity))
+        } else {
+            (self.inner.len(), None)
+        }
+    }
+}

data/src/client/body.rs

@@ -0,0 +1,57 @@
+mod form;
+mod json;
+mod stream;
+
+use bytes::Bytes;
+use futures_util::StreamExt;
+use magnus::{
+    Error, Module, Object, RModule, RString, Ruby, TryConvert, Value, function, method,
+    typed_data::Obj,
+};
+
+pub use self::{
+    form::Form,
+    json::Json,
+    stream::{BodyReceiver, BodySender, ReceiverStream},
+};
+
+/// Represents the body of an HTTP request.
+/// Supports text, bytes, and streaming bodies (Proc/Enumerator).
+pub enum Body {
+    /// Static bytes body
+    Bytes(Bytes),
+    /// Streaming body
+    Stream(ReceiverStream<Bytes>),
+}
+
+impl TryConvert for Body {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        if let Ok(s) = RString::try_convert(val) {
+            return Ok(Body::Bytes(s.to_bytes()));
+        }
+
+        let obj = Obj::<BodySender>::try_convert(val)?;
+        let stream = ReceiverStream::try_from(&*obj)?;
+        Ok(Body::Stream(stream))
+    }
+}
+
+impl From<Body> for wreq::Body {
+    fn from(body: Body) -> Self {
+        match body {
+            Body::Bytes(b) => wreq::Body::from(b),
+            Body::Stream(stream) => {
+                let try_stream = stream.map(Ok::<Bytes, std::io::Error>);
+                wreq::Body::wrap_stream(try_stream)
+            }
+        }
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let sender_class = gem_module.define_class("BodySender", ruby.class_object())?;
+    sender_class.define_singleton_method("new", function!(BodySender::new, -1))?;
+    sender_class.define_method("push", method!(BodySender::push, 1))?;
+    sender_class.define_method("close", magnus::method!(BodySender::close, 0))?;
+    Ok(())
+}

data/src/client/param.rs

@@ -0,0 +1,19 @@
+use indexmap::IndexMap;
+use serde::{Deserialize, Serialize};
+
+/// Represents HTTP parameters from Python as either a mapping or a sequence of key-value pairs.
+pub type Params = IndexMap<String, ParamValue>;
+
+/// Represents a single parameter value that can be automatically converted from Python types.
+#[derive(Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ParamValue {
+    /// A boolean value from Python `bool`.
+    Boolean(bool),
+    /// An integer value from Python `int`.
+    Number(isize),
+    /// A floating-point value from Python `float`.
+    Float64(f64),
+    /// A string value from Python `str`.
+    String(String),
+}

data/src/client/query.rs

@@ -0,0 +1,2 @@
+/// Alias for query parameters.
+pub type Query = super::param::Params;