Merge pull request #298 from mattsse/ef-remove-async-std

Remove async-std support

Author: Sytten

.github/workflows/ci.yml

@@ -83,11 +83,5 @@ jobs:
     steps:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
-      - name: Check examples with default features
-        run: cargo check --examples --features tokio-runtime,bytes
-      - name: Check async-std examples
-        run: cargo check --examples --features async-std-runtime
-      - name: Check fetcher examples
-        run: |
-          cargo check --example fetcher --features _fetcher-native-tokio
-          cargo check --example fetcher-async-std --features async-std-runtime,_fetcher-native-async-std
+      - name: Check examples
+        run: cargo check --examples --features fetcher

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Breaking Changes
+
+- Removed async-std support
+
 ### Changed
 
 - Updated edition to 2024

Cargo.toml

@@ -14,12 +14,8 @@ keywords = ["chrome", "chromedriver", "puppeteer", "automation"]
 categories = ["web-programming", "api-bindings", "development-tools::testing"]
 
 [dependencies]
-async-tungstenite = "0.32.0"
+async-tungstenite = { version = "0.32.0", features = ["tokio-runtime"] }
 serde = { version = "1", features = ["derive"] }
-async-std = { version = "1", features = [
-  "attributes",
-  "unstable",
-], optional = true }
 futures = "0.3"
 chromiumoxide_types = { path = "chromiumoxide_types", version = "0.8" }
 chromiumoxide_cdp = { path = "chromiumoxide_cdp", version = "0.8" }
@@ -31,15 +27,14 @@ url = "2"
 base64 = "0.22"
 fnv = "1"
 futures-timer = "3"
-cfg-if = "1"
 tokio = { version = "1", features = [
   "rt",
   "rt-multi-thread",
   "time",
   "fs",
   "macros",
   "process",
-], optional = true }
+] }
 tracing = "0.1"
 pin-project-lite = "0.2"
 dunce = "1"
@@ -57,37 +52,17 @@ tracing-subscriber = "0.3"
 tokio = { version = "1", features = ["rt-multi-thread", "time", "macros"] }
 
 [features]
-default = ["tokio-runtime", "bytes"]
-async-std-runtime = ["async-std", "async-tungstenite/async-std-runtime"]
-tokio-runtime = ["tokio", "async-tungstenite/tokio-runtime"]
-fetcher = []
+default = ["bytes"]
+fetcher = ["chromiumoxide_fetcher"]
 bytes = ["dep:bytes"]
 serde0 = []
 
-# Temporary features until cargo weak dependencies bug is fixed
-# See https://github.com/rust-lang/cargo/issues/10801
-_fetcher-rustls-async-std = [
-  "fetcher",
-  "chromiumoxide_fetcher/_rustls-async-std",
-]
-_fetcher-rustls-tokio = ["fetcher", "chromiumoxide_fetcher/_rustls-tokio"]
-_fetcher-native-async-std = [
-  "fetcher",
-  "chromiumoxide_fetcher/_native-async-std",
-]
-_fetcher-native-tokio = ["fetcher", "chromiumoxide_fetcher/_native-tokio"]
-
-[[example]]
-name = "wiki-async-std"
-required-features = ["async-std-runtime"]
-
-[[example]]
-name = "fetcher-async-std"
-required-features = ["async-std-runtime", "_fetcher-native-async-std"]
+rustls = ["chromiumoxide_fetcher/rustls"]
+native-tls = ["chromiumoxide_fetcher/native-tls"]
 
 [[example]]
 name = "fetcher"
-required-features = ["_fetcher-native-tokio"]
+required-features = ["fetcher"]
 
 [[test]]
 name = "chromiumoxide_tests"

README.md

@@ -67,15 +67,7 @@ If you need something else, the `Page::execute` function allows for writing your
 
 ### Add chromiumoxide to your project
 
-`chromiumoxide` comes with support for the [`tokio`](https://github.com/tokio-rs/tokio) and [`async-std`](https://github.com/async-rs/async-std) runtimes.
-
-By default `chromiumoxide` is configured with `tokio`.
-
-To use `chromiumoxide` with the `async-std` runtime:
-
-```toml
-chromiumoxide = { version = "0.8.0", default-features = false, features = ["async-std-runtime"] }
-```
+`chromiumoxide` only supports the [`tokio`](https://github.com/tokio-rs/tokio) runtime.
 
 ## Generated Code
 
@@ -90,15 +82,9 @@ All Events are bundled in single enum (`CdpEvent`)
 ## Fetcher
 
 By default `chromiumoxide` will try to find an installed version of chromium on the computer it runs on.
-It is possible to download and install one automatically for some platforms using the `fetcher`.
-
-Ther features are currently a bit messy due to a Cargo bug and will be changed once it is resolved.
-Based on your runtime and TLS configuration you should enable one of the following:
+It is possible to download and install one automatically for some platforms using the `fetcher` feature.
 
-- `_fetcher-rustls-async-std`
-- `_fetcher-rustls-tokio`
-- `_fetcher-native-async-std`
-- `_fetcher-native-tokio`
+You need to enable either the `rustls` or the `native-tls` feature to allow the fetcher to download binaries.
 
 ```rust
 use std::path::Path;

chromiumoxide_fetcher/Cargo.toml

@@ -34,22 +34,14 @@ directories = "6"
 serde = { version = "1", features = ["derive"] }
 tracing = "0.1"
 zip = { version = "0.6", default-features = false, features = ["deflate"] }
-async-std = { version = "1.5", features = ["unstable"], optional = true }
-tokio = { version = "1", features = ["fs"], optional = true }
-reqwest = { version = "0.12", default-features = false, features = [
-  "json",
-], optional = true }
-surf = { version = "2.3", default-features = false, optional = true }
+tokio = { version = "1", features = ["fs", "io-util"] }
+reqwest = { version = "0.12", default-features = false, features = ["json"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows-version = "0.1"
 
 [features]
-default = ["_native-tokio"]
-async-std-runtime = ["async-std", "surf"]
-tokio-runtime = ["tokio", "reqwest"]
+default = ["rustls"]
 
-_rustls-async-std = ["surf/h1-client-rustls", "async-std-runtime"]
-_rustls-tokio = ["reqwest/rustls-tls", "tokio-runtime"]
-_native-async-std = ["surf/h1-client", "async-std-runtime"]
-_native-tokio = ["reqwest/native-tls", "tokio-runtime"]
+rustls = ["reqwest/rustls-tls"]
+native-tls = ["reqwest/native-tls"]

chromiumoxide_fetcher/src/runtime/mod.rs

@@ -1,6 +1,8 @@
+use std::path::{Path, PathBuf};
+
 use anyhow::Context;
 use serde::Deserialize;
-use std::path::{Path, PathBuf};
+use tokio::io::AsyncWriteExt;
 
 use self::zip::ZipArchive;
 
@@ -9,85 +11,6 @@ mod zip;
 #[derive(Debug, Default)]
 pub struct Runtime;
 
-#[cfg(feature = "async-std-runtime")]
-impl Runtime {
-    pub async fn exists(folder_path: &Path) -> bool {
-        async_std::fs::metadata(folder_path).await.is_ok()
-    }
-
-    pub async fn download_json<T>(url: &str) -> anyhow::Result<T>
-    where
-        T: for<'de> Deserialize<'de>,
-    {
-        use surf::http;
-
-        let url = url.parse::<surf::Url>().context("Invalid metadata url")?;
-        let mut res = surf::RequestBuilder::new(http::Method::Get, url)
-            .await
-            .map_err(|e| e.into_inner())
-            .context("Failed to send request to host")?;
-        if res.status() != surf::StatusCode::Ok {
-            anyhow::bail!("Invalid metadata url");
-        }
-        let body = res
-            .body_json::<T>()
-            .await
-            .map_err(|e| e.into_inner().context("Failed to read response body"))?;
-        Ok(body)
-    }
-
-    pub async fn download_text(url: &str) -> anyhow::Result<String> {
-        use surf::http;
-        let url = url.parse::<surf::Url>().context("Invalid metadata url")?;
-        let mut res = surf::RequestBuilder::new(http::Method::Get, url)
-            .await
-            .map_err(|e| e.into_inner())
-            .context("Failed to send request to host")?;
-        if res.status() != surf::StatusCode::Ok {
-            anyhow::bail!("Invalid metadata url");
-        }
-        let body = res
-            .body_string()
-            .await
-            .map_err(|e| e.into_inner().context("Failed to read response body"))?;
-        Ok(body)
-    }
-
-    pub async fn download_file(url: &str, archive_path: &Path) -> anyhow::Result<()> {
-        use async_std::io::WriteExt;
-        use surf::http;
-
-        // Open file
-        let file = async_std::fs::File::create(&archive_path)
-            .await
-            .context("Failed to create archive file")?;
-        let mut file = async_std::io::BufWriter::new(file);
-
-        // Download
-        let url = url.parse::<surf::Url>().context("Invalid archive url")?;
-        let res = surf::RequestBuilder::new(http::Method::Get, url)
-            .await
-            .map_err(|e| e.into_inner())
-            .context("Failed to send request to host")?;
-        if res.status() != surf::StatusCode::Ok {
-            anyhow::bail!("Invalid archive url");
-        }
-        async_std::io::copy(res, &mut file)
-            .await
-            .context("Failed to write to archive file")?;
-
-        // Flush to disk
-        file.flush().await.context("Failed to flush to disk")?;
-        Ok(())
-    }
-
-    pub async fn unzip(archive_path: PathBuf, folder_path: PathBuf) -> anyhow::Result<()> {
-        async_std::task::spawn_blocking(move || do_unzip(&archive_path, &folder_path)).await?;
-        Ok(())
-    }
-}
-
-#[cfg(feature = "tokio-runtime")]
 impl Runtime {
     pub async fn exists(folder_path: &Path) -> bool {
         tokio::fs::metadata(folder_path).await.is_ok()
@@ -128,8 +51,6 @@ impl Runtime {
     }
 
     pub async fn download_file(url: &str, archive_path: &Path) -> anyhow::Result<()> {
-        use tokio::io::AsyncWriteExt;
-
         // Open file
         let file = tokio::fs::File::create(&archive_path)
             .await

chromiumoxide_pdl/src/build/generator.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::fs;
-use std::io::{self, Error, ErrorKind};
+use std::io::{self, Error};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
@@ -163,9 +163,7 @@ impl Generator {
     pub fn compile_pdls<P: AsRef<Path>>(&mut self, pdls: &[P]) -> io::Result<()> {
         let target: PathBuf = self.out_dir.clone().map(Ok).unwrap_or_else(|| {
             std::env::var_os("OUT_DIR")
-                .ok_or_else(|| {
-                    Error::new(ErrorKind::Other, "OUT_DIR environment variable is not set")
-                })
+                .ok_or_else(|| Error::other("OUT_DIR environment variable is not set"))
                 .map(Into::into)
         })?;
 
@@ -174,24 +172,20 @@ impl Generator {
         for path in pdls {
             let path = path.as_ref();
             let file_name = path.file_stem().ok_or_else(|| {
-                Error::new(
-                    ErrorKind::Other,
-                    format!("Failed to read file name for {}", path.display()),
-                )
+                Error::other(format!("Failed to read file name for {}", path.display()))
             })?;
             let mod_name = file_name.to_string_lossy().to_string();
             self.protocol_mods.push(mod_name);
 
             let input = fs::read_to_string(path)?;
-            let resolved =
-                resolve_pdl(path, &input).map_err(|e| Error::new(ErrorKind::Other, e.message))?;
+            let resolved = resolve_pdl(path, &input).map_err(|e| Error::other(e.message))?;
             inputs.push(resolved);
         }
 
         let mut protocols = vec![];
 
         for (idx, input) in inputs.iter().enumerate() {
-            let pdl = parse_pdl(input).map_err(|e| Error::new(ErrorKind::Other, e.message))?;
+            let pdl = parse_pdl(input).map_err(|e| Error::other(e.message))?;
 
             self.domains
                 .extend(pdl.domains.iter().map(|d| (d.name.to_string(), idx)));