use std::collections::BTreeMap;
use std::fmt;
use crate::error::{ParseError, Result};
use crate::tokenize::strip_quotes;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Request {
pub primitive: String,
pub args: Vec<String>,
pub flags: BTreeMap<String, Option<String>>,
}
impl Request {
#[must_use]
pub fn new(primitive: impl Into<String>) -> Self {
Self {
primitive: primitive.into(),
args: Vec::new(),
flags: BTreeMap::new(),
}
}
#[must_use]
pub fn arg(mut self, value: impl Into<String>) -> Self {
self.args.push(value.into());
self
}
#[must_use]
pub fn flag(mut self, name: impl Into<String>) -> Self {
self.flags.insert(name.into(), None);
self
}
#[must_use]
pub fn flag_value(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
self.flags.insert(name.into(), Some(value.into()));
self
}
#[must_use]
pub fn encode(&self) -> String {
let mut out = self.primitive.clone();
for arg in &self.args {
out.push(' ');
out.push_str("e_arg(&escape_wire(arg)));
}
for (k, v) in &self.flags {
out.push(' ');
out.push_str("--");
out.push_str(k);
if let Some(value) = v {
out.push('=');
out.push_str("e_arg(&escape_wire(value)));
}
}
out.push('\n');
out
}
pub fn parse(line: &str) -> Result<Self> {
let trimmed = line.trim_end_matches('\n').trim();
if trimmed.is_empty() {
return Err(ParseError::InvalidRequest {
detail: "empty request line",
});
}
let mut tokens = raw_tokens(trimmed).into_iter();
let primitive_tok = tokens.next().ok_or(ParseError::InvalidRequest {
detail: "missing primitive",
})?;
if !is_valid_primitive(primitive_tok) {
return Err(ParseError::InvalidRequest {
detail: "invalid primitive name",
});
}
let mut args = Vec::new();
let mut flags = BTreeMap::new();
for tok in tokens {
if let Some(rest) = tok.strip_prefix("--") {
if rest.is_empty() {
return Err(ParseError::InvalidRequest {
detail: "flag with no name",
});
}
if let Some((name, value)) = rest.split_once('=') {
if name.is_empty() {
return Err(ParseError::InvalidRequest {
detail: "flag with empty name",
});
}
flags.insert(name.to_string(), Some(unescape_wire(strip_quotes(value))));
} else {
flags.insert(rest.to_string(), None);
}
} else {
args.push(unescape_wire(strip_quotes(tok)));
}
}
Ok(Self {
primitive: primitive_tok.to_string(),
args,
flags,
})
}
}
impl fmt::Display for Request {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.encode().trim_end_matches('\n'))
}
}
fn escape_wire(s: &str) -> String {
if !s.contains(['\\', '"', '\n', '\r', '\t']) {
return s.to_string();
}
let mut out = String::with_capacity(s.len() + 8);
for c in s.chars() {
match c {
'\\' => out.push_str("\\\\"),
'"' => out.push_str("\\\""),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
other => out.push(other),
}
}
out
}
fn unescape_wire(s: &str) -> String {
if !s.contains('\\') {
return s.to_string();
}
let mut out = String::with_capacity(s.len());
let mut chars = s.chars();
while let Some(c) = chars.next() {
if c != '\\' {
out.push(c);
continue;
}
match chars.next() {
Some('\\') | None => out.push('\\'),
Some('"') => out.push('"'),
Some('n') => out.push('\n'),
Some('r') => out.push('\r'),
Some('t') => out.push('\t'),
Some(other) => {
out.push('\\');
out.push(other);
}
}
}
out
}
fn quote_arg(escaped: &str) -> String {
if escaped.is_empty() || escaped.contains([' ', '\t']) {
format!("\"{escaped}\"")
} else {
escaped.to_string()
}
}
fn raw_tokens(s: &str) -> Vec<&str> {
let mut tokens = Vec::new();
let mut rest = s;
loop {
let trimmed = rest.trim_start_matches([' ', '\t']);
if trimmed.is_empty() {
return tokens;
}
let mut in_quotes = false;
let mut end = trimmed.len();
let mut chars = trimmed.char_indices();
while let Some((i, c)) = chars.next() {
match c {
'\\' => {
chars.next();
}
'"' => in_quotes = !in_quotes,
' ' | '\t' if !in_quotes => {
end = i;
break;
}
_ => {}
}
}
tokens.push(&trimmed[..end]);
rest = &trimmed[end..];
}
}
fn is_valid_primitive(s: &str) -> bool {
!s.is_empty()
&& s.chars()
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn primitive_only() {
let r = Request::new("vs_view");
let s = r.encode();
assert_eq!(s, "vs_view\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn with_arg() {
let r = Request::new("vs_open").arg("https://example.com");
let s = r.encode();
assert_eq!(s, "vs_open https://example.com\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn with_quoted_arg() {
let r = Request::new("vs_act")
.arg("2")
.arg("fill")
.arg("frane@example.com");
let s = r.encode();
assert_eq!(s, "vs_act 2 fill frane@example.com\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn arg_with_spaces_quoted() {
let r = Request::new("vs_act")
.arg("2")
.arg("fill")
.arg("with spaces");
let s = r.encode();
assert_eq!(s, "vs_act 2 fill \"with spaces\"\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn bare_flag() {
let r = Request::new("vs_capture").flag("full-page");
let s = r.encode();
assert_eq!(s, "vs_capture --full-page\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn flag_with_value() {
let r = Request::new("vs_capture").flag_value("viewport", "mobile");
let s = r.encode();
assert_eq!(s, "vs_capture --viewport=mobile\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn flag_value_with_spaces_quoted() {
let r = Request::new("vs_session_open").flag_value("policy", "strict mode");
let s = r.encode();
assert_eq!(s, "vs_session_open --policy=\"strict mode\"\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn full_request() {
let r = Request::new("vs_capture")
.arg("7")
.flag("full-page")
.flag_value("viewport", "mobile");
let s = r.encode();
assert_eq!(s, "vs_capture 7 --full-page --viewport=mobile\n");
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn multiline_arg_survives_framing() {
let expr = "const x = 1;\nconst y = 2;\nx + y";
let r = Request::new("vs_inspect").arg("eval").arg("3").arg(expr);
let s = r.encode();
assert_eq!(
s.matches('\n').count(),
1,
"encoded request must be a single wire line; got {s:?}"
);
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn backslash_and_tab_round_trip() {
let expr = "a\tb /\\d+/ c\\nd"; let r = Request::new("vs_inspect").arg("eval").arg("1").arg(expr);
let s = r.encode();
assert_eq!(s.matches('\n').count(), 1);
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn double_quotes_in_arg_round_trip() {
for expr in [
r#"document.querySelector("a").href"#,
r#"x === "with space" && y"#,
r#"JSON.parse("{\"k\":1}")"#, ] {
let r = Request::new("vs_inspect").arg("eval").arg("1").arg(expr);
let s = r.encode();
assert_eq!(
s.matches('\n').count(),
1,
"single wire line expected for {expr:?}; got {s:?}"
);
assert_eq!(
Request::parse(&s).unwrap(),
r,
"round-trip failed for {expr:?} (encoded {s:?})"
);
}
}
#[test]
fn multiline_flag_value_round_trips() {
let r = Request::new("vs_act").flag_value("text", "line1\nline2");
let s = r.encode();
assert_eq!(s.matches('\n').count(), 1);
assert_eq!(Request::parse(&s).unwrap(), r);
}
#[test]
fn rejects_invalid_primitive() {
for bad in ["", "VS_VIEW", "--vs", "vs!", "vs-cli"] {
assert!(Request::parse(bad).is_err(), "{bad} should fail");
}
}
}