feat(emulate): parse tls/http2

Cargo.toml

@@ -33,6 +33,7 @@ wreq = { git = "https://github.com/0x676e67/wreq", features = [
 ] }
 wreq-util = { git = "https://github.com/0x676e67/wreq-util", features = ["emulation-compression"] }
 serde = { version = "1.0.228", features = ["derive"] }
+serde_json = { version = "1.0", features = ["preserve_order"] }
 serde_magnus = "0.11.0"
 indexmap = { version = "2.14.0", features = ["serde"] }
 cookie = "0.18.1"

lib/wreq_ruby/emulate.rb

@@ -227,5 +227,21 @@ class Emulation
       def self.new(profile: nil, platform: nil, http2: true, headers: true)
       end
     end
+
+    unless method_defined?(:parse)
+      # Parses a string representation of an emulation option.
+      # @param json [String] String to parse into an TLS/HTTP2 emulation option
+      # @param permute_extensions [Boolean, nil] Whether to permute extensions (optional)
+      # @param psk_skip_session_ticket [Boolean] Whether to skip session ticket for PSK
+      # @param aes_hw_override [Boolean, nil] Override AES hardware support (optional)
+      # @param random_aes_hw_override [Boolean] Whether to randomly override AES
+      # @return [Wreq::Emulation] Parsed emulation option
+      def self.parse(json,
+        permute_extensions: nil,
+        psk_skip_session_ticket: false,
+        aes_hw_override: nil,
+        random_aes_hw_override: false)
+      end
+    end
   end
 end

src/client.rs

@@ -26,6 +26,15 @@ use crate::{
     http::Method,
 };
 
+macro_rules! request {
+    ($args:expr, $required:ty) => {{
+        let args = magnus::scan_args::scan_args::<$required, (), (), (), magnus::RHash, ()>($args)?;
+        let required = args.required;
+        let request = crate::client::req::Request::new(&ruby!(), args.keywords)?;
+        (required, request)
+    }};
+}
+
 /// A builder for `Client`.
 #[derive(Default, Deserialize)]
 struct Builder {
@@ -170,7 +179,7 @@ impl Client {
                 let mut builder = wreq::Client::builder();
 
                 // Emulation options.
-                apply_option!(set_if_some_inner, builder, params.emulation, emulation);
+                apply_option!(set_if_some, builder, params.emulation, emulation);
 
                 // User agent options.
                 apply_option!(set_if_some, builder, params.user_agent, user_agent);
@@ -316,63 +325,63 @@ impl Client {
     /// Send a HTTP request.
     #[inline]
     pub fn request(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((method, url), request) = extract_request!(args, (Obj<Method>, String));
+        let ((method, url), request) = request!(args, (Obj<Method>, String));
         execute_request(rb_self.0.clone(), *method, url, request)
     }
 
     /// Send a GET request.
     #[inline]
     pub fn get(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::GET, url, request)
     }
 
     /// Send a POST request.
     #[inline]
     pub fn post(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::POST, url, request)
     }
 
     /// Send a PUT request.
     #[inline]
     pub fn put(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::PUT, url, request)
     }
 
     /// Send a DELETE request.
     #[inline]
     pub fn delete(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::DELETE, url, request)
     }
 
     /// Send a HEAD request.
     #[inline]
     pub fn head(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::HEAD, url, request)
     }
 
     /// Send an OPTIONS request.
     #[inline]
     pub fn options(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::OPTIONS, url, request)
     }
 
     /// Send a TRACE request.
     #[inline]
     pub fn trace(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::TRACE, url, request)
     }
 
     /// Send a PATCH request.
     #[inline]
     pub fn patch(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = request!(args, (String,));
         execute_request(rb_self.0.clone(), Method::PATCH, url, request)
     }
 }

src/client/req.rs

@@ -142,7 +142,7 @@ pub fn execute_request<U: AsRef<str>>(
         let mut builder = client.request(method.into_ffi(), url.as_ref());
 
         // Emulation options.
-        apply_option!(set_if_some_inner, builder, request.emulation, emulation);
+        apply_option!(set_if_some, builder, request.emulation, emulation);
 
         // Version options.
         apply_option!(set_if_some, builder, request.version, version);