[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_165":-5,"_168":169,"_170":171},"routes/shell",{"_42":43,"_164":-5,"_165":-5,"_166":167},"routes/repo",{"_34":-7,"_35":36,"_37":38,"_39":40,"_41":32,"_42":43,"_44":32,"_45":32,"_46":32,"_47":32,"_48":32,"_49":32,"_50":51,"_52":53,"_54":32,"_55":-7,"_56":-7,"_57":58,"_59":60,"_61":62,"_63":-5,"_64":65,"_66":67,"_68":69,"_70":71},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":-5,"_26":27,"_28":29,"_29":30,"_31":32,"_33":14},"ref","main","path","tests/oracle/yaml/src/main.rs","oid","d1124291bbd0746b47bb8a824cc7419e77f9e338","size",17370,"commit","12e96b5435e408a25422fcfd87d6fa5474b6e53a","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","//! Compares the parts of tidy's YAML parser with `yaml` 2.9.0, whose results `tests/oracle/yaml/*.ts` writes.\n//!\n//! bun tests/oracle/yaml/cst.ts > target/yaml-cst.json && cargo run --release -- cst target/yaml-cst.json\n\n#[path = \"../../../../crates/tidy/src/yaml/cst.rs\"]\n#[allow(dead_code)]\nmod cst;\n#[path = \"../../../../crates/tidy/src/yaml/lexer.rs\"]\nmod lexer;\n\nuse cst::{Item, Key, Node, Prop, ScalarKind, Source, Tree};\nuse serde_json::{Map, Value, json};\n\nfn main() {\n let worker = std::thread::Builder::new().stack_size(1 << 30).spawn(run).unwrap();\n worker.join().unwrap();\n}\n\n/// Reads a JSON file, as deep as its trees go.\nfn read(path: &str) -> Vec {\n use serde::Deserialize;\n let text = std::fs::read_to_string(path).unwrap();\n let mut deserializer = serde_json::Deserializer::from_str(&text);\n deserializer.disable_recursion_limit();\n Vec::::deserialize(&mut deserializer).unwrap()\n}\n\nfn run() {\n let args: Vec = std::env::args().skip(1).collect();\n match args.first().map(String::as_str) {\n Some(\"cst\") => cst(&args[1], args.get(2).and_then(|it| it.parse().ok()).unwrap_or(5)),\n Some(\"format\") => {\n format(&args[1], args.get(2).and_then(|it| it.parse().ok()).unwrap_or(5), args.get(3))\n }\n Some(\"ast\") => ast(&args[1], args.get(2).and_then(|it| it.parse().ok()).unwrap_or(5)),\n Some(\"accepts\") => accepts(&args[1], args.get(2).and_then(|it| it.parse().ok()).unwrap_or(10)),\n _ => eprintln!(\"usage: cst [show]\"),\n }\n}\n\nfn cst(path: &str, show: usize) {\n let cases = read(path);\n let (mut same, mut shown) = (0, 0);\n for case in &cases {\n let name = case[\"name\"].as_str().unwrap();\n let text = case[\"text\"].as_str().unwrap();\n let mut lexemes = Vec::new();\n lexer::Lexer::lex(text.as_bytes(), &mut lexemes);\n let mut tree = Tree::default();\n cst::Parser::parse(text.as_bytes(), &lexemes, &mut tree);\n let dump = Dump { text, utf16: utf16_offsets(text), tree: &tree };\n let actual = Value::Array(tree.tokens.iter().map(|id| dump.node(*id)).collect());\n let expected = strip_messages(case[\"cst\"].clone());\n if actual == expected {\n same += 1;\n continue;\n }\n if shown < show {\n shown += 1;\n println!(\"\\n✗ {name}\\n text {:?}\", text.chars().take(200).collect::());\n first_difference(&expected, &actual, \"\");\n }\n }\n println!(\"\\ncst: {same}/{} same\", cases.len());\n}\n\n/// Compares what Prettier prints with what tidy prints, under the option sets of `format.ts`.\nfn format(path: &str, show: usize, filter: Option<&String>) {\n use tidy::Wrap;\n use tidy::yaml::Options;\n let cases = read(path);\n let (mut same, mut total, mut shown) = (0, 0, 0);\n let mut per_set: std::collections::BTreeMap = Default::default();\n for case in &cases {\n let name = case[\"name\"].as_str().unwrap();\n let set = case[\"set\"].as_str().unwrap();\n if filter.is_some_and(|filter| !format!(\"{set}: {name}\").contains(filter.as_str())) {\n continue;\n }\n total += 1;\n let text = case[\"text\"].as_str().unwrap();\n let expected = case[\"expected\"].as_str().unwrap();\n let default = Options::default();\n let options = match set {\n \"single quotes, width 40\" => Options { single_quote: true, width: 40, ..default },\n \"prose always, width 40\" => Options { wrap: Wrap::Always, width: 40, ..default },\n \"prose never\" => Options { wrap: Wrap::Never, ..default },\n \"no bracket spacing, no trailing commas, indent 4\" => {\n Options { bracket_spacing: false, trailing_comma: false, tab_width: 4, ..default }\n }\n _ => default,\n };\n let actual = tidy::yaml::format(text, &options).unwrap_or_else(|_| \"!error\".into());\n if actual == expected {\n same += 1;\n continue;\n }\n *per_set.entry(set.to_owned()).or_default() += 1;\n if shown < show {\n shown += 1;\n println!(\"\\n✗ {set}: {name}\");\n let (expected, actual): (Vec<&str>, Vec<&str>) =\n (expected.lines().collect(), actual.lines().collect());\n let first = expected\n .iter()\n .zip(&actual)\n .position(|(a, b)| a != b)\n .unwrap_or(expected.len().min(actual.len()));\n let from = first.saturating_sub(3);\n for line in expected.iter().skip(from).take(8) {\n println!(\" - {line:?}\");\n }\n for line in actual.iter().skip(from).take(8) {\n println!(\" + {line:?}\");\n }\n }\n }\n for (set, count) in per_set {\n println!(\" {set}: {count} different\");\n }\n println!(\"\\nformat: {same}/{total} same\");\n}\n\n/// Compares the trees of Prettier's YAML parser with tidy's.\nfn ast(path: &str, show: usize) {\n let cases = read(path);\n let (mut same, mut shown) = (0, 0);\n for case in &cases {\n let name = case[\"name\"].as_str().unwrap();\n let text = case[\"text\"].as_str().unwrap();\n let actual = match tidy::yaml::parse(text) {\n Ok(root) => {\n let dump = AstDump { root: &root, utf16: utf16_offsets(text) };\n json!({ \"ast\": dump.node(root.root) })\n }\n Err(error) => json!({ \"error\": error.to_string() }),\n };\n let expected = json!({ \"ast\": case[\"ast\"] });\n if actual == expected {\n same += 1;\n continue;\n }\n if shown < show {\n shown += 1;\n println!(\"\\n✗ {name}\\n text {:?}\", text.chars().take(200).collect::());\n first_difference(&expected, &actual, \"\");\n }\n }\n println!(\"\\nast: {same}/{} same\", cases.len());\n}\n\nstruct AstDump<'d> {\n root: &'d tidy::yaml::Root,\n utf16: Vec,\n}\n\nimpl AstDump<'_> {\n fn point(&self, point: tidy::yaml::Point) -> Value {\n json!([point.line, point.column, self.utf16[point.offset as usize]])\n }\n\n fn node(&self, id: u32) -> Value {\n use tidy::yaml::{Chomping, Kind};\n let node = self.root.node(id);\n let kind = match node.kind {\n Kind::Root => \"root\",\n Kind::Document => \"document\",\n Kind::DocumentHead => \"documentHead\",\n Kind::DocumentBody => \"documentBody\",\n Kind::Directive => \"directive\",\n Kind::Comment => \"comment\",\n Kind::Tag => \"tag\",\n Kind::Anchor => \"anchor\",\n Kind::Alias => \"alias\",\n Kind::BlockLiteral => \"blockLiteral\",\n Kind::BlockFolded => \"blockFolded\",\n Kind::Plain => \"plain\",\n Kind::QuoteSingle => \"quoteSingle\",\n Kind::QuoteDouble => \"quoteDouble\",\n Kind::Mapping => \"mapping\",\n Kind::MappingItem => \"mappingItem\",\n Kind::MappingKey => \"mappingKey\",\n Kind::MappingValue => \"mappingValue\",\n Kind::Sequence => \"sequence\",\n Kind::SequenceItem => \"sequenceItem\",\n Kind::FlowMapping => \"flowMapping\",\n Kind::FlowMappingItem => \"flowMappingItem\",\n Kind::FlowSequence => \"flowSequence\",\n Kind::FlowSequenceItem => \"flowSequenceItem\",\n };\n let mut map = Map::new();\n map.insert(\"type\".into(), json!(kind));\n map.insert(\"start\".into(), self.point(node.position.start));\n map.insert(\"end\".into(), self.point(node.position.end));\n let valued = matches!(\n node.kind,\n Kind::Comment\n | Kind::Tag\n | Kind::Anchor\n | Kind::Alias\n | Kind::BlockLiteral\n | Kind::BlockFolded\n | Kind::Plain\n | Kind::QuoteSingle\n | Kind::QuoteDouble\n | Kind::Directive\n );\n if valued {\n map.insert(\"value\".into(), json!(node.value()));\n }\n if node.kind == Kind::Directive {\n map.insert(\"parameters\".into(), json!(node.parameters()));\n }\n let leaf = matches!(\n node.kind,\n Kind::Comment\n | Kind::Tag\n | Kind::Anchor\n | Kind::Alias\n | Kind::BlockLiteral\n | Kind::BlockFolded\n | Kind::Plain\n | Kind::QuoteSingle\n | Kind::QuoteDouble\n | Kind::Directive\n );\n if !leaf {\n map.insert(\n \"children\".into(),\n Value::Array(node.children().iter().map(|it| self.node(*it)).collect()),\n );\n }\n let list = |ids: &[u32]| Value::Array(ids.iter().map(|it| self.node(*it)).collect());\n if !node.leading_comments().is_empty() {\n map.insert(\"leadingComments\".into(), list(node.leading_comments()));\n }\n if !node.end_comments().is_empty() {\n map.insert(\"endComments\".into(), list(node.end_comments()));\n }\n if !node.middle_comments().is_empty() {\n map.insert(\"middleComments\".into(), list(node.middle_comments()));\n }\n for (key, value) in [\n (\"trailingComment\", node.trailing_comment),\n (\"indicatorComment\", node.indicator_comment()),\n (\"tag\", node.tag),\n (\"anchor\", node.anchor),\n ] {\n if let Some(value) = value {\n map.insert(key.into(), self.node(value));\n }\n }\n if matches!(node.kind, Kind::BlockLiteral | Kind::BlockFolded) {\n let chomping = match node.chomping {\n Chomping::Clip => \"clip\",\n Chomping::Keep => \"keep\",\n Chomping::Strip => \"strip\",\n };\n map.insert(\"chomping\".into(), json!(chomping));\n map.insert(\"indent\".into(), json!(node.indent));\n }\n if node.directives_end_marker {\n map.insert(\"directivesEndMarker\".into(), json!(true));\n }\n if node.document_end_marker {\n map.insert(\"documentEndMarker\".into(), json!(true));\n }\n Value::Object(map)\n }\n}\n\n/// Compares which inputs Prettier's parser accepts with which tidy's does.\nfn accepts(path: &str, show: usize) {\n let cases = read(path);\n let (mut same, mut shown) = (0, 0);\n for case in &cases {\n let name = case[\"name\"].as_str().unwrap();\n let text = case[\"text\"].as_str().unwrap();\n let expected = case[\"accepted\"].as_bool().unwrap();\n let actual = tidy::yaml::parse(text).map(|_| ());\n if expected == actual.is_ok() {\n same += 1;\n continue;\n }\n if shown < show {\n shown += 1;\n let message = case[\"message\"].as_str().unwrap_or_default();\n println!(\n \"\\n✗ {name}\\n text {:?}\\n prettier {}\\n tidy {:?}\",\n text.chars().take(160).collect::(),\n if expected { \"accepts\" } else { message },\n actual\n );\n }\n }\n println!(\"\\naccepts: {same}/{} same\", cases.len());\n}\n\nfn strip_messages(mut value: Value) -> Value {\n match &mut value {\n Value::Object(map) => {\n if map.get(\"type\") == Some(&json!(\"error\")) {\n map.remove(\"message\");\n map.remove(\"source\");\n }\n for value in map.values_mut() {\n *value = strip_messages(value.take());\n }\n }\n Value::Array(list) => {\n for value in list.iter_mut() {\n *value = strip_messages(value.take());\n }\n }\n _ => {}\n }\n value\n}\n\nfn first_difference(expected: &Value, actual: &Value, path: &str) {\n match (expected, actual) {\n (Value::Object(a), Value::Object(b)) => {\n for key in a.keys().chain(b.keys()) {\n if a.get(key) != b.get(key) {\n return match (a.get(key), b.get(key)) {\n (Some(x), Some(y)) => first_difference(x, y, &format!(\"{path}.{key}\")),\n (x, y) => println!(\" at {path}.{key}\\n yaml {x:?}\\n tidy {y:?}\"),\n };\n }\n }\n }\n (Value::Array(a), Value::Array(b)) => {\n for index in 0..a.len().max(b.len()) {\n if a.get(index) != b.get(index) {\n return match (a.get(index), b.get(index)) {\n (Some(x), Some(y)) => first_difference(x, y, &format!(\"{path}[{index}]\")),\n (x, y) => {\n println!(\" at {path}[{index}]\\n yaml {}\\n tidy {}\", short(x), short(y))\n }\n };\n }\n }\n }\n _ => {\n println!(\" at {path}\\n yaml {}\\n tidy {}\", short(Some(expected)), short(Some(actual)))\n }\n }\n}\n\nfn short(value: Option<&Value>) -> String {\n value.map(|it| it.to_string().chars().take(300).collect()).unwrap_or_else(|| \"absent\".into())\n}\n\n/// The UTF-16 offset of each byte offset, as `yaml` counts.\nfn utf16_offsets(text: &str) -> Vec {\n let mut out = vec![0; text.len() + 1];\n let mut units = 0;\n for (at, character) in text.char_indices() {\n for byte in 0..character.len_utf8() {\n out[at + byte] = units;\n }\n units += character.len_utf16() as u32;\n }\n out[text.len()] = units;\n out\n}\n\nstruct Dump<'d> {\n text: &'d str,\n utf16: Vec,\n tree: &'d Tree,\n}\n\nimpl Dump<'_> {\n fn offset(&self, offset: u32) -> Value {\n json!(self.utf16[offset as usize])\n }\n\n fn slice(&self, start: u32, end: u32) -> Value {\n json!(self.text[start as usize..end as usize])\n }\n\n fn source(&self, source: &Source) -> Value {\n json!({\n \"type\": kind(source.kind),\n \"offset\": self.offset(source.offset),\n \"indent\": source.indent,\n \"source\": self.slice(source.offset, source.end),\n })\n }\n\n fn sources(&self, list: &[Source]) -> Value {\n Value::Array(list.iter().map(|it| self.source(it)).collect())\n }\n\n fn item(&self, item: &Item) -> Value {\n let mut map = Map::new();\n map.insert(\"start\".into(), self.sources(&item.start));\n if item.explicit_key {\n map.insert(\"explicitKey\".into(), json!(true));\n }\n match item.key {\n Key::Absent => {}\n Key::Null => drop(map.insert(\"key\".into(), Value::Null)),\n Key::Token(id) => drop(map.insert(\"key\".into(), self.node(id))),\n }\n if let Some(sep) = &item.sep {\n map.insert(\"sep\".into(), self.sources(sep));\n }\n if let Some(value) = item.value {\n map.insert(\"value\".into(), self.node(value));\n }\n Value::Object(map)\n }\n\n fn node(&self, id: u32) -> Value {\n let mut map = Map::new();\n let mut put = |key: &str, value: Value| drop(map.insert(key.into(), value));\n match self.tree.node(id) {\n Node::Source(source) => return self.source(source),\n Node::Error { offset, .. } => {\n put(\"type\", json!(\"error\"));\n put(\"offset\", self.offset(*offset));\n }\n Node::Directive { offset, end } => {\n put(\"type\", json!(\"directive\"));\n put(\"offset\", self.offset(*offset));\n put(\"source\", self.slice(*offset, *end));\n }\n Node::Document { offset, start, value, end } => {\n put(\"type\", json!(\"document\"));\n put(\"offset\", self.offset(*offset));\n put(\"start\", self.sources(start));\n if let Some(value) = value {\n put(\"value\", self.node(*value));\n }\n if let Some(end) = end {\n put(\"end\", self.sources(end));\n }\n }\n Node::DocumentEnd { offset, source_end, end } => {\n put(\"type\", json!(\"doc-end\"));\n put(\"offset\", self.offset(*offset));\n put(\"source\", self.slice(*offset, *source_end));\n if let Some(end) = end {\n put(\"end\", self.sources(end));\n }\n }\n Node::FlowScalar { kind, offset, source_end, indent, end } => {\n let name = match kind {\n ScalarKind::Alias => \"alias\",\n ScalarKind::Plain => \"scalar\",\n ScalarKind::Single => \"single-quoted-scalar\",\n ScalarKind::Double => \"double-quoted-scalar\",\n };\n put(\"type\", json!(name));\n put(\"offset\", self.offset(*offset));\n put(\"indent\", json!(indent));\n put(\"source\", self.slice(*offset, *source_end));\n if let Some(end) = end {\n put(\"end\", self.sources(end));\n }\n }\n Node::BlockScalar { offset, indent, props, source } => {\n put(\"type\", json!(\"block-scalar\"));\n put(\"offset\", self.offset(*offset));\n put(\"indent\", json!(indent));\n let props = props.iter().map(|prop| match prop {\n Prop::Source(source) => self.source(source),\n Prop::Token(id) => self.node(*id),\n });\n put(\"props\", Value::Array(props.collect()));\n put(\"source\", self.slice(source.0, source.1));\n }\n Node::BlockMap { offset, indent, items } | Node::BlockSeq { offset, indent, items } => {\n let name = if matches!(self.tree.node(id), Node::BlockMap { .. }) {\n \"block-map\"\n } else {\n \"block-seq\"\n };\n put(\"type\", json!(name));\n put(\"offset\", self.offset(*offset));\n put(\"indent\", json!(indent));\n put(\"items\", Value::Array(items.iter().map(|it| self.item(it)).collect()));\n }\n Node::FlowCollection { offset, indent, start, items, end } => {\n put(\"type\", json!(\"flow-collection\"));\n put(\"offset\", self.offset(*offset));\n put(\"indent\", json!(indent));\n put(\"start\", self.source(start));\n put(\"items\", Value::Array(items.iter().map(|it| self.item(it)).collect()));\n put(\"end\", self.sources(end));\n }\n }\n Value::Object(map)\n }\n}\n\nfn kind(kind: cst::Kind) -> &'static str {\n use cst::Kind::*;\n match kind {\n ByteOrderMark => \"byte-order-mark\",\n DocMode => \"doc-mode\",\n DocStart => \"doc-start\",\n DocEnd => \"doc-end\",\n Space => \"space\",\n Comment => \"comment\",\n Newline => \"newline\",\n DirectiveLine => \"directive-line\",\n Anchor => \"anchor\",\n Tag => \"tag\",\n SeqItemInd => \"seq-item-ind\",\n ExplicitKeyInd => \"explicit-key-ind\",\n MapValueInd => \"map-value-ind\",\n FlowMapStart => \"flow-map-start\",\n FlowMapEnd => \"flow-map-end\",\n FlowSeqStart => \"flow-seq-start\",\n FlowSeqEnd => \"flow-seq-end\",\n FlowErrorEnd => \"flow-error-end\",\n Comma => \"comma\",\n BlockScalarHeader => \"block-scalar-header\",\n Alias => \"alias\",\n Scalar => \"scalar\",\n SingleQuotedScalar => \"single-quoted-scalar\",\n DoubleQuotedScalar => \"double-quoted-scalar\",\n }\n}\n","editable",false,"branch","documentNavigation","repo","lukeed/tidy","repoId","b2cac5cc-818f-4958-803a-7d401ccd9a90","ownerId","user:5855893","organization","site","nexthub","private","admin","settings","maintainer","triage","starred","stars",0,"watchers",1,"watching","pinned","notify","views",[120,121,122,123,124,125,126,127,128,129,130,131,132],"navigation",{"_57":58,"_79":80,"_81":82,"_83":84,"_85":86,"_87":88,"_89":90},"sources",[],"viewer","meta",{"_72":73,"_74":75,"_76":73,"_44":32,"_77":14,"_78":32,"_50":51,"_52":53},"branches",[14],"tags",[],"cloneUrl","https://git.nexthub.sh/lukeed/tidy.git","description","","owner","lukeed","section","head","empty","pins",[102,103,104],"documents",{"_99":100,"_101":51},"code",{"_96":97,"_98":51},"automations",{"_93":94,"_95":-5},"delivery",{"_91":51,"_92":-5},"tag","W1_y18R9FUcyveBRlHeRXdVTtjo","releases","applications","workflows",2,"deployments","commits",350,"changes","counts",{},"total",{"_105":98,"_107":118,"_15":98,"_109":119,"_55":111,"_112":32,"_113":111,"_114":51},{"_105":115,"_107":116,"_15":115,"_109":117,"_55":111,"_112":32,"_113":111,"_114":51},{"_105":106,"_107":108,"_15":106,"_109":110,"_55":111,"_112":32,"_113":111,"_114":51},"id","issues","name","Issues","filters",{},true,"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_105":98,"_107":118,"_15":98,"_109":163,"_55":111,"_112":32,"_113":111},{"_105":115,"_107":116,"_15":115,"_109":162,"_55":111,"_112":32,"_113":111},{"_105":106,"_107":108,"_15":106,"_109":161,"_55":111,"_112":32,"_113":111},{"_105":158,"_107":159,"_15":158,"_109":160,"_55":32,"_112":32,"_113":111},{"_105":155,"_107":156,"_15":155,"_109":157,"_55":32,"_112":32,"_113":111},{"_105":93,"_107":153,"_15":85,"_109":154,"_55":32,"_112":32,"_113":111},{"_105":95,"_107":150,"_15":151,"_109":152,"_55":32,"_112":32,"_113":111},{"_105":91,"_107":148,"_15":91,"_109":149,"_55":32,"_112":32,"_113":111},{"_105":144,"_107":145,"_15":146,"_109":147,"_55":32,"_112":32,"_113":111},{"_105":81,"_107":142,"_15":81,"_109":143,"_55":32,"_112":32,"_113":32},{"_105":139,"_107":140,"_15":139,"_109":141,"_55":32,"_112":32,"_113":32},{"_105":136,"_107":137,"_15":136,"_109":138,"_55":32,"_112":32,"_113":32},{"_105":133,"_107":134,"_15":133,"_109":135,"_55":32,"_112":32,"_113":32},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794735834864,"sidebar","expanded"]