Merge branch 'denoland:main' into main

Author: edgul

src/canonicalize_and_process.rs

@@ -46,7 +46,8 @@ pub fn canonicalize_hostname(value: &str) -> Result<String, Error> {
     return Ok(String::new());
   }
   let mut url = url::Url::parse("http://dummy.test").unwrap();
-  url.set_host(Some(value)).map_err(Error::Url)?;
+  url::quirks::set_hostname(&mut url, value)
+    .map_err(|_| Error::Url(url::ParseError::InvalidDomainCharacter))?;
   Ok(url::quirks::hostname(&url).to_string())
 }
 

src/component.rs

@@ -7,6 +7,7 @@ use crate::parser::Options;
 use crate::parser::Part;
 use crate::parser::PartModifier;
 use crate::parser::PartType;
+use crate::parser::RegexSyntax;
 use crate::parser::FULL_WILDCARD_REGEXP_VALUE;
 use crate::regexp::RegExp;
 use crate::tokenizer::is_valid_name_codepoint;
@@ -42,7 +43,15 @@ impl<R: RegExp> Component<R> {
     let (regexp_string, name_list) =
       generate_regular_expression_and_name_list(&part_list, &options);
     let flags = if options.ignore_case { "ui" } else { "u" };
-    let regexp = R::parse(&regexp_string, flags).map_err(Error::RegExp);
+    let mut regexp =
+      R::parse(&regexp_string, flags, false).map_err(Error::RegExp);
+    if regexp.is_ok() && R::syntax() == RegexSyntax::EcmaScript {
+      for part in part_list.iter() {
+        if part.kind == PartType::Regexp {
+          regexp = R::parse(&regexp_string, flags, true).map_err(Error::RegExp);
+        }
+      }
+    }
     let pattern_string = generate_pattern_string(&part_list, &options);
     let matcher = generate_matcher::<R>(&part_list, &options, flags);
     Ok(Component {
@@ -350,7 +359,8 @@ fn generate_matcher<R: RegExp>(
     part_list => {
       let (regexp_string, _) =
         generate_regular_expression_and_name_list(part_list, options);
-      let regexp = R::parse(&regexp_string, flags).map_err(Error::RegExp);
+      let regexp =
+        R::parse(&regexp_string, flags, false).map_err(Error::RegExp);
       InnerMatcher::RegExp { regexp }
     }
   };

src/quirks.rs

@@ -175,12 +175,20 @@ impl RegExp for EcmaRegexp {
     RegexSyntax::EcmaScript
   }
 
-  fn parse(pattern: &str, flags: &str) -> Result<Self, ()> {
-    Ok(EcmaRegexp(pattern.to_string(), flags.to_string()))
+  fn parse(pattern: &str, flags: &str, force_eval: bool) -> Result<Self, ()> {
+    if force_eval {
+      let regexp = regex::Regex::parse(pattern, flags, false);
+      match regexp {
+        Ok(r) => Ok(EcmaRegexp(r.to_string(), flags.to_string())),
+        _ => Err(()),
+      }
+    } else {
+      Ok(EcmaRegexp(pattern.to_string(), flags.to_string()))
+    }
   }
 
   fn matches<'a>(&self, text: &'a str) -> Option<Vec<Option<&'a str>>> {
-    let regexp = regex::Regex::parse(&self.0, &self.1).ok()?;
+    let regexp = regex::Regex::parse(&self.0, &self.1, false).ok()?;
     regexp.matches(text)
   }
 }
@@ -191,7 +199,8 @@ pub fn parse_pattern(
   options: UrlPatternOptions,
 ) -> Result<UrlPattern, Error> {
   let pattern =
-    crate::UrlPattern::<EcmaRegexp>::parse_internal(init, false, options)?;
+    crate::UrlPattern::<EcmaRegexp>::parse_internal(init, true, options)?;
+
   let urlpattern = UrlPattern {
     has_regexp_groups: pattern.has_regexp_groups(),
     protocol: pattern.protocol.into(),

src/regexp.rs

@@ -5,7 +5,7 @@ pub trait RegExp: Sized {
 
   /// Generates a regexp pattern for the given string. If the pattern is
   /// invalid, the parse function should return an error.
-  fn parse(pattern: &str, flags: &str) -> Result<Self, ()>;
+  fn parse(pattern: &str, flags: &str, force_eval: bool) -> Result<Self, ()>;
 
   /// Matches the given text against the regular expression and returns the list
   /// of captures. The matches are returned in the order they appear in the
@@ -22,7 +22,7 @@ impl RegExp for regex::Regex {
     RegexSyntax::Rust
   }
 
-  fn parse(pattern: &str, flags: &str) -> Result<Self, ()> {
+  fn parse(pattern: &str, flags: &str, _force_eval: bool) -> Result<Self, ()> {
     regex::Regex::new(&format!("(?{flags}){pattern}")).map_err(|_| ())
   }
 

src/testdata/urlpatterntestdata.json

@@ -1883,7 +1883,17 @@
   {
     "pattern": [ "https://{sub.}?example{.com/}foo" ],
     "inputs": [ "https://example.com/foo" ],
-    "expected_obj": "error"
+    "exactly_empty_components": [ "port" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "{sub.}?example.com",
+      "pathname": "*"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo", "groups": { "0": "/foo" } }
+    }
   },
   {
     "pattern": [ "{https://}example.com/foo" ],
@@ -2441,15 +2451,27 @@
   },
   {
     "pattern": [{ "hostname": "bad#hostname" }],
-    "expected_obj": "error"
+    "inputs": [{ "hostname":  "bad" }],
+    "expected_obj": {
+      "hostname": "bad"
+    },
+    "expected_match": {
+      "hostname": { "input": "bad", "groups": {} }
+    }
   },
   {
     "pattern": [{ "hostname": "bad%hostname" }],
     "expected_obj": "error"
   },
   {
     "pattern": [{ "hostname": "bad/hostname" }],
-    "expected_obj": "error"
+    "inputs": [{ "hostname": "bad" }],
+    "expected_obj": {
+      "hostname": "bad"
+    },
+    "expected_match": {
+      "hostname": { "input": "bad", "groups": {} }
+    }
   },
   {
     "skip": "likely a bug in rust-url",
@@ -2482,7 +2504,11 @@
   },
   {
     "pattern": [{ "hostname": "bad\\\\hostname" }],
-    "expected_obj": "error"
+    "inputs": [{ "hostname": "badhostname" }],
+    "expected_obj": {
+      "hostname": "bad"
+    },
+    "expected_match": null
   },
   {
     "pattern": [{ "hostname": "bad^hostname" }],