refactor: parameterize the regex (#31)

Author: lucacasonato

README.md

@@ -23,7 +23,7 @@ fn main() {
     pathname: Some("/users/:id".to_owned()),
     ..Default::default()
   };
-  let pattern = UrlPattern::parse(init).unwrap();
+  let pattern = <UrlPattern>::parse(init).unwrap();
 
   // Match the pattern against a URL.
   let url = "https://example.com/users/123".parse().unwrap();

src/component.rs

@@ -5,19 +5,19 @@ use crate::parser::Part;
 use crate::parser::PartModifier;
 use crate::parser::PartType;
 use crate::parser::FULL_WILDCARD_REGEXP_VALUE;
+use crate::regexp::RegExp;
 use crate::tokenizer::is_valid_name_codepoint;
 use crate::Error;
 
 // Ref: https://wicg.github.io/urlpattern/#component
 #[derive(Debug)]
-pub(crate) struct Component {
+pub(crate) struct Component<R: RegExp> {
   pub pattern_string: String,
-  pub rust_regexp: Result<regex::Regex, Error>,
-  pub ecma_regexp_string: String,
+  pub regexp: Result<R, Error>,
   pub group_name_list: Vec<String>,
 }
 
-impl Component {
+impl<R: RegExp> Component<R> {
   // Ref: https://wicg.github.io/urlpattern/#compile-a-component
   pub(crate) fn compile<F>(
     input: Option<&str>,
@@ -32,18 +32,13 @@ impl Component {
       &options,
       encoding_callback,
     )?;
-    let (rust_regexp_string, _) =
-      generate_regular_expression_and_name_list(&part_list, &options);
-    let rust_regexp =
-      regex::Regex::new(&rust_regexp_string).map_err(Error::RegEx);
-    let options = options.with_syntax(crate::parser::RegexSyntax::EcmaScript);
-    let (ecma_regexp_string, name_list) =
+    let (regexp_string, name_list) =
       generate_regular_expression_and_name_list(&part_list, &options);
+    let regexp = R::parse(&regexp_string).map_err(Error::RegExp);
     let pattern_string = generate_pattern_string(part_list, &options);
     Ok(Component {
       pattern_string,
-      rust_regexp,
-      ecma_regexp_string,
+      regexp,
       group_name_list: name_list,
     })
   }
@@ -52,9 +47,9 @@ impl Component {
   pub(crate) fn protocol_component_matches_special_scheme(&self) -> bool {
     const SPECIAL_SCHEMES: [&str; 6] =
       ["ftp", "file", "http", "https", "ws", "wss"];
-    if let Ok(regex) = &self.rust_regexp {
+    if let Ok(regex) = &self.regexp {
       for scheme in SPECIAL_SCHEMES {
-        if regex.captures(scheme).is_some() {
+        if regex.matches(scheme).is_some() {
           return true;
         }
       }
@@ -66,28 +61,23 @@ impl Component {
   pub(crate) fn create_match_result(
     &self,
     input: String,
-    exec_result: regex::Captures,
+    exec_result: Vec<&str>,
   ) -> crate::UrlPatternComponentResult {
-    let mut iter = exec_result.iter();
-    iter.next(); // first match is entire string
-    crate::UrlPatternComponentResult {
-      input,
-      groups: self
-        .group_name_list
-        .clone()
-        .into_iter()
-        .zip(iter.map(|e| e.map(|e| e.as_str().to_string())))
-        .map(|(name, key)| (name, key.unwrap_or_default()))
-        .collect(),
-    }
+    let groups = self
+      .group_name_list
+      .clone()
+      .into_iter()
+      .zip(exec_result.into_iter().map(str::to_owned))
+      .collect();
+    crate::UrlPatternComponentResult { input, groups }
   }
 
   pub(crate) fn optionally_transpose_regex_error(
     mut self,
     do_transpose: bool,
   ) -> Result<Self, Error> {
     if do_transpose {
-      self.rust_regexp = Ok(self.rust_regexp?);
+      self.regexp = Ok(self.regexp?);
     }
     Ok(self)
   }

src/constructor_parser.rs

@@ -1,6 +1,7 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
 use crate::error::Error;
+use crate::regexp::RegExp;
 use crate::tokenizer::Token;
 use crate::tokenizer::TokenType;
 use crate::UrlPatternInit;
@@ -193,9 +194,11 @@ impl<'a> ConstructorStringParser<'a> {
   }
 
   // Ref: https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag
-  fn compute_protocol_matches_special_scheme(&mut self) -> Result<(), Error> {
+  fn compute_protocol_matches_special_scheme<R: RegExp>(
+    &mut self,
+  ) -> Result<(), Error> {
     let protocol_string = self.make_component_string();
-    let protocol_component = crate::component::Component::compile(
+    let protocol_component = crate::component::Component::<R>::compile(
       Some(&protocol_string),
       crate::canonicalize_and_process::canonicalize_protocol,
       Default::default(),
@@ -230,7 +233,7 @@ impl<'a> ConstructorStringParser<'a> {
 }
 
 // Ref: https://wicg.github.io/urlpattern/#parse-a-constructor-string
-pub(crate) fn parse_constructor_string(
+pub(crate) fn parse_constructor_string<R: RegExp>(
   input: &str,
 ) -> Result<UrlPatternInit, Error> {
   let token_list = crate::tokenizer::tokenize(
@@ -315,7 +318,7 @@ pub(crate) fn parse_constructor_string(
       }
       ConstructorStringParserState::Protocol => {
         if parser.is_protocol_suffix() {
-          parser.compute_protocol_matches_special_scheme()?;
+          parser.compute_protocol_matches_special_scheme::<R>()?;
           if parser.protocol_matches_special_scheme {
             parser.result.pathname = Some(String::from("/"));
           }

src/error.rs

@@ -20,7 +20,9 @@ pub enum Error {
   Parser(ParserError),
 
   Url(url::ParseError),
-  RegEx(regex::Error),
+
+  #[display(fmt = "regexp error")]
+  RegExp(()),
 }
 
 impl std::error::Error for Error {}

src/lib.rs

@@ -11,6 +11,7 @@ mod constructor_parser;
 mod error;
 mod parser;
 pub mod quirks;
+mod regexp;
 mod tokenizer;
 
 pub use error::Error;
@@ -19,6 +20,7 @@ use url::Url;
 use crate::canonicalize_and_process::is_special_scheme;
 use crate::canonicalize_and_process::special_scheme_default_port;
 use crate::component::Component;
+use crate::regexp::RegExp;
 
 /// The structured input used to create a URL pattern.
 #[derive(Debug, Default, Clone, Eq, PartialEq)]
@@ -35,11 +37,11 @@ pub struct UrlPatternInit {
 }
 
 impl UrlPatternInit {
-  pub fn parse_constructor_string(
+  pub fn parse_constructor_string<R: RegExp>(
     pattern: &str,
     base_url: Option<Url>,
   ) -> Result<UrlPatternInit, Error> {
-    let mut init = constructor_parser::parse_constructor_string(pattern)?;
+    let mut init = constructor_parser::parse_constructor_string::<R>(pattern)?;
     if base_url.is_none() && init.protocol.is_none() {
       return Err(Error::BaseUrlRequired);
     }
@@ -194,7 +196,7 @@ fn is_absolute_pathname(
 ///   pathname: Some("/users/:id".to_owned()),
 ///   ..Default::default()
 /// };
-/// let pattern = UrlPattern::parse(init).unwrap();
+/// let pattern = <UrlPattern>::parse(init).unwrap();
 ///
 /// // Match the pattern against a URL.
 /// let url = "https://example.com/users/123".parse().unwrap();
@@ -203,15 +205,15 @@ fn is_absolute_pathname(
 ///# }
 /// ```
 #[derive(Debug)]
-pub struct UrlPattern {
-  protocol: Component,
-  username: Component,
-  password: Component,
-  hostname: Component,
-  port: Component,
-  pathname: Component,
-  search: Component,
-  hash: Component,
+pub struct UrlPattern<R: RegExp = regex::Regex> {
+  protocol: Component<R>,
+  username: Component<R>,
+  password: Component<R>,
+  hostname: Component<R>,
+  port: Component<R>,
+  pathname: Component<R>,
+  search: Component<R>,
+  hash: Component<R>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -220,7 +222,7 @@ pub enum UrlPatternMatchInput {
   Url(Url),
 }
 
-impl UrlPattern {
+impl<R: RegExp> UrlPattern<R> {
   // Ref: https://wicg.github.io/urlpattern/#dom-urlpattern-urlpattern
   /// Parse a [UrlPatternInit] into a [UrlPattern].
   pub fn parse(init: UrlPatternInit) -> Result<Self, Error> {
@@ -405,52 +407,40 @@ impl UrlPattern {
 
     let protocol_exec_result = self
       .protocol
-      .rust_regexp
+      .regexp
       .as_ref()
       .unwrap()
-      .captures(&input.protocol);
+      .matches(&input.protocol);
     let username_exec_result = self
       .username
-      .rust_regexp
+      .regexp
       .as_ref()
       .unwrap()
-      .captures(&input.username);
+      .matches(&input.username);
     let password_exec_result = self
       .password
-      .rust_regexp
+      .regexp
       .as_ref()
       .unwrap()
-      .captures(&input.password);
+      .matches(&input.password);
     let hostname_exec_result = self
       .hostname
-      .rust_regexp
+      .regexp
       .as_ref()
       .unwrap()
-      .captures(&input.hostname);
-    let port_exec_result = self
-      .port
-      .rust_regexp
-      .as_ref()
-      .unwrap()
-      .captures(&input.port);
+      .matches(&input.hostname);
+    let port_exec_result =
+      self.port.regexp.as_ref().unwrap().matches(&input.port);
     let pathname_exec_result = self
       .pathname
-      .rust_regexp
-      .as_ref()
-      .unwrap()
-      .captures(&input.pathname);
-    let search_exec_result = self
-      .search
-      .rust_regexp
-      .as_ref()
-      .unwrap()
-      .captures(&input.search);
-    let hash_exec_result = self
-      .hash
-      .rust_regexp
+      .regexp
       .as_ref()
       .unwrap()
-      .captures(&input.hash);
+      .matches(&input.pathname);
+    let search_exec_result =
+      self.search.regexp.as_ref().unwrap().matches(&input.search);
+    let hash_exec_result =
+      self.hash.regexp.as_ref().unwrap().matches(&input.hash);
 
     match (
       protocol_exec_result,
@@ -640,7 +630,7 @@ mod tests {
       base_url.as_deref(),
     );
 
-    let res = init_res.and_then(UrlPattern::parse);
+    let res = init_res.and_then(<UrlPattern>::parse);
     let expected_obj = match case.expected_obj {
       Some(StringOrInit::String(s)) if s == "error" => {
         assert!(res.is_err());
@@ -864,7 +854,7 @@ mod tests {
 
   #[test]
   fn issue26() {
-    UrlPattern::parse(UrlPatternInit {
+    <UrlPattern>::parse(UrlPatternInit {
       pathname: Some("/:foo.".to_owned()),
       ..Default::default()
     })

src/parser.rs

@@ -62,11 +62,6 @@ impl Options {
     }
   }
 
-  pub fn with_syntax(mut self, syntax: RegexSyntax) -> Self {
-    self.regex_syntax = syntax;
-    self
-  }
-
   // Ref: https://wicg.github.io/urlpattern/#escape-a-regexp-string
   pub fn escape_regexp_string(&self, input: &str) -> String {
     assert!(input.is_ascii());