Function parse_pattern_string

src/parser.rs:369–448

Ref: https://wicg.github.io/urlpattern/#parse-a-pattern-string

(
  input: &str,
  options: &Options,
  encoding_callback: F,
)

// Ref: https://wicg.github.io/urlpattern/#parse-a-pattern-string
pub fn parse_pattern_string<F>(
  input: &str,
  options: &Options,
  encoding_callback: F,
) -> Result<Vec<Part>, Error>
where
  F: Fn(&str) -> Result<String, Error>,
{
  let token_list = crate::tokenizer::tokenize(
    input,
    crate::tokenizer::TokenizePolicy::Strict,
  )?;

  let mut parser = PatternParser {
    token_list,
    encoding_callback,
    segment_wildcard_regexp: options.generate_segment_wildcard_regexp(),
    part_list: vec![],
    pending_fixed_value: String::new(),
    index: 0,
    next_numeric_name: 0,
  };

  while parser.index < parser.token_list.len() {
    let char_token = parser.try_consume_token(TokenType::Char);
    let mut name_token = parser.try_consume_token(TokenType::Name);
    let mut regexp_or_wildcard_token =
      parser.try_consume_regexp_or_wildcard_token(name_token.is_none());
    if name_token.is_some() || regexp_or_wildcard_token.is_some() {
      let mut prefix = String::new();
      if let Some(char_token) = char_token {
        char_token.value.clone_into(&mut prefix);
      }
      if !prefix.is_empty() && prefix != options.prefix_code_point {
        parser.pending_fixed_value.push_str(&prefix);
        prefix = String::new();
      }
      parser.maybe_add_part_from_pending_fixed_value()?;
      let modifier_token = parser.try_consume_modifier_token();
      parser.add_part(
        &prefix,
        name_token,
        regexp_or_wildcard_token,
        "",
        modifier_token,
      )?;
      continue;
    }
    let mut fixed_token = char_token;
    if fixed_token.is_none() {
      fixed_token = parser.try_consume_token(TokenType::EscapedChar);
    }
    if let Some(fixed_token) = fixed_token {
      parser.pending_fixed_value.push_str(fixed_token.value);
      continue;
    }
    let open_token = parser.try_consume_token(TokenType::Open);
    if open_token.is_some() {