diff options
Diffstat (limited to 'src/parser.rs')
| -rw-r--r-- | src/parser.rs | 1474 |
1 files changed, 464 insertions, 1010 deletions
diff --git a/src/parser.rs b/src/parser.rs index 1f028a0..38fa3fe 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -3,11 +3,32 @@ use std::ops::Range; #[derive(Debug)] pub struct Challenge { pub scheme: Range<usize>, - pub params: Vec<AuthParam>, + pub realm: Option<Range<usize>>, + pub scope: Option<Range<usize>>, + pub service: Option<Range<usize>>, +} + +#[derive(Default)] +pub struct PartialChallenge { + pub scheme: Option<Range<usize>>, + pub realm: Option<Range<usize>>, + pub scope: Option<Range<usize>>, + pub service: Option<Range<usize>>, +} + +impl Into<Challenge> for PartialChallenge { + fn into(self) -> Challenge { + return Challenge { + scheme: self.scheme.unwrap(), + realm: self.realm, + scope: self.scope, + service: self.service, + } + } } // RFC 7230 -fn parse_token(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_token(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; while str.len() > pos { match str[pos] { @@ -26,40 +47,7 @@ fn parse_token(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { return None; } - return Some((start..pos, pos)); -} - -#[cfg(test)] -mod test_token { - use super::*; - - #[test] - fn rejects_nontchar() { - let data = vec!['>']; - - let res = parse_token(&data, 0); - assert!(res.is_none()); - } - - #[test] - fn matches_letter() { - let data = vec!['a']; - - let (range, pos) = parse_token(&data, 0).unwrap(); - assert_eq!(pos, 1); - assert_eq!(range.start, 0); - assert_eq!(range.end, 1); - } - - #[test] - fn matches_multiple_letters() { - let data = vec!['a', '1', '|']; - - let (range, pos) = parse_token(&data, 0).unwrap(); - assert_eq!(pos, 3); - assert_eq!(range.start, 0); - assert_eq!(range.end, 3); - } + return Some(pos); } fn parse_qdtext(str: &Vec<char>, start: usize) -> Option<usize> { @@ -77,13 +65,14 @@ fn parse_quotedpair(str: &Vec<char>, start: usize) -> Option<usize> { return Some(start + 2); } -fn parse_quotedstring(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_quotedstring(str: &Vec<char>, start: usize, range: &mut Option<&mut Range<usize>>) -> Option<usize> { let mut pos = start; if str[pos] != '"' { return None; } pos += 1; + range.as_mut().map(|x| x.start = pos); loop { if let Some(npos) = parse_qdtext(str, pos) { pos = npos; @@ -93,16 +82,17 @@ fn parse_quotedstring(str: &Vec<char>, start: usize) -> Option<(Range<usize>, us break; } } + range.as_mut().map(|x| x.end = pos); if str[pos] != '"' { return None; } pos += 1; - return Some((start+1..pos-1, pos)); + return Some(pos); } -fn parse_sp(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_sp(str: &Vec<char>, start: usize) -> Option<usize> { if str.len() <= start { return None; } @@ -117,7 +107,20 @@ fn parse_sp(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { return None; } - return Some((start..pos, pos)); + return Some(pos); +} + +fn parse_ows(str: &Vec<char>, start: usize) -> Option<usize> { + // @COMPL: This is not right + let mut pos = start; + loop { + match parse_sp(str, pos) { + Some(npos) => pos = npos, + None => break, + } + } + + return Some(pos); } fn parse_crlf(str: &Vec<char>, start: usize) -> Option<usize> { @@ -132,7 +135,7 @@ fn parse_crlf(str: &Vec<char>, start: usize) -> Option<usize> { return None; } -fn parse_lws(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_lws(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; match parse_crlf(str, pos) { @@ -141,28 +144,47 @@ fn parse_lws(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { } match parse_sp(str, pos) { - Some((_, npos)) => pos = npos, + Some(npos) => pos = npos, None => return None, } loop { match parse_sp(str, pos) { - Some((_, npos)) => pos = npos, + Some(npos) => pos = npos, None => break, } } - return Some((start..pos, pos)); + return Some(pos); } -#[derive(Debug)] -pub struct AuthParam { - pub key: Range<usize>, - pub value: Range<usize>, -} +fn parse_param(str: &Vec<char>, start: usize, partial: &mut PartialChallenge) -> Option<usize> { + let mut pos = start; -fn parse_param(str: &Vec<char>, start: usize) -> Option<(AuthParam, usize)> { - let pos = start; - let (param_range, pos) = parse_token(str, pos)?; + let mut value_range_slot = None; + + if let Some(npos) = parse_exact_string(str, pos, "realm") { + partial.realm = Some(Range { + ..Default::default() + }); + value_range_slot = partial.realm.as_mut(); + pos = npos; + } else if let Some(npos) = parse_exact_string(str, pos, "scope") { + partial.scope = Some(Range { + ..Default::default() + }); + value_range_slot = partial.scope.as_mut(); + pos = npos; + } else if let Some(npos) = parse_exact_string(str, pos, "service") { + partial.service = Some(Range { + ..Default::default() + }); + value_range_slot = partial.service.as_mut(); + pos = npos; + } else if let Some(npos) = parse_token(str, pos) { + pos = npos; + } else { + return None; + } let mut pos = pos; if str[pos] == '=' { @@ -171,49 +193,65 @@ fn parse_param(str: &Vec<char>, start: usize) -> Option<(AuthParam, usize)> { todo!(); } - let value_range; - if let Some((range, npos)) = parse_token(str, pos) { - value_range = range; + value_range_slot.as_mut().map(|x| x.start = pos); + if let Some(npos) = parse_token(str, pos) { + value_range_slot.map(|x| x.end = npos); pos = npos; - } else if let Some((range, npos)) = parse_quotedstring(str, pos) { - value_range = range; + } else if let Some(npos) = parse_quotedstring(str, pos, &mut value_range_slot) { pos = npos; } else { todo!("{:?}", &str[pos..]); } - return Some((AuthParam{key: param_range, value: value_range}, pos)); + return Some(pos); } -pub fn parse_challenge(str: &Vec<char>, start: usize) -> Option<(Challenge, usize)> { - let pos = start; - let (scheme_range, pos) = parse_token(str, pos).unwrap(); +pub fn parse_authenticate_header(header: &str) -> Option<Challenge> { + let mut partial: PartialChallenge = Default::default(); + let data = header.chars().collect(); + + parse_challenge(&data, 0, &mut partial)?; - let (_, pos) = parse_sp(str, pos).unwrap(); + return Some(partial.into()); +} + +fn parse_challenge(str: &Vec<char>, start: usize, partial: &mut PartialChallenge) -> Option<usize> { + let mut pos = start; + + { + let mut scheme_range = Range { + start: pos, + ..Default::default() + }; + + pos = parse_token(str, pos).unwrap(); + + scheme_range.end = pos; + partial.scheme = Some(scheme_range); + } + + let pos = parse_sp(str, pos).unwrap(); let mut pos = pos; loop { match parse_sp(str, pos) { - Some((_, npos)) => pos = npos, + Some(npos) => pos = npos, None => break, } } - let mut params = vec!(); - let mut pos = pos; loop { match parse_lws(str, pos) { - Some((_, npos)) => pos = npos, + Some(npos) => pos = npos, None => break, } } - let (param, pos) = parse_param(str, pos).unwrap(); - params.push(param); + let pos = parse_param(str, pos, partial).unwrap(); let mut pos = pos; loop { loop { match parse_lws(str, pos) { - Some((_, npos)) => pos = npos, + Some(npos) => pos = npos, None => break, } } @@ -225,15 +263,14 @@ pub fn parse_challenge(str: &Vec<char>, start: usize) -> Option<(Challenge, usiz loop { match parse_lws(str, pos) { - Some((_, npos)) => pos = npos, + Some(npos) => pos = npos, None => break, } } - match parse_param(str, pos) { - Some((param, npos)) => { + match parse_param(str, pos, partial) { + Some(npos) => { pos = npos; - params.push(param); }, None => return None, } @@ -242,58 +279,39 @@ pub fn parse_challenge(str: &Vec<char>, start: usize) -> Option<(Challenge, usiz if pos < str.len() { return None; } - return Some((Challenge {scheme: scheme_range, params}, pos)); -} - -#[derive(Debug)] -pub enum LinkParam { - Rel{relation: Range<usize>}, -} - -impl LinkParam { - pub fn value(&self) -> &Range<usize> { - match self { - LinkParam::Rel{relation} => &relation, - } - } + return Some(pos); } -#[derive(Debug)] -pub struct LinkValue { - uri: Range<usize>, - pub params: Vec<LinkParam>, -} - -fn parse_alpha(str: &Vec<char>, pos: usize) -> Option<(Range<usize>, usize)> { +fn parse_alpha(str: &Vec<char>, pos: usize) -> Option<usize> { if pos >= str.len() { return None; } return match str[pos] { - 'a'..='z' | 'A'..='Z' => Some((pos..pos+1, pos+1)), + 'a'..='z' | 'A'..='Z' => Some(pos+1), _ => None, } } -fn parse_digit(str: &Vec<char>, pos: usize) -> Option<(Range<usize>, usize)> { +fn parse_digit(str: &Vec<char>, pos: usize) -> Option<usize> { if pos >= str.len() { return None; } return match str[pos] { - '0'..='9' => Some((pos..pos+1, pos+1)), + '0'..='9' => Some(pos+1), _ => None, } } -fn parse_dec_octet(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_dec_octet(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; let mut len = 0; let mut value: u16 = 0; while len < 3 { - if let Some((_, npos)) = parse_digit(str, pos) { + if let Some(npos) = parse_digit(str, pos) { value = value * 10 + (str[pos] as u16 - '0' as u16); pos = npos; len += 1; @@ -314,13 +332,13 @@ fn parse_dec_octet(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize return None; } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_ipv4address(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_ipv4address(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - let (_, npos) = parse_dec_octet(str, pos)?; + let npos = parse_dec_octet(str, pos)?; pos = npos; if let Some(ch) = str.get(pos) && *ch == '.' { @@ -329,7 +347,7 @@ fn parse_ipv4address(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usi return None; } - let (_, npos) = parse_dec_octet(str, pos)?; + let npos = parse_dec_octet(str, pos)?; pos = npos; if let Some(ch) = str.get(pos) && *ch == '.' { @@ -338,7 +356,7 @@ fn parse_ipv4address(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usi return None; } - let (_, npos) = parse_dec_octet(str, pos)?; + let npos = parse_dec_octet(str, pos)?; pos = npos; if let Some(ch) = str.get(pos) && *ch == '.' { @@ -347,31 +365,31 @@ fn parse_ipv4address(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usi return None; } - let (_, npos) = parse_dec_octet(str, pos)?; + let npos = parse_dec_octet(str, pos)?; pos = npos; - return Some((start..pos, pos)); + return Some(pos); } -fn parse_hexdig(str: &Vec<char>, pos: usize) -> Option<(Range<usize>, usize)> { +fn parse_hexdig(str: &Vec<char>, pos: usize) -> Option<usize> { if pos >= str.len() { return None; } return match str[pos] { - '0'..='9' | 'A'..='F' | 'a'..='f' => Some((pos..pos+1, pos+1)), + '0'..='9' | 'A'..='F' | 'a'..='f' => Some(pos+1), _ => None, } } -fn parse_scheme(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_scheme(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - let (_, npos) = parse_alpha(str, pos)?; + let npos = parse_alpha(str, pos)?; pos = npos; loop { - if let Some((_, npos)) = parse_alpha(str, pos) { + if let Some(npos) = parse_alpha(str, pos) { pos = npos; } else { break; @@ -381,685 +399,404 @@ fn parse_scheme(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> return None; } -fn parse_reg_name(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_reg_name(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; loop { - if let Some((_, npos)) = parse_unreserved(str, pos) { + if let Some(npos) = parse_unreserved(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_pct_encoded(str, pos) { + } else if let Some(npos) = parse_pct_encoded(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_sub_delims(str, pos) { + } else if let Some(npos) = parse_sub_delims(str, pos) { pos = npos; } else { break; } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_h16(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_h16(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - let (_, npos) = parse_hexdig(str, pos)?; + let npos = parse_hexdig(str, pos)?; pos = npos; for _ in 0..3 { - if let Some((_, npos)) = parse_hexdig(str, pos) { + if let Some(npos) = parse_hexdig(str, pos) { pos = npos; } else { break; } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_ls32(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_ls32(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - if let Some((_, npos)) = parse_h16(str, pos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - if let Some((_, npos)) = parse_h16(str, npos) { - return Some((start..npos, npos)); + if let Some(npos) = parse_h16(str, pos) { + if let Some(npos) = parse_exact_string(str, npos, ":") { + if let Some(npos) = parse_h16(str, npos) { + return Some(npos); } } } - if let Some((_, npos)) = parse_ipv4address(str, pos) { - return Some((start..npos, npos)); + if let Some(npos) = parse_ipv4address(str, pos) { + return Some(npos); } return None; } -fn parse_ipv6address(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_first_part_ipv6(str: &Vec<char>, start: usize, max_reps: usize) -> Option<usize> { + let mut pos; + + if let Some(npos) = parse_h16(str, start) { + pos = Some(npos); + } else { + pos = Some(start); + } + + for _ in 0..max_reps { + if let Some(npos) = parse_exact_string(str, pos.unwrap(), ":") { + if let Some(npos) = parse_h16(str, npos) { + pos = Some(npos); + continue; + } + } + + break; + } + + if let Some(npos) = parse_exact_string(str, pos.unwrap(), "::") { + pos = Some(npos); + } else { + pos = None; + } + + return pos; +} + +fn parse_ipv6address(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - { - let mut tpos = pos; + // 6( h16 ":" ) ls32 + if pos == start { // Just for symmetry, this is always true + let mut tpos = Some(pos); + for _ in 0..6 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; + if let Some(npos) = parse_h16(str, tpos.unwrap()) { + if let Some(npos) = parse_exact_string(str, npos, ":") { + tpos = Some(npos); continue; } } // We fail the match, Rollback and stop - tpos = pos; + tpos = None; break; } - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_ls32(str, tpos) { - pos = npos; + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_ls32(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None; } } + + if let Some(tpos_val) = tpos { + pos = tpos_val; + } } + // "::" 5( h16 ":" ) ls32 if pos == start { - let mut tpos = pos; - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; + let mut tpos; + + if let Some(npos) = parse_exact_string(str, pos, "::") { + tpos = Some(npos); } else { - tpos = pos; + tpos = None; } - if tpos != pos { + if let Some(ref mut tpos_val) = tpos { for _ in 0..5 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; + if let Some(npos) = parse_h16(str, *tpos_val) { + if let Some(npos) = parse_exact_string(str, npos, ":") { + *tpos_val = npos; continue; } } // We fail the match, Rollback and stop - tpos = pos; + tpos = None; break; } } - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_ls32(str, tpos) { - pos = npos; + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_ls32(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None; } } + + if let Some(tpos_val) = tpos { + pos = tpos_val; + } } + // [ h16 ] "::" 4( h16 ":" ) ls32 if pos == start { - let mut tpos = pos; + let mut tpos; - if let Some((_, npos)) = parse_h16(str, tpos) { - tpos = npos; + if let Some(npos) = parse_h16(str, pos) { + tpos = Some(npos); + } else { + tpos = Some(pos); } - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; + if let Some(npos) = parse_exact_string(str, tpos.unwrap(), "::") { + tpos = Some(npos); } else { - tpos = pos; + tpos = None; } - if tpos != pos { + if let Some(ref mut tpos_val) = tpos { for _ in 0..4 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; + if let Some(npos) = parse_h16(str, *tpos_val) { + if let Some(npos) = parse_exact_string(str, npos, ":") { + *tpos_val = npos; continue; } } // We fail the match, Rollback and stop - tpos = pos; + tpos = None; break; } } - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_ls32(str, tpos) { - pos = npos; - } - } - } - - if pos == start { - let mut tpos = pos; - - for _ in 0..1 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; - continue; - } + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_ls32(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None; } - - // Match failed - break; } - if let Some((_, npos)) = parse_h16(str, tpos) { - tpos = npos; + if let Some(tpos_val) = tpos { + pos = tpos_val; } + } - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; - } else { - tpos = pos; - } + // [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 + // Implementing this parsing rule sucks. When reading the first repeating block ( h16 ":" ) we + // have to speculatively read those two tokens, but we can't commit them since we don't know if + // they're valid until we then read ANOTHER h16 followed by another colon, which can then of + // course ALSO be part of the repetition if not followed by a second colon. I don't want to + // write that lookahead/rollback code. Instead we can reformulate that production into: + // [ h16 *1( ":" h16 ) ] "::" 3( h16 ":" ) ls32 + // This is much easier to implement, since we now just have to try and read a colon followed by + // an h16, and if we don't find that fall through to the double colon or fail. + // @COMPL We have to be a little careful, since this may interact differently with whitespace + // and such, but that's for later. + if pos == start { + let mut tpos = parse_first_part_ipv6(str, pos, 1); - if tpos != pos { + if let Some(ref mut tpos_val) = tpos { for _ in 0..3 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; + if let Some(npos) = parse_h16(str, *tpos_val) { + if let Some(npos) = parse_exact_string(str, npos, ":") { + *tpos_val = npos; continue; } } // We fail the match, Rollback and stop - tpos = pos; + tpos = None; break; } } - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_ls32(str, tpos) { - pos = npos; - } - } - } - - if pos == start { - let mut tpos = pos; - - for _ in 0..2 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; - continue; - } + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_ls32(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None } - - // Match failed - break; } - if let Some((_, npos)) = parse_h16(str, tpos) { - tpos = npos; + if let Some(tpos_val) = tpos { + pos = tpos_val; } + } - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; - } else { - tpos = pos; - } + // [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 + if pos == start { + let mut tpos = parse_first_part_ipv6(str, pos, 2); - if tpos != pos { + if let Some(ref mut tpos_val) = tpos { for _ in 0..2 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; + if let Some(npos) = parse_h16(str, *tpos_val) { + if let Some(npos) = parse_exact_string(str, npos, ":") { + *tpos_val = npos; continue; } } // We fail the match, Rollback and stop - tpos = pos; + tpos = None; break; } } - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_ls32(str, tpos) { - pos = npos; + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_ls32(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None } } - } - - if pos == start { - let mut tpos = pos; - for _ in 0..3 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; - continue; - } - } - - // Match failed - break; - } - - if let Some((_, npos)) = parse_h16(str, tpos) { - tpos = npos; + if let Some(tpos_val) = tpos { + pos = tpos_val; } + } - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; - } else { - tpos = pos; - } + // [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32 + if pos == start { + let mut tpos = parse_first_part_ipv6(str, pos, 3); - if tpos != pos { + if let Some(ref mut tpos_val) = tpos { for _ in 0..1 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; + if let Some(npos) = parse_h16(str, *tpos_val) { + if let Some(npos) = parse_exact_string(str, npos, ":") { + *tpos_val = npos; continue; } } // We fail the match, Rollback and stop - tpos = pos; + tpos = None; break; } } - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_ls32(str, tpos) { - pos = npos; + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_ls32(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None } } + + if let Some(tpos_val) = tpos { + pos = tpos_val; + } } + // [ *4( h16 ":" ) h16 ] "::" ls32 if pos == start { - let mut tpos = pos; + let mut tpos = parse_first_part_ipv6(str, pos, 4); - for _ in 0..4 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; - continue; - } + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_ls32(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None } - - // Match failed - break; - } - - if let Some((_, npos)) = parse_h16(str, tpos) { - tpos = npos; - } - - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; - } else { - tpos = pos; } - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_ls32(str, tpos) { - pos = npos; - } + if let Some(tpos_val) = tpos { + pos = tpos_val; } } + // [ *5( h16 ":" ) h16 ] "::" h16 if pos == start { - let mut tpos = pos; + let mut tpos = parse_first_part_ipv6(str, pos, 5); - for _ in 0..5 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; - continue; - } + if let Some(ref mut tpos_val) = tpos { + if let Some(npos) = parse_h16(str, *tpos_val) { + *tpos_val = npos; + } else { + tpos = None } - - // Match failed - break; - } - - if let Some((_, npos)) = parse_h16(str, tpos) { - tpos = npos; } - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; - } else { - tpos = pos; - } - - if tpos != pos { - // We successfully matched the last part - if let Some((_, npos)) = parse_h16(str, tpos) { - pos = npos; - } + if let Some(tpos_val) = tpos { + pos = tpos_val; } } if pos == start { - let mut tpos = pos; - - for _ in 0..6 { - if let Some((_, npos)) = parse_h16(str, tpos) { - if let Some((_, npos)) = parse_exact_string(str, npos, ":") { - tpos = npos; - continue; - } - } + let tpos = parse_first_part_ipv6(str, pos, 6); - // Match failed - break; - } - - if let Some((_, npos)) = parse_h16(str, tpos) { - tpos = npos; + if let Some(tpos_val) = tpos { + pos = tpos_val; } - - if let Some((_, npos)) = parse_exact_string(str, tpos, "::") { - tpos = npos; - } else { - tpos = pos; - } - - pos = tpos; } if pos == start { return None; } - return Some((start..pos, pos)); -} - -#[cfg(test)] -mod test_ipv6address { - use super::*; - - #[test] - fn parses_full_ipv6address() { - let data = "2001:0db8:85a3:0000:0000:8a2e:0370:7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 39); - assert_eq!(range.start, 0); - assert_eq!(range.end, 39); - } - - #[test] - fn parses_7part_ipv6address() { - let data = "::0db8:85a3:0000:0000:8a2e:0370:7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 36); - assert_eq!(range.start, 0); - assert_eq!(range.end, 36); - } - - #[test] - fn parses_6part_ipv6address() { - let data = "::85a3:0000:0000:8a2e:0370:7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 31); - assert_eq!(range.start, 0); - assert_eq!(range.end, 31); - } - - #[test] - fn parses_5part_ipv6address() { - let data = "::0000:0000:8a2e:0370:7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 26); - assert_eq!(range.start, 0); - assert_eq!(range.end, 26); - } - - #[test] - fn parses_4part_ipv6address() { - let data = "::0000:8a2e:0370:7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 21); - assert_eq!(range.start, 0); - assert_eq!(range.end, 21); - } - - #[test] - fn parses_3part_ipv6address() { - let data = "::8a2e:0370:7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 16); - assert_eq!(range.start, 0); - assert_eq!(range.end, 16); - } - - #[test] - fn parses_2part_ipv6address() { - let data = "::0370:7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 11); - assert_eq!(range.start, 0); - assert_eq!(range.end, 11); - } - - #[test] - fn parses_1part_ipv6address() { - let data = "::7334".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 6); - assert_eq!(range.start, 0); - assert_eq!(range.end, 6); - } - - #[test] - fn parses_0part_ipv6address() { - let data = "::".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 2); - assert_eq!(range.start, 0); - assert_eq!(range.end, 2); - } - - #[test] - fn parses_full_ipv6address_trailing_ipv4() { - let data = "2001:0db8:85a3:0000:0000:8a2e:127.0.0.1".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 39); - assert_eq!(range.start, 0); - assert_eq!(range.end, 39); - } - - #[test] - fn parses_compressed_ipv6_loopback() { - let data = "::1".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 3); - assert_eq!(range.start, 0); - assert_eq!(range.end, 3); - } - - #[test] - fn parses_ipv6_with_embedded_ipv4() { - let data = "::ffff:192.0.2.128".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 18); - assert_eq!(range.start, 0); - assert_eq!(range.end, 18); - } - - #[test] - fn rejects_invalid_ipv6_hex() { - let data = "2001:db8::g1".chars().collect(); - - let res = parse_ipv6address(&data, 0); - - assert!(res.is_none()); - } - - #[test] - fn rejects_multiple_compressions() { - let data = "2001::85a3::7334".chars().collect(); - - let res = parse_ipv6address(&data, 0); - - assert!(res.is_none()); - } - - #[test] - fn rejects_too_many_segments() { - let data = "1:2:3:4:5:6:7:8:9".chars().collect(); - - let res = parse_ipv6address(&data, 0); - - assert!(res.is_none()); - } - - #[test] - fn rejects_missing_segments_without_compression() { - let data = "2001:db8:85a3:0:0:8a2e:370".chars().collect(); - - let res = parse_ipv6address(&data, 0); - - assert!(res.is_none()); - } - - #[test] - fn parses_trailing_compression() { - let data = "2001:db8:85a3::".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 15); - assert_eq!(range.start, 0); - assert_eq!(range.end, 15); - } - - #[test] - fn parses_compressed_ipv6_with_ipv4_tail() { - let data = "2001:db8::192.0.2.33".chars().collect(); - - let (range, pos) = parse_ipv6address(&data, 0).unwrap(); - - assert_eq!(pos, 21); - assert_eq!(range.start, 0); - assert_eq!(range.end, 21); - } - - #[test] - fn rejects_ipv4_tail_out_of_range() { - let data = "2001::256.0.0.1".chars().collect(); - - let res = parse_ipv6address(&data, 0); - - assert!(res.is_none()); - } + return Some(pos); } - -fn parse_ipvfuture(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_ipvfuture(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - let (_, npos) = parse_exact_string(str, pos, "v")?; + let npos = parse_exact_string(str, pos, "v")?; pos = npos; - let (_, npos) = parse_hexdig(str, pos)?; + let npos = parse_hexdig(str, pos)?; pos = npos; loop { - if let Some((_, npos)) = parse_hexdig(str, pos) { + if let Some(npos) = parse_hexdig(str, pos) { pos = npos; } else { break; } } - let (_, npos) = parse_exact_string(str, pos, ".")?; + let npos = parse_exact_string(str, pos, ".")?; pos = npos; - if let Some((_, npos)) = parse_unreserved(str, pos) { + if let Some(npos) = parse_unreserved(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_sub_delims(str, pos) { + } else if let Some(npos) = parse_sub_delims(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_exact_string(str, pos, ":") { + } else if let Some(npos) = parse_exact_string(str, pos, ":") { pos = npos; } else { return None; } loop { - if let Some((_, npos)) = parse_unreserved(str, pos) { + if let Some(npos) = parse_unreserved(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_sub_delims(str, pos) { + } else if let Some(npos) = parse_sub_delims(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_exact_string(str, pos, ":") { + } else if let Some(npos) = parse_exact_string(str, pos, ":") { pos = npos; } else { break; } } - return Some((start..pos, pos)); -} - -#[cfg(test)] -mod test_ipvfuture { - use super::*; - - #[test] - fn parses_ipvfuture_with_colons_and_subdelims() { - let data = "vF.fe80::1-._~+!".chars().collect(); - - let (range, pos) = parse_ipvfuture(&data, 0).unwrap(); - - assert_eq!(pos, 16); - assert_eq!(range.start, 0); - assert_eq!(range.end, 16); - } - - #[test] - fn rejects_ipvfuture_missing_dot() { - let data = "v1fe80::1".chars().collect(); - - let res = parse_ipvfuture(&data, 0); - - assert!(res.is_none()); - } - - #[test] - fn rejects_ipvfuture_with_percent_encoded() { - let data = "v1.fe80::1%25".chars().collect(); - - let (range, pos) = parse_ipvfuture(&data, 0).unwrap(); - - assert_eq!(pos, 10); - assert_eq!(range.start, 0); - assert_eq!(range.end, 10); - } + return Some(pos); } - -fn parse_ip_literal(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_ip_literal(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; if let Some(ch) = str.get(pos) && *ch == '[' { @@ -1068,9 +805,9 @@ fn parse_ip_literal(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usiz return None; } - if let Some((_, npos)) = parse_ipv6address(str, pos) { + if let Some(npos) = parse_ipv6address(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_ipvfuture(str, pos) { + } else if let Some(npos) = parse_ipvfuture(str, pos) { pos = npos; } else { return None; @@ -1078,13 +815,13 @@ fn parse_ip_literal(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usiz if let Some(ch) = str.get(pos) && *ch == ']' { pos += 1; - return Some((start..pos, pos)); + return Some(pos); } return None; } -fn parse_port(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_port(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; while let Some(ch) = str.get(pos) { @@ -1094,39 +831,39 @@ fn parse_port(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_host(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_host(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - if let Some((_, npos)) = parse_ip_literal(str, pos) { + if let Some(npos) = parse_ip_literal(str, pos) { pos = npos; - return Some((start..pos, pos)); + return Some(pos); } - if let Some((_, npos)) = parse_ipv4address(str, pos) { + if let Some(npos) = parse_ipv4address(str, pos) { pos = npos; - return Some((start..pos, pos)); + return Some(pos); } - if let Some((_, npos)) = parse_reg_name(str, pos) { + if let Some(npos) = parse_reg_name(str, pos) { pos = npos; - return Some((start..pos, pos)); + return Some(pos); } return None; } -fn parse_userinfo(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_userinfo(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; loop { - if let Some((_, npos)) = parse_unreserved(str, pos) { + if let Some(npos) = parse_unreserved(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_pct_encoded(str, pos) { + } else if let Some(npos) = parse_pct_encoded(str, pos) { pos = npos; - } else if let Some((_, npos)) = parse_sub_delims(str, pos) { + } else if let Some(npos) = parse_sub_delims(str, pos) { pos = npos; } else if let Some(ch) = str.get(pos) && *ch == ':' { pos += 1; @@ -1135,37 +872,37 @@ fn parse_userinfo(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize) } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_authority(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_authority(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - if let Some((_, npos)) = parse_userinfo(str, pos) { + if let Some(npos) = parse_userinfo(str, pos) { if let Some(ch) = str.get(npos) && *ch == '@' { pos = npos; } } // If the character after the userinfo isn't a @ we roll back that parse and try it as a host. - if let Some((_, npos)) = parse_host(str, pos) { + if let Some(npos) = parse_host(str, pos) { pos = npos; } else { return None; } if let Some(ch) = str.get(pos) && *ch == ':' { - if let Some((_, npos)) = parse_port(str, pos+1) { + if let Some(npos) = parse_port(str, pos+1) { pos = npos; } else { return None; } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_relative_part_1(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_relative_part_1(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; if str[pos] != '/' || str[pos+1] != '/' { @@ -1173,16 +910,16 @@ fn parse_relative_part_1(str: &Vec<char>, start: usize) -> Option<(Range<usize>, } pos += 2; - let (_, npos) = parse_authority(str, pos)?; + let npos = parse_authority(str, pos)?; pos = npos; - let (_, npos) = parse_path_abempty(str, pos)?; + let npos = parse_path_abempty(str, pos)?; pos = npos; - return Some((start..pos, pos)); + return Some(pos); } -fn parse_unreserved(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_unreserved(str: &Vec<char>, start: usize) -> Option<usize> { if let Some(x) = parse_alpha(str, start) { return Some(x); } @@ -1195,12 +932,12 @@ fn parse_unreserved(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usiz return None; } match str[start] { - '-' | '.' | '_' | '~' => Some((start..start+1, start+1)), + '-' | '.' | '_' | '~' => Some(start+1), _ => None } } -fn parse_pct_encoded(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_pct_encoded(str: &Vec<char>, start: usize) -> Option<usize> { if start + 2 >= str.len() { return None; } @@ -1212,25 +949,25 @@ fn parse_pct_encoded(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usi let is_hexdig = |ch: char| matches!(ch, '0'..='9' | 'A'..='F' | 'a'..='f'); if is_hexdig(str[start + 1]) && is_hexdig(str[start + 2]) { - return Some((start..start + 3, start + 3)); + return Some(start + 3); } return None; } -fn parse_sub_delims(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_sub_delims(str: &Vec<char>, start: usize) -> Option<usize> { if start >= str.len() { return None; } match str[start] { - '!' | '$' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | ';' | '=' => Some((start..start+1, start+1)), + '!' | '$' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | ';' | '=' => Some(start+1), _ => None } } -fn parse_pchar(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_pchar(str: &Vec<char>, start: usize) -> Option<usize> { if let Some(x) = parse_unreserved(str, start) { return Some(x); } @@ -1245,7 +982,7 @@ fn parse_pchar(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { if let Some(ch) = str.get(start) { match ch { - ':' | '@' => return Some((start..start + 1, start + 1)), + ':' | '@' => return Some(start + 1), _ => {} } } @@ -1253,38 +990,38 @@ fn parse_pchar(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { return None; } -fn parse_segment_nz(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_segment_nz(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - let (_, npos) = parse_pchar(str, pos)?; + let npos = parse_pchar(str, pos)?; pos = npos; loop { - if let Some((_, npos)) = parse_pchar(str, pos) { + if let Some(npos) = parse_pchar(str, pos) { pos = npos; } else { break; } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_segment(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_segment(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; loop { - if let Some((_, npos)) = parse_pchar(str, pos) { + if let Some(npos) = parse_pchar(str, pos) { pos = npos; } else { break; } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_path_absolute(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_path_absolute(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; if str[pos] != '/' { @@ -1292,7 +1029,7 @@ fn parse_path_absolute(str: &Vec<char>, start: usize) -> Option<(Range<usize>, u } pos += 1; - if let Some((_, npos)) = parse_segment_nz(str, pos) { + if let Some(npos) = parse_segment_nz(str, pos) { pos = npos; loop { @@ -1300,7 +1037,7 @@ fn parse_path_absolute(str: &Vec<char>, start: usize) -> Option<(Range<usize>, u break; } - if let Some((_, npos)) = parse_segment(str, pos+1) { + if let Some(npos) = parse_segment(str, pos+1) { pos = npos; } else { break; @@ -1308,15 +1045,15 @@ fn parse_path_absolute(str: &Vec<char>, start: usize) -> Option<(Range<usize>, u } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_path_abempty(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_path_abempty(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; loop { if let Some(ch) = str.get(pos) && *ch == '/' { - if let Some((_, npos)) = parse_segment(str, pos+1) { + if let Some(npos) = parse_segment(str, pos+1) { pos = npos; } else { break; @@ -1326,41 +1063,26 @@ fn parse_path_abempty(str: &Vec<char>, start: usize) -> Option<(Range<usize>, us } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_relative_part(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_relative_part(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - if let Some((_, npos)) = parse_relative_part_1(str, pos) { + if let Some(npos) = parse_relative_part_1(str, pos) { pos = npos; - return Some((start..pos, pos)); + return Some(pos); } - if let Some((_, npos)) = parse_path_absolute(str, pos) { + if let Some(npos) = parse_path_absolute(str, pos) { pos = npos; - return Some((start..pos, pos)); + return Some(pos); } return None; } -#[cfg(test)] -mod test_relative_part { - use super::*; - - #[test] - fn absolute_path() { - let data = "/foo?".chars().collect(); - - let (range, pos) = parse_relative_part(&data, 0).unwrap(); - assert_eq!(pos, 4); - assert_eq!(range.start, 0); - assert_eq!(range.end, 4); - } -} - -fn parse_query(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_query(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; if start >= str.len() { @@ -1368,7 +1090,7 @@ fn parse_query(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { } loop { - if let Some((_, npos)) = parse_pchar(str, pos) { + if let Some(npos) = parse_pchar(str, pos) { pos = npos; } else if let Some(ch) = str.get(pos) && *ch == '/' { pos += 1; @@ -1379,10 +1101,10 @@ fn parse_query(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { } } - return Some((start..pos, pos)); + return Some(pos); } -fn parse_fragment(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_fragment(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; if start >= str.len() { @@ -1390,7 +1112,7 @@ fn parse_fragment(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize) } loop { - if let Some((_, npos)) = parse_pchar(str, pos) { + if let Some(npos) = parse_pchar(str, pos) { pos = npos; } else if let Some(ch) = str.get(pos) && (*ch == '/' || *ch == '?') { pos += 1; @@ -1399,90 +1121,37 @@ fn parse_fragment(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize) } } - return Some((start..pos, pos)); + return Some(pos); } // RFC 3986 -fn parse_relative_ref(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_relative_ref(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - let (_, npos) = parse_relative_part(str, pos)?; + let npos = parse_relative_part(str, pos)?; pos = npos; - if let Some(ch) = str.get(pos) && *ch == '?' && let Some((_, npos)) = parse_query(str, pos+1) { + if let Some(ch) = str.get(pos) && *ch == '?' && let Some(npos) = parse_query(str, pos+1) { pos = npos; } - if let Some(ch) = str.get(pos) && *ch == '#' && let Some((_, npos)) = parse_fragment(str, pos+1) { + if let Some(ch) = str.get(pos) && *ch == '#' && let Some(npos) = parse_fragment(str, pos+1) { pos = npos; } - return Some((start..pos, pos)); + return Some(pos); } -#[cfg(test)] -mod test_relative_ref { - use super::*; - - #[test] - fn reject_not_starting_slash() { - let data = vec!['?']; - - let res = parse_relative_ref(&data, 0); - assert!(res.is_none()); - } - - #[test] - fn simple() { - let data = vec!['/', '/', 'h', 'e', 'l', 'l', 'o', '/']; - - let (range, pos) = parse_relative_ref(&data, 0).unwrap(); - assert_eq!(pos, 8); - assert_eq!(range.start, 0); - assert_eq!(range.end, 8); - } - - #[test] - fn with_query_parameter() { - let data = "/foo?bar=baz".chars().collect(); - - let (range, pos) = parse_relative_ref(&data, 0).unwrap(); - assert_eq!(pos, 12); - assert_eq!(range.start, 0); - assert_eq!(range.end, 12); - } - - #[test] - fn with_fragment() { - let data = "/foo#frag".chars().collect(); - - let (range, pos) = parse_relative_ref(&data, 0).unwrap(); - assert_eq!(pos, data.len()); - assert_eq!(range.start, 0); - assert_eq!(range.end, data.len()); - } - - #[test] - fn with_percent_encoded_fragment() { - let data = "/foo#fr%20ag".chars().collect(); - - let (range, pos) = parse_relative_ref(&data, 0).unwrap(); - assert_eq!(pos, data.len()); - assert_eq!(range.start, 0); - assert_eq!(range.end, data.len()); - } -} - -fn parse_uri(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_uri(str: &Vec<char>, start: usize) -> Option<usize> { let mut pos = start; - let(_, npos) = parse_scheme(str, pos)?; + let npos = parse_scheme(str, pos)?; pos = npos; - return Some((start..pos, pos)); + return Some(pos); } -fn parse_exact_string(str: &Vec<char>, start: usize, to_match: &str) -> Option<(Range<usize>, usize)> { +fn parse_exact_string(str: &Vec<char>, start: usize, to_match: &str) -> Option<usize> { let mut pos = start; let end = pos + to_match.len(); @@ -1495,171 +1164,117 @@ fn parse_exact_string(str: &Vec<char>, start: usize, to_match: &str) -> Option<( } pos += to_match.len(); - return Some((start..pos, pos)); -} - -fn parse_loalpha(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { - match str.get(start) { - Some('a'..='z') => Some((start..start+1, start+1)), - _ => None, - } + return Some(pos); } -fn parse_relation_type(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { +fn parse_link_param(str: &Vec<char>, start: usize, res: &mut PartialNextPage) -> Option<usize> { let mut pos = start; - let (_, npos) = parse_loalpha(str, pos)?; - pos = npos; + let mut is_rel = false; - loop { - if let Some((_, npos)) = parse_loalpha(str, pos) { - pos = npos; - continue; - } else if let Some((_, npos)) = parse_digit(str, pos) { - pos = npos; - continue; - } else if let Some((_, npos)) = parse_exact_string(str, pos, ".") { - pos = npos; - continue; - } else if let Some((_, npos)) = parse_exact_string(str, pos, "-") { - pos = npos; - continue; - } else { - break; - } + if let Some(npos) = parse_exact_string(str, pos, "rel") { + is_rel = true; + pos = npos; + } else if let Some(npos) = parse_token(str, pos) { + pos = npos; + } else { + return None; } - return Some((start..pos, pos)); -} - -fn parse_relation_types(str: &Vec<char>, start: usize) -> Option<(Range<usize>, usize)> { - let mut pos = start; - - if let Some((_, npos)) = parse_relation_type(str, pos) { + // @CORRECT This part is actually supposed to be optional + if let Some(npos) = parse_ows(str, pos) { pos = npos; + } - return Some((start..pos, pos)); - } else if let Some((_, npos)) = parse_exact_string(str, pos, "\"") { + if let Some(npos) = parse_exact_string(str, pos, "=") { pos = npos; - - if let Some((_, npos)) = parse_relation_type(str, pos) { - pos = npos; - - loop { - if let Some((_, npos)) = parse_sp(str, pos) { - - loop { - if let Some((_, npos)) = parse_sp(str, pos) { - pos = npos; - } else { - break; - } - } - - pos = npos; - if let Some((_, npos)) = parse_relation_type(str, pos) { - pos = npos; - continue; - } - } - break; - } - - if let Some((_, npos)) = parse_exact_string(str, pos, "\"") { - pos = npos; - return Some((start+1..pos-1, pos)); - } - } + } else { + return None; } - return None; -} - -fn parse_link_param(str: &Vec<char>, start: usize) -> Option<(LinkParam, usize)> { - let mut pos = start; - - // Non-standard but seen in the wild - if let Some((_, npos)) = parse_sp(str, pos) { + if let Some(npos) = parse_ows(str, pos) { pos = npos; } - if let Some((_, npos)) = parse_exact_string(str, pos, "rel=") { - if let Some((relation, npos)) = parse_relation_types(str, npos) { - pos = npos; - return Some((LinkParam::Rel{relation}, pos)); - } + // @INCOMPLETE This is not exhaustive + if is_rel && let Some(npos) = parse_exact_string(str, pos, "\"next\"") { + res.found_next_uri = Some(res.current_uri.clone()); + pos = npos; + } else if let Some(npos) = parse_token(str, pos) { + pos = npos; + } else if let Some(npos) = parse_quotedstring(str, pos, &mut None) { + pos = npos; + } else { + return None; } - return None; + return Some(pos); } -fn parse_link_value(str: &Vec<char>, start: usize) -> Option<(LinkValue, usize)> { +fn parse_link_value(str: &Vec<char>, start: usize, res: &mut PartialNextPage) -> Option<usize> { let mut pos = start; - if let Some((_, npos)) = parse_exact_string(str, pos, "<") { + if let Some(npos) = parse_exact_string(str, pos, "<") { pos = npos; } else { return None; } - let uri_range; - let mut params = vec!(); - - if let Some((range, npos)) = parse_uri(str, pos) { - uri_range = range; + res.current_uri.start = pos; + if let Some(npos) = parse_uri(str, pos) { pos = npos; - } else if let Some((range, npos)) = parse_relative_ref(str, pos) { - uri_range = range; + } else if let Some(npos) = parse_relative_ref(str, pos) { pos = npos; } else { return None; } + res.current_uri.end = pos; - if let Some((_, npos)) = parse_exact_string(str, pos, ">") { + if let Some(npos) = parse_exact_string(str, pos, ">") { pos = npos; } else { return None; } loop { - if let Some((_, npos)) = parse_exact_string(str, pos, ";") { + if let Some(npos) = parse_exact_string(str, pos, ";") { pos = npos; } else { break; } - if let Some((param, npos)) = parse_link_param(str, pos) { + if let Some(npos) = parse_ows(str, pos) { + pos = npos; + } + + if let Some(npos) = parse_link_param(str, pos, res) { pos = npos; - params.push(param); } else { break; } } - return Some((LinkValue{ uri: uri_range, params: params }, pos)); + return Some(pos); } -pub fn parse_link(str: &Vec<char>, start: usize) -> Option<(Vec<LinkValue>, usize)> { +fn parse_link_into(str: &Vec<char>, start: usize, res: &mut PartialNextPage) -> Option<usize> { let mut pos = start; - let mut values = vec!(); - loop { match parse_lws(str, pos) { - Some((_, npos)) => pos = npos, + Some(npos) => pos = npos, None => break, } } - let (param, npos) = parse_link_value(str, pos)?; - values.push(param); + let npos = parse_link_value(str, pos, res)?; pos = npos; loop { let mut ipos = pos; loop { match parse_lws(str, ipos) { - Some((_, npos)) => ipos = npos, + Some(npos) => ipos = npos, None => break, } } @@ -1671,15 +1286,14 @@ pub fn parse_link(str: &Vec<char>, start: usize) -> Option<(Vec<LinkValue>, usiz loop { match parse_lws(str, ipos) { - Some((_, npos)) => ipos = npos, + Some(npos) => ipos = npos, None => break, } } - match parse_link_value(str, ipos) { - Some((param, npos)) => { + match parse_link_value(str, ipos, res) { + Some(npos) => { ipos = npos; - values.push(param); }, None => { break; @@ -1690,194 +1304,34 @@ pub fn parse_link(str: &Vec<char>, start: usize) -> Option<(Vec<LinkValue>, usiz } - return Some((values, pos)); + return Some(pos); } -#[cfg(test)] -mod test_link { - use super::*; - - #[test] - fn parses_relative_authority_only() { - let data: Vec<char> = "<//example.com>".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 15); - assert_eq!(links.len(), 1); - assert_eq!(links[0].uri, 1..14); - assert_eq!(links[0].params.len(), 0); - } - - #[test] - fn parses_relative_absolute_path() { - let data: Vec<char> = "</path/to/resource>".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 19); - assert_eq!(links.len(), 1); - assert_eq!(links[0].uri, 1..18); - } - - #[test] - fn parses_relative_with_query() { - let data: Vec<char> = "</foo?bar=baz>".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 14); - assert_eq!(links.len(), 1); - assert_eq!(links[0].uri, 1..13); - } - - #[test] - fn parses_rel_param_unquoted() { - let data: Vec<char> = "<//example.com>; rel=preconnect".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 31); - - match &links[0].params[0] { - LinkParam::Rel { relation } => { - assert_eq!(relation.clone(), 21..31); - } - _ => assert!(false), - } - } - - #[test] - fn parses_multiple_links_with_lws() { - let data: Vec<char> = "<//a>; rel=preconnect, <//b>".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 28); - assert_eq!(links.len(), 2); - - match &links[0].params[0] { - LinkParam::Rel { relation } => { - assert_eq!(relation.clone(), 11..21); - } - } - - assert_eq!(links[1].params.len(), 0); - assert_eq!(links[0].uri, 1..4); - assert_eq!(links[1].uri, 24..27); - } - - #[test] - fn parses_lws_between_link_values() { - let data: Vec<char> = "<//a>,\r\n <//b>".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 14); - assert_eq!(links.len(), 2); - assert_eq!(links[0].uri, 1..4); - assert_eq!(links[1].uri, 10..13); - } - - #[test] - // Is this correct? - fn rejects_absolute_uri() { - let data: Vec<char> = "<http://example.com>".chars().collect(); - - let res = parse_link(&data, 0); - assert!(res.is_none()); - } - - #[test] - fn rejects_missing_closing_delimiter() { - let data: Vec<char> = "<//example.com".chars().collect(); - - let res = parse_link(&data, 0); - assert!(res.is_none()); - } +#[derive(Default)] +struct PartialNextPage { + current_uri: Range<usize>, - #[test] - fn parses_quoted_rel_multiple_values() { - let data: Vec<char> = "<//example.com>; rel=\"preconnect dns-prefetch\"".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, data.len()); - assert_eq!(links.len(), 1); - assert_eq!(links[0].params.len(), 1); - - match &links[0].params[0] { - LinkParam::Rel { relation } => { - assert_eq!(relation.clone(), 22..45); - } - } - } - - #[test] - #[ignore = "absolute URI targets are not parsed yet"] - fn parses_absolute_uri_with_rel() { - let data: Vec<char> = "<http://example.com>; rel=preconnect".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); + found_next_uri: Option<Range<usize>>, +} - assert_eq!(pos, 35); - assert_eq!(links.len(), 1); - assert_eq!(links[0].uri, 1..19); - match &links[0].params[0] { - LinkParam::Rel { relation } => assert_eq!(relation.clone(), 22..32), +impl Into<NextPage> for PartialNextPage { + fn into(self) -> NextPage { + return NextPage { + next_uri: self.found_next_uri, } } +} - #[test] - #[ignore = "additional parameters beyond rel= are not parsed"] - fn parses_title_parameter() { - let data: Vec<char> = "<//example.com>; rel=preconnect; title=\"Example\"".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 57); - assert_eq!(links.len(), 1); - assert_eq!(links[0].params.len(), 2); - } - - #[test] - #[ignore = "extended title* parameter not supported"] - fn parses_title_star_parameter() { - let data: Vec<char> = "<//example.com>; rel=preconnect; title*=UTF-8''Ex%C3%A4mple".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 65); - assert_eq!(links.len(), 1); - } - - #[test] - #[ignore = "anchor parameter not parsed"] - fn parses_anchor_parameter() { - let data: Vec<char> = "<//example.com>; rel=preconnect; anchor=\"/base\"".chars().collect(); - - let (links, pos) = parse_link(&data, 0).unwrap(); - - assert_eq!(pos, 56); - assert_eq!(links.len(), 1); - } - - #[test] - #[ignore = "hreflang parameter not parsed"] - fn parses_hreflang_parameter() { - let data: Vec<char> = "<//example.com>; rel=preconnect; hreflang=en".chars().collect(); +pub struct NextPage { + pub next_uri: Option<Range<usize>> +} - let (links, pos) = parse_link(&data, 0).unwrap(); +pub fn extract_next_page(header: &str) -> Option<NextPage> { + let mut partial = Default::default(); - assert_eq!(pos, 53); - assert_eq!(links.len(), 1); - } + let data = header.chars().collect(); - #[test] - fn rejects_percent_encoded_path() { - let data: Vec<char> = "</pa%20th>".chars().collect(); + parse_link_into(&data, 0, &mut partial)?; - let res = parse_link(&data, 0); - assert!(res.is_some()); - } + return Some(partial.into()); } |