wreq 1.2.3-x64-mingw-ucrt

data/src/cookie.rs

@@ -0,0 +1,312 @@
+use std::{fmt, sync::Arc, time::SystemTime};
+
+use bytes::Bytes;
+use cookie::{Cookie as RawCookie, Expiration, ParseError, time::Duration};
+use magnus::{
+    Error, Module, Object, RHash, RModule, RString, Ruby, TryConvert, Value, function, method,
+    r_hash::ForEach, typed_data::Obj, value::ReprValue,
+};
+use wreq::header::{self, HeaderMap, HeaderValue};
+
+use crate::{error::header_value_error_to_magnus, gvl};
+
+define_ruby_enum!(
+    /// The Cookie SameSite attribute.
+    const,
+    SameSite,
+    "Wreq::SameSite",
+    cookie::SameSite,
+    Strict,
+    Lax,
+    None,
+);
+
+/// A single HTTP cookie.
+#[derive(Clone)]
+#[magnus::wrap(class = "Wreq::Cookie", free_immediately, size)]
+pub struct Cookie(RawCookie<'static>);
+
+/// A collection of HTTP cookies.
+#[derive(Default)]
+pub struct Cookies(pub Vec<HeaderValue>);
+
+/// A good default `CookieStore` implementation.
+///
+/// This is the implementation used when simply calling `cookie_store(true)`.
+/// This type is exposed to allow creating one and filling it with some
+/// existing cookies more easily, before creating a `Client`.
+#[derive(Clone, Default)]
+#[magnus::wrap(class = "Wreq::Jar", free_immediately, size)]
+pub struct Jar(pub Arc<wreq::cookie::Jar>);
+
+// ===== impl Cookie =====
+
+impl Cookie {
+    /// Create a new [`Cookie`].
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        let args =
+            magnus::scan_args::scan_args::<(String, String), (), (), (), magnus::RHash, ()>(args)?;
+        #[allow(clippy::type_complexity)]
+        let keywords: magnus::scan_args::KwArgs<
+            (),
+            (
+                Option<String>,
+                Option<String>,
+                Option<u64>,
+                Option<f64>,
+                Option<bool>,
+                Option<bool>,
+                Option<Obj<SameSite>>,
+            ),
+            (),
+        > = magnus::scan_args::get_kwargs(
+            args.keywords,
+            &[],
+            &[
+                "domain",
+                "path",
+                "max_age",
+                "expires",
+                "http_only",
+                "secure",
+                "same_site",
+            ],
+        )?;
+
+        let (name, value) = args.required;
+
+        let mut cookie = RawCookie::new(name, value);
+
+        if let Some(domain) = keywords.optional.0 {
+            cookie.set_domain(domain);
+        }
+
+        if let Some(path) = keywords.optional.1 {
+            cookie.set_path(path);
+        }
+
+        if let Some(max_age) = keywords.optional.2 {
+            cookie.set_max_age(Duration::seconds(max_age as i64));
+        }
+
+        if let Some(expires) = keywords.optional.3 {
+            let duration = std::time::Duration::from_secs_f64(expires);
+            if let Some(system_time) = SystemTime::UNIX_EPOCH.checked_add(duration) {
+                cookie.set_expires(Expiration::DateTime(system_time.into()));
+            }
+        }
+
+        cookie.set_http_only(keywords.optional.4);
+        cookie.set_secure(keywords.optional.5);
+
+        if let Some(same_site) = keywords.optional.6 {
+            cookie.set_same_site(same_site.into_ffi());
+        }
+
+        Ok(Self(cookie))
+    }
+
+    /// The name of the cookie.
+    #[inline]
+    pub fn name(&self) -> &str {
+        self.0.name()
+    }
+
+    /// The value of the cookie.
+    #[inline]
+    pub fn value(&self) -> &str {
+        self.0.value()
+    }
+
+    /// Returns true if the 'HttpOnly' directive is enabled.
+    #[inline]
+    pub fn http_only(&self) -> bool {
+        self.0.http_only().unwrap_or(false)
+    }
+
+    /// Returns true if the 'Secure' directive is enabled.
+    #[inline]
+    pub fn secure(&self) -> bool {
+        self.0.secure().unwrap_or(false)
+    }
+
+    /// Returns true if  'SameSite' directive is 'Lax'.
+    #[inline]
+    pub fn same_site_lax(&self) -> bool {
+        self.0.same_site() == Some(cookie::SameSite::Lax)
+    }
+
+    /// Returns true if  'SameSite' directive is 'Strict'.
+    #[inline]
+    pub fn same_site_strict(&self) -> bool {
+        self.0.same_site() == Some(cookie::SameSite::Strict)
+    }
+
+    /// Returns the path directive of the cookie, if set.
+    #[inline]
+    pub fn path(&self) -> Option<&str> {
+        self.0.path()
+    }
+
+    /// Returns the domain directive of the cookie, if set.
+    #[inline]
+    pub fn domain(&self) -> Option<&str> {
+        self.0.domain()
+    }
+
+    /// Get the Max-Age information.
+    #[inline]
+    pub fn max_age(&self) -> Option<i64> {
+        self.0.max_age().map(|d| d.whole_seconds())
+    }
+
+    /// The cookie expiration time.
+    #[inline]
+    pub fn expires(&self) -> Option<f64> {
+        match self.0.expires() {
+            Some(Expiration::DateTime(offset)) => {
+                let system_time = SystemTime::from(offset);
+                system_time
+                    .duration_since(SystemTime::UNIX_EPOCH)
+                    .ok()
+                    .map(|d| d.as_secs_f64())
+            }
+            None | Some(Expiration::Session) => None,
+        }
+    }
+}
+
+impl Cookie {
+    /// Parse cookies from a `HeaderMap`.
+    pub fn extract_headers_cookies(headers: &HeaderMap) -> Vec<Cookie> {
+        headers
+            .get_all(header::SET_COOKIE)
+            .iter()
+            .map(Cookie::parse)
+            .flat_map(Result::ok)
+            .map(RawCookie::into_owned)
+            .map(Cookie)
+            .collect()
+    }
+
+    fn parse<'a>(value: &'a HeaderValue) -> Result<RawCookie<'a>, ParseError> {
+        std::str::from_utf8(value.as_bytes())
+            .map_err(cookie::ParseError::from)
+            .and_then(RawCookie::parse)
+    }
+}
+
+impl fmt::Display for Cookie {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+// ===== impl Cookies =====
+
+impl TryConvert for Cookies {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        // try extract uncompressed cookies
+        if let Some(rhash) = RHash::from_value(value) {
+            let mut cookies = Vec::new();
+            rhash.foreach(|name: RString, value: RString| {
+                let cookie = format!("{name}={value}");
+                let header_value = HeaderValue::from_maybe_shared(Bytes::from(cookie))
+                    .map_err(header_value_error_to_magnus)?;
+                cookies.push(header_value);
+                Ok(ForEach::Continue)
+            })?;
+
+            return Ok(Self(cookies));
+        }
+
+        // try extract compressed cookies
+        if let Some(cookies) = RString::from_value(value) {
+            return Ok(Self(vec![
+                HeaderValue::from_maybe_shared(cookies.to_bytes())
+                    .map_err(header_value_error_to_magnus)?,
+            ]));
+        }
+
+        Ok(Self::default())
+    }
+}
+
+// ===== impl Jar =====
+
+impl Jar {
+    /// Create a new [`Jar`] with an empty cookie store.
+    pub fn new() -> Self {
+        Jar(Arc::new(wreq::cookie::Jar::default()))
+    }
+
+    /// Get all cookies.
+    pub fn get_all(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let cookies: Vec<Cookie> = rb_self
+            .0
+            .get_all()
+            .map(RawCookie::from)
+            .map(Cookie)
+            .collect();
+        let ary = ruby.ary_new_capa(cookies.len());
+        for cookie in cookies {
+            ary.push(cookie)?;
+        }
+        Ok(ary.as_value())
+    }
+
+    /// Add a cookie to this jar.
+    pub fn add(&self, cookie: Value, url: String) {
+        if let Ok(cookie) = Obj::<Cookie>::try_convert(cookie) {
+            gvl::nogvl(|| self.0.add(cookie.0.clone(), &url))
+        }
+
+        if let Ok(cookie_str) = String::try_convert(cookie) {
+            gvl::nogvl(|| self.0.add(cookie_str.as_ref(), &url))
+        }
+    }
+
+    /// Remove a cookie from this jar by name and URL.
+    pub fn remove(&self, name: String, url: String) {
+        gvl::nogvl(|| self.0.remove(name, &url))
+    }
+
+    /// Clear all cookies in this jar.
+    pub fn clear(&self) {
+        gvl::nogvl(|| self.0.clear())
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    // SameSite enum
+    let same_site_class = gem_module.define_class("SameSite", ruby.class_object())?;
+    same_site_class.const_set("Strict", SameSite::Strict)?;
+    same_site_class.const_set("Lax", SameSite::Lax)?;
+    same_site_class.const_set("None", SameSite::None)?;
+
+    // Cookie class
+    let cookie_class = gem_module.define_class("Cookie", ruby.class_object())?;
+    cookie_class.define_singleton_method("new", function!(Cookie::new, -1))?;
+    cookie_class.define_method("name", method!(Cookie::name, 0))?;
+    cookie_class.define_method("value", method!(Cookie::value, 0))?;
+    cookie_class.define_method("http_only", method!(Cookie::http_only, 0))?;
+    cookie_class.define_method("http_only?", method!(Cookie::http_only, 0))?;
+    cookie_class.define_method("secure", method!(Cookie::secure, 0))?;
+    cookie_class.define_method("secure?", method!(Cookie::secure, 0))?;
+    cookie_class.define_method("same_site_lax?", method!(Cookie::same_site_lax, 0))?;
+    cookie_class.define_method("same_site_strict?", method!(Cookie::same_site_strict, 0))?;
+    cookie_class.define_method("path", method!(Cookie::path, 0))?;
+    cookie_class.define_method("domain", method!(Cookie::domain, 0))?;
+    cookie_class.define_method("max_age", method!(Cookie::max_age, 0))?;
+    cookie_class.define_method("expires", method!(Cookie::expires, 0))?;
+
+    // Jar class
+    let jar_class = gem_module.define_class("Jar", ruby.class_object())?;
+    jar_class.define_singleton_method("new", function!(Jar::new, 0))?;
+    jar_class.define_method("get_all", method!(Jar::get_all, 0))?;
+    jar_class.define_method("add", method!(Jar::add, 2))?;
+    jar_class.define_method("remove", method!(Jar::remove, 2))?;
+    jar_class.define_method("clear", method!(Jar::clear, 0))?;
+
+    Ok(())
+}

data/src/emulate.rs

@@ -0,0 +1,376 @@
+use magnus::{
+    Error, Module, Object, RHash, RModule, Ruby, TryConvert, Value, function, method,
+    typed_data::{Inspect, Obj},
+};
+
+define_ruby_enum!(
+    /// An emulation profile.
+    const,
+    Profile,
+    "Wreq::Profile",
+    wreq_util::Profile,
+    Chrome100,
+    Chrome101,
+    Chrome104,
+    Chrome105,
+    Chrome106,
+    Chrome107,
+    Chrome108,
+    Chrome109,
+    Chrome110,
+    Chrome114,
+    Chrome116,
+    Chrome117,
+    Chrome118,
+    Chrome119,
+    Chrome120,
+    Chrome123,
+    Chrome124,
+    Chrome126,
+    Chrome127,
+    Chrome128,
+    Chrome129,
+    Chrome130,
+    Chrome131,
+    Chrome132,
+    Chrome133,
+    Chrome134,
+    Chrome135,
+    Chrome136,
+    Chrome137,
+    Chrome138,
+    Chrome139,
+    Chrome140,
+    Chrome141,
+    Chrome142,
+    Chrome143,
+    Chrome144,
+    Chrome145,
+    Chrome146,
+    Chrome147,
+    Chrome148,
+    Chrome149,
+
+    Edge101,
+    Edge122,
+    Edge127,
+    Edge131,
+    Edge134,
+    Edge135,
+    Edge136,
+    Edge137,
+    Edge138,
+    Edge139,
+    Edge140,
+    Edge141,
+    Edge142,
+    Edge143,
+    Edge144,
+    Edge145,
+    Edge146,
+    Edge147,
+    Edge148,
+
+    Firefox109,
+    Firefox117,
+    Firefox128,
+    Firefox133,
+    Firefox135,
+    FirefoxPrivate135,
+    FirefoxAndroid135,
+    Firefox136,
+    FirefoxPrivate136,
+    Firefox139,
+    Firefox142,
+    Firefox143,
+    Firefox144,
+    Firefox145,
+    Firefox146,
+    Firefox147,
+    Firefox148,
+    Firefox149,
+    Firefox150,
+    Firefox151,
+
+    SafariIos17_2,
+    SafariIos17_4_1,
+    SafariIos16_5,
+    Safari15_3,
+    Safari15_5,
+    Safari15_6_1,
+    Safari16,
+    Safari16_5,
+    Safari17_0,
+    Safari17_2_1,
+    Safari17_4_1,
+    Safari17_5,
+    Safari17_6,
+    Safari18,
+    SafariIPad18,
+    Safari18_2,
+    Safari18_3,
+    Safari18_3_1,
+    SafariIos18_1_1,
+    Safari18_5,
+    Safari26,
+    Safari26_1,
+    Safari26_2,
+    Safari26_3,
+    Safari26_4,
+    SafariIos26,
+    SafariIos26_2,
+    SafariIPad26,
+    SafariIpad26_2,
+
+    OkHttp3_9,
+    OkHttp3_11,
+    OkHttp3_13,
+    OkHttp3_14,
+    OkHttp4_9,
+    OkHttp4_10,
+    OkHttp4_12,
+    OkHttp5,
+
+    Opera116,
+    Opera117,
+    Opera118,
+    Opera119,
+    Opera120,
+    Opera121,
+    Opera122,
+    Opera123,
+    Opera124,
+    Opera125,
+    Opera126,
+    Opera127,
+    Opera128,
+    Opera129,
+    Opera130,
+    Opera131,
+);
+
+define_ruby_enum!(
+    /// An emulation profile for OS.
+    const,
+    Platform,
+    "Wreq::Platform",
+    wreq_util::Platform,
+    Windows,
+    MacOS,
+    Linux,
+    Android,
+    IOS,
+);
+
+/// A struct to represent the `EmulationOption` class.
+#[derive(Clone)]
+#[magnus::wrap(class = "Wreq::Emulation", free_immediately, size)]
+pub struct Emulation(pub wreq_util::Emulation);
+
+// ===== impl Profile =====
+
+impl Profile {
+    pub fn to_s(&self) -> String {
+        self.into_ffi().inspect()
+    }
+}
+
+// ===== impl Platform =====
+
+impl Platform {
+    pub fn to_s(&self) -> String {
+        self.into_ffi().inspect()
+    }
+}
+
+// ===== impl Emulation =====
+
+impl Emulation {
+    fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+        let mut profile = None;
+        let mut platform = None;
+        let mut http2 = None;
+        let mut headers = None;
+
+        if let Some(hash) = args.first().and_then(|v| RHash::from_value(*v)) {
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(profile))) {
+                profile = Some(Obj::<Profile>::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(platform))) {
+                platform = Some(Obj::<Platform>::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(http2))) {
+                http2 = Some(bool::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(headers))) {
+                headers = Some(bool::try_convert(v)?);
+            }
+        }
+
+        let emulation = wreq_util::Emulation::builder()
+            .profile(profile.map(|obj| obj.into_ffi()).unwrap_or_default())
+            .platform(platform.map(|os| os.into_ffi()).unwrap_or_default())
+            .http2(http2.unwrap_or(true))
+            .headers(headers.unwrap_or(true))
+            .build();
+
+        Ok(Self(emulation))
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    // Profile enum binding
+    let profile = gem_module.define_class("Profile", ruby.class_object())?;
+    profile.define_method("to_s", method!(Profile::to_s, 0))?;
+    profile.const_set("Chrome100", Profile::Chrome100)?;
+    profile.const_set("Chrome101", Profile::Chrome101)?;
+    profile.const_set("Chrome104", Profile::Chrome104)?;
+    profile.const_set("Chrome105", Profile::Chrome105)?;
+    profile.const_set("Chrome106", Profile::Chrome106)?;
+    profile.const_set("Chrome107", Profile::Chrome107)?;
+    profile.const_set("Chrome108", Profile::Chrome108)?;
+    profile.const_set("Chrome109", Profile::Chrome109)?;
+    profile.const_set("Chrome110", Profile::Chrome110)?;
+    profile.const_set("Chrome114", Profile::Chrome114)?;
+    profile.const_set("Chrome116", Profile::Chrome116)?;
+    profile.const_set("Chrome117", Profile::Chrome117)?;
+    profile.const_set("Chrome118", Profile::Chrome118)?;
+    profile.const_set("Chrome119", Profile::Chrome119)?;
+    profile.const_set("Chrome120", Profile::Chrome120)?;
+    profile.const_set("Chrome123", Profile::Chrome123)?;
+    profile.const_set("Chrome124", Profile::Chrome124)?;
+    profile.const_set("Chrome126", Profile::Chrome126)?;
+    profile.const_set("Chrome127", Profile::Chrome127)?;
+    profile.const_set("Chrome128", Profile::Chrome128)?;
+    profile.const_set("Chrome129", Profile::Chrome129)?;
+    profile.const_set("Chrome130", Profile::Chrome130)?;
+    profile.const_set("Chrome131", Profile::Chrome131)?;
+    profile.const_set("Chrome132", Profile::Chrome132)?;
+    profile.const_set("Chrome133", Profile::Chrome133)?;
+    profile.const_set("Chrome134", Profile::Chrome134)?;
+    profile.const_set("Chrome135", Profile::Chrome135)?;
+    profile.const_set("Chrome136", Profile::Chrome136)?;
+    profile.const_set("Chrome137", Profile::Chrome137)?;
+    profile.const_set("Chrome138", Profile::Chrome138)?;
+    profile.const_set("Chrome139", Profile::Chrome139)?;
+    profile.const_set("Chrome140", Profile::Chrome140)?;
+    profile.const_set("Chrome141", Profile::Chrome141)?;
+    profile.const_set("Chrome142", Profile::Chrome142)?;
+    profile.const_set("Chrome143", Profile::Chrome143)?;
+    profile.const_set("Chrome144", Profile::Chrome144)?;
+    profile.const_set("Chrome145", Profile::Chrome145)?;
+    profile.const_set("Chrome146", Profile::Chrome146)?;
+    profile.const_set("Chrome147", Profile::Chrome147)?;
+    profile.const_set("Chrome148", Profile::Chrome148)?;
+
+    profile.const_set("Edge101", Profile::Edge101)?;
+    profile.const_set("Edge122", Profile::Edge122)?;
+    profile.const_set("Edge127", Profile::Edge127)?;
+    profile.const_set("Edge131", Profile::Edge131)?;
+    profile.const_set("Edge134", Profile::Edge134)?;
+    profile.const_set("Edge135", Profile::Edge135)?;
+    profile.const_set("Edge136", Profile::Edge136)?;
+    profile.const_set("Edge137", Profile::Edge137)?;
+    profile.const_set("Edge138", Profile::Edge138)?;
+    profile.const_set("Edge139", Profile::Edge139)?;
+    profile.const_set("Edge140", Profile::Edge140)?;
+    profile.const_set("Edge141", Profile::Edge141)?;
+    profile.const_set("Edge142", Profile::Edge142)?;
+    profile.const_set("Edge143", Profile::Edge143)?;
+    profile.const_set("Edge144", Profile::Edge144)?;
+    profile.const_set("Edge145", Profile::Edge145)?;
+    profile.const_set("Edge146", Profile::Edge146)?;
+    profile.const_set("Edge147", Profile::Edge147)?;
+    profile.const_set("Edge148", Profile::Edge148)?;
+
+    profile.const_set("Firefox109", Profile::Firefox109)?;
+    profile.const_set("Firefox117", Profile::Firefox117)?;
+    profile.const_set("Firefox128", Profile::Firefox128)?;
+    profile.const_set("Firefox133", Profile::Firefox133)?;
+    profile.const_set("Firefox135", Profile::Firefox135)?;
+    profile.const_set("FirefoxPrivate135", Profile::FirefoxPrivate135)?;
+    profile.const_set("FirefoxAndroid135", Profile::FirefoxAndroid135)?;
+    profile.const_set("Firefox136", Profile::Firefox136)?;
+    profile.const_set("FirefoxPrivate136", Profile::FirefoxPrivate136)?;
+    profile.const_set("Firefox139", Profile::Firefox139)?;
+    profile.const_set("Firefox142", Profile::Firefox142)?;
+    profile.const_set("Firefox143", Profile::Firefox143)?;
+    profile.const_set("Firefox144", Profile::Firefox144)?;
+    profile.const_set("Firefox145", Profile::Firefox145)?;
+    profile.const_set("Firefox146", Profile::Firefox146)?;
+    profile.const_set("Firefox147", Profile::Firefox147)?;
+    profile.const_set("Firefox148", Profile::Firefox148)?;
+    profile.const_set("Firefox149", Profile::Firefox149)?;
+    profile.const_set("Firefox150", Profile::Firefox150)?;
+    profile.const_set("Firefox151", Profile::Firefox151)?;
+
+    profile.const_set("SafariIos17_2", Profile::SafariIos17_2)?;
+    profile.const_set("SafariIos17_4_1", Profile::SafariIos17_4_1)?;
+    profile.const_set("SafariIos16_5", Profile::SafariIos16_5)?;
+    profile.const_set("Safari15_3", Profile::Safari15_3)?;
+    profile.const_set("Safari15_5", Profile::Safari15_5)?;
+    profile.const_set("Safari15_6_1", Profile::Safari15_6_1)?;
+    profile.const_set("Safari16", Profile::Safari16)?;
+    profile.const_set("Safari16_5", Profile::Safari16_5)?;
+    profile.const_set("Safari17_0", Profile::Safari17_0)?;
+    profile.const_set("Safari17_2_1", Profile::Safari17_2_1)?;
+    profile.const_set("Safari17_4_1", Profile::Safari17_4_1)?;
+    profile.const_set("Safari17_5", Profile::Safari17_5)?;
+    profile.const_set("Safari17_6", Profile::Safari17_6)?;
+    profile.const_set("Safari18", Profile::Safari18)?;
+    profile.const_set("SafariIPad18", Profile::SafariIPad18)?;
+    profile.const_set("Safari18_2", Profile::Safari18_2)?;
+    profile.const_set("Safari18_3", Profile::Safari18_3)?;
+    profile.const_set("Safari18_3_1", Profile::Safari18_3_1)?;
+    profile.const_set("SafariIos18_1_1", Profile::SafariIos18_1_1)?;
+    profile.const_set("Safari18_5", Profile::Safari18_5)?;
+    profile.const_set("Safari26", Profile::Safari26)?;
+    profile.const_set("Safari26_1", Profile::Safari26_1)?;
+    profile.const_set("Safari26_2", Profile::Safari26_2)?;
+    profile.const_set("Safari26_3", Profile::Safari26_3)?;
+    profile.const_set("Safari26_4", Profile::Safari26_4)?;
+    profile.const_set("SafariIos26", Profile::SafariIos26)?;
+    profile.const_set("SafariIos26_2", Profile::SafariIos26_2)?;
+    profile.const_set("SafariIPad26", Profile::SafariIPad26)?;
+    profile.const_set("SafariIpad26_2", Profile::SafariIpad26_2)?;
+
+    profile.const_set("OkHttp3_9", Profile::OkHttp3_9)?;
+    profile.const_set("OkHttp3_11", Profile::OkHttp3_11)?;
+    profile.const_set("OkHttp3_13", Profile::OkHttp3_13)?;
+    profile.const_set("OkHttp3_14", Profile::OkHttp3_14)?;
+    profile.const_set("OkHttp4_9", Profile::OkHttp4_9)?;
+    profile.const_set("OkHttp4_10", Profile::OkHttp4_10)?;
+    profile.const_set("OkHttp4_12", Profile::OkHttp4_12)?;
+    profile.const_set("OkHttp5", Profile::OkHttp5)?;
+
+    profile.const_set("Opera116", Profile::Opera116)?;
+    profile.const_set("Opera117", Profile::Opera117)?;
+    profile.const_set("Opera118", Profile::Opera118)?;
+    profile.const_set("Opera119", Profile::Opera119)?;
+    profile.const_set("Opera120", Profile::Opera120)?;
+    profile.const_set("Opera121", Profile::Opera121)?;
+    profile.const_set("Opera122", Profile::Opera122)?;
+    profile.const_set("Opera123", Profile::Opera123)?;
+    profile.const_set("Opera124", Profile::Opera124)?;
+    profile.const_set("Opera125", Profile::Opera125)?;
+    profile.const_set("Opera126", Profile::Opera126)?;
+    profile.const_set("Opera127", Profile::Opera127)?;
+    profile.const_set("Opera128", Profile::Opera128)?;
+    profile.const_set("Opera129", Profile::Opera129)?;
+    profile.const_set("Opera130", Profile::Opera130)?;
+    profile.const_set("Opera131", Profile::Opera131)?;
+
+    // Platform enum binding
+    let platform = gem_module.define_class("Platform", ruby.class_object())?;
+    platform.define_method("to_s", method!(Platform::to_s, 0))?;
+    platform.const_set("Windows", Platform::Windows)?;
+    platform.const_set("MacOS", Platform::MacOS)?;
+    platform.const_set("Linux", Platform::Linux)?;
+    platform.const_set("Android", Platform::Android)?;
+    platform.const_set("IOS", Platform::IOS)?;
+
+    // Emulation class binding
+    let emulation = gem_module.define_class("Emulation", ruby.class_object())?;
+    emulation.define_singleton_method("new", function!(Emulation::new, -1))?;
+    Ok(())
+}