chore: Remove the serde_regex dependency, which wasn't very heavily used

Author: bgw

Cargo.lock

@@ -1,16 +1,81 @@
+use std::fmt;
+
 use anyhow::{Context, Result};
-use serde::{Deserialize, Serialize};
-use turbo_tasks::primitives::Regex;
+use regex::Regex;
+use serde::{
+    Deserialize, Deserializer, Serialize, Serializer,
+    de::{Error as _, Visitor},
+    ser::SerializeTupleStruct,
+};
 use turbopack_node::route_matcher::{Param, Params, RouteMatcherRef};
 
 /// A regular expression that matches a path, with named capture groups for the
 /// dynamic parts of the path.
-#[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
+#[derive(Debug)]
 pub struct PathRegex {
     regex: Regex,
     named_params: Vec<NamedParam>,
 }
 
+impl PartialEq for PathRegex {
+    fn eq(&self, other: &Self) -> bool {
+        self.regex.as_str() == other.regex.as_str() && self.named_params == other.named_params
+    }
+}
+
+impl Eq for PathRegex {}
+
+impl Serialize for PathRegex {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut ts = serializer.serialize_tuple_struct("PathRegex", 2)?;
+        ts.serialize_field(self.regex.as_str())?;
+        ts.serialize_field(&self.named_params)?;
+        ts.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for PathRegex {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct PathRegexVisitor;
+
+        impl<'de> Visitor<'de> for PathRegexVisitor {
+            type Value = PathRegex;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a PathRegex tuple struct")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let regex_str: String = seq
+                    .next_element()?
+                    .ok_or_else(|| A::Error::invalid_length(0, &self))?;
+                let named_params: Vec<NamedParam> = seq
+                    .next_element()?
+                    .ok_or_else(|| A::Error::invalid_length(1, &self))?;
+
+                let regex = Regex::new(&regex_str)
+                    .map_err(|e| A::Error::custom(format!("invalid regex: {e}")))?;
+
+                Ok(PathRegex {
+                    regex,
+                    named_params,
+                })
+            }
+        }
+
+        deserializer.deserialize_tuple_struct("PathRegex", 2, PathRegexVisitor)
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
 struct NamedParam {
     name: String,
@@ -153,7 +218,7 @@ impl PathRegexBuilder {
     pub fn build(mut self) -> Result<PathRegex> {
         self.regex_str += "$";
         Ok(PathRegex {
-            regex: Regex(regex::Regex::new(&self.regex_str).with_context(|| "invalid path regex")?),
+            regex: regex::Regex::new(&self.regex_str).with_context(|| "invalid path regex")?,
             named_params: self.named_params,
         })
     }
@@ -164,3 +229,18 @@ impl Default for PathRegexBuilder {
         Self::new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_path_regex_serde_roundtrip() {
+        let path_regex = super::super::build_path_regex("/api/[version]/[[...path]]").unwrap();
+
+        let serialized = serde_json::to_string(&path_regex).unwrap();
+        let deserialized: PathRegex = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(path_regex, deserialized);
+    }
+}

crates/next-core/src/next_route_matcher/path_regex.rs

@@ -39,7 +39,6 @@ regex = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["rc", "derive"] }
 serde_json = { workspace = true }
-serde_regex = "1.1.0"
 shrink-to-fit = { workspace=true,features = ["indexmap", "serde_json", "smallvec", "nightly"] }
 smallvec = { workspace = true }
 thiserror = { workspace = true }

turbopack/crates/turbo-tasks/Cargo.toml

@@ -1,4 +1,4 @@
-use std::{ops::Deref, time::Duration};
+use std::time::Duration;
 
 use turbo_rcstr::RcStr;
 use turbo_tasks_macros::primitive as __turbo_tasks_internal_primitive;
@@ -33,27 +33,3 @@ __turbo_tasks_internal_primitive!(serde_json::Value);
 __turbo_tasks_internal_primitive!(Duration);
 __turbo_tasks_internal_primitive!(Vec<u8>, manual_shrink_to_fit);
 __turbo_tasks_internal_primitive!(Vec<bool>, manual_shrink_to_fit);
-
-#[turbo_tasks::value(transparent, eq = "manual")]
-#[derive(Debug, Clone)]
-pub struct Regex(
-    #[turbo_tasks(trace_ignore)]
-    #[serde(with = "serde_regex")]
-    pub regex::Regex,
-);
-
-impl Deref for Regex {
-    type Target = regex::Regex;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl PartialEq for Regex {
-    fn eq(&self, other: &Regex) -> bool {
-        // Context: https://github.com/rust-lang/regex/issues/313#issuecomment-269898900
-        self.0.as_str() == other.0.as_str()
-    }
-}
-impl Eq for Regex {}

turbopack/crates/turbo-tasks/src/primitives.rs

@@ -3,12 +3,12 @@ use std::{
     mem::{replace, take},
 };
 
-use anyhow::{Result, bail};
+use anyhow::Result;
 use either::Either;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use turbo_esregex::EsRegex;
-use turbo_tasks::{NonLocalValue, ReadRef, ResolvedVc, primitives::Regex, trace::TraceRawVcs};
+use turbo_tasks::{NonLocalValue, ReadRef, ResolvedVc, trace::TraceRawVcs};
 use turbo_tasks_fs::{FileContent, FileSystemPath, glob::Glob};
 use turbopack_core::{
     asset::Asset, reference_type::ReferenceType, source::Source, virtual_source::VirtualSource,
@@ -30,7 +30,6 @@ pub enum RuleCondition {
     ResourcePathInExactDirectory(FileSystemPath),
     ContentTypeStartsWith(String),
     ContentTypeEmpty,
-    ResourcePathRegex(#[turbo_tasks(trace_ignore)] Regex),
     ResourcePathEsRegex(#[turbo_tasks(trace_ignore)] ReadRef<EsRegex>),
     ResourceContentEsRegex(#[turbo_tasks(trace_ignore)] ReadRef<EsRegex>),
     /// For paths that are within the same filesystem as the `base`, it need to
@@ -268,9 +267,6 @@ impl RuleCondition {
                             .map_or(path.path.as_str(), |(_, b)| b);
                         return Ok(glob.matches(basename));
                     }
-                    RuleCondition::ResourcePathRegex(_) => {
-                        bail!("ResourcePathRegex not implemented yet");
-                    }
                     RuleCondition::ResourcePathEsRegex(regex) => {
                         return Ok(regex.is_match(&path.path));
                     }