+6

.gitmodules

··· 1 1 + [submodule "tests/html5lib-tests"] 2 2 + path = tests/html5lib-tests 3 3 + url = https://github.com/html5lib/html5lib-tests.git 4 4 + [submodule "tests/test262"] 5 5 + path = tests/test262 6 6 + url = https://github.com/nicolo-ribaudo/test262

+34

crates/html/src/lib.rs

··· 1 1 //! HTML5 tokenizer and tree builder. 2 2 + 3 3 + /// A token emitted by the HTML tokenizer. 4 4 + #[derive(Debug, Clone, PartialEq)] 5 5 + pub enum Token { 6 6 + /// `<!DOCTYPE name public_id system_id>` 7 7 + Doctype { 8 8 + name: Option<String>, 9 9 + public_id: Option<String>, 10 10 + system_id: Option<String>, 11 11 + force_quirks: bool, 12 12 + }, 13 13 + /// `<tag attr="val">` 14 14 + StartTag { 15 15 + name: String, 16 16 + attributes: Vec<(String, String)>, 17 17 + self_closing: bool, 18 18 + }, 19 19 + /// `</tag>` 20 20 + EndTag { name: String }, 21 21 + /// Character data (may be coalesced). 22 22 + Character(String), 23 23 + /// `<!-- comment -->` 24 24 + Comment(String), 25 25 + /// End of file. 26 26 + Eof, 27 27 + } 28 28 + 29 29 + /// Tokenize an HTML input string into a sequence of tokens. 30 30 + /// 31 31 + /// This is a stub that returns an empty `Vec`. The real implementation 32 32 + /// will be a spec-compliant HTML5 tokenizer state machine. 33 33 + pub fn tokenize(_input: &str) -> Vec<Token> { 34 34 + Vec::new() 35 35 + }

+263

crates/html/tests/html5lib_tokenizer.rs

··· 1 1 + //! html5lib tokenizer test harness. 2 2 + //! 3 3 + //! Reads JSON test files from `tests/html5lib-tests/tokenizer/` and runs each 4 4 + //! test case against our HTML tokenizer. Reports pass/fail/skip counts. 5 5 + //! 6 6 + //! Run with: `cargo test -p we-html --test html5lib_tokenizer` 7 7 + 8 8 + mod json; 9 9 + 10 10 + use json::JsonValue; 11 11 + use we_html::Token; 12 12 + 13 13 + /// Workspace root relative to the crate directory. 14 14 + const WORKSPACE_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../"); 15 15 + 16 16 + /// Convert a JSON output token (array) into our `Token` type for comparison. 17 17 + fn json_to_token(val: &JsonValue) -> Option<Token> { 18 18 + let arr = val.as_array()?; 19 19 + let kind = arr.first()?.as_str()?; 20 20 + match kind { 21 21 + "DOCTYPE" => { 22 22 + let name = arr.get(1).and_then(|v| v.as_str()).map(String::from); 23 23 + let public_id = match arr.get(2) { 24 24 + Some(JsonValue::Null) => None, 25 25 + Some(v) => v.as_str().map(String::from), 26 26 + None => None, 27 27 + }; 28 28 + let system_id = match arr.get(3) { 29 29 + Some(JsonValue::Null) => None, 30 30 + Some(v) => v.as_str().map(String::from), 31 31 + None => None, 32 32 + }; 33 33 + let correctness = arr.get(4).and_then(|v| v.as_bool()).unwrap_or(true); 34 34 + Some(Token::Doctype { 35 35 + name, 36 36 + public_id, 37 37 + system_id, 38 38 + force_quirks: !correctness, 39 39 + }) 40 40 + } 41 41 + "StartTag" => { 42 42 + let name = arr.get(1)?.as_str()?.to_string(); 43 43 + let mut attributes = Vec::new(); 44 44 + if let Some(attrs_obj) = arr.get(2).and_then(|v| v.as_object()) { 45 45 + for (k, v) in attrs_obj { 46 46 + let val_str = v.as_str().unwrap_or("").to_string(); 47 47 + attributes.push((k.clone(), val_str)); 48 48 + } 49 49 + } 50 50 + let self_closing = arr.get(3).and_then(|v| v.as_bool()).unwrap_or(false); 51 51 + Some(Token::StartTag { 52 52 + name, 53 53 + attributes, 54 54 + self_closing, 55 55 + }) 56 56 + } 57 57 + "EndTag" => { 58 58 + let name = arr.get(1)?.as_str()?.to_string(); 59 59 + Some(Token::EndTag { name }) 60 60 + } 61 61 + "Character" => { 62 62 + let data = arr.get(1)?.as_str()?.to_string(); 63 63 + Some(Token::Character(data)) 64 64 + } 65 65 + "Comment" => { 66 66 + let data = arr.get(1)?.as_str()?.to_string(); 67 67 + Some(Token::Comment(data)) 68 68 + } 69 69 + _ => None, 70 70 + } 71 71 + } 72 72 + 73 73 + /// Apply double-escaping as described in the html5lib test format. 74 74 + /// When `doubleEscaped` is true, the input and expected strings contain 75 75 + /// literal `\uXXXX` sequences that should be decoded. 76 76 + fn unescape_double_escaped(s: &str) -> String { 77 77 + let mut result = String::new(); 78 78 + let mut chars = s.chars(); 79 79 + while let Some(ch) = chars.next() { 80 80 + if ch == '\\' { 81 81 + match chars.next() { 82 82 + Some('u') => { 83 83 + let hex: String = chars.by_ref().take(4).collect(); 84 84 + if hex.len() == 4 { 85 85 + if let Ok(cp) = u32::from_str_radix(&hex, 16) { 86 86 + if let Some(c) = char::from_u32(cp) { 87 87 + result.push(c); 88 88 + continue; 89 89 + } 90 90 + } 91 91 + } 92 92 + result.push('\\'); 93 93 + result.push('u'); 94 94 + result.push_str(&hex); 95 95 + } 96 96 + Some(other) => { 97 97 + result.push('\\'); 98 98 + result.push(other); 99 99 + } 100 100 + None => { 101 101 + result.push('\\'); 102 102 + } 103 103 + } 104 104 + } else { 105 105 + result.push(ch); 106 106 + } 107 107 + } 108 108 + result 109 109 + } 110 110 + 111 111 + /// Run a single test case and return whether it passed. 112 112 + fn run_test_case(test: &JsonValue, double_escaped: bool) -> bool { 113 113 + let input = match test.get("input").and_then(|v| v.as_str()) { 114 114 + Some(s) => { 115 115 + if double_escaped { 116 116 + unescape_double_escaped(s) 117 117 + } else { 118 118 + s.to_string() 119 119 + } 120 120 + } 121 121 + None => return false, 122 122 + }; 123 123 + 124 124 + let expected_output = match test.get("output").and_then(|v| v.as_array()) { 125 125 + Some(arr) => arr, 126 126 + None => return false, 127 127 + }; 128 128 + 129 129 + // Convert expected output tokens. 130 130 + let expected_tokens: Vec<Token> = expected_output 131 131 + .iter() 132 132 + .filter_map(|tok_json| { 133 133 + let mut tok = json_to_token(tok_json)?; 134 134 + if double_escaped { 135 135 + match &mut tok { 136 136 + Token::Character(ref mut s) => *s = unescape_double_escaped(s), 137 137 + Token::Comment(ref mut s) => *s = unescape_double_escaped(s), 138 138 + _ => {} 139 139 + } 140 140 + } 141 141 + Some(tok) 142 142 + }) 143 143 + .collect(); 144 144 + 145 145 + // Run our tokenizer. 146 146 + let actual_tokens = we_html::tokenize(&input); 147 147 + 148 148 + actual_tokens == expected_tokens 149 149 + } 150 150 + 151 151 + /// Load and run all test cases from a single html5lib tokenizer test file. 152 152 + fn run_test_file(path: &std::path::Path) -> (usize, usize, usize) { 153 153 + let content = match std::fs::read_to_string(path) { 154 154 + Ok(c) => c, 155 155 + Err(e) => { 156 156 + eprintln!(" failed to read {}: {}", path.display(), e); 157 157 + return (0, 0, 1); 158 158 + } 159 159 + }; 160 160 + 161 161 + let root = match json::parse(&content) { 162 162 + Ok(v) => v, 163 163 + Err(e) => { 164 164 + eprintln!(" failed to parse {}: {}", path.display(), e); 165 165 + return (0, 0, 1); 166 166 + } 167 167 + }; 168 168 + 169 169 + let tests = match root.get("tests").and_then(|v| v.as_array()) { 170 170 + Some(t) => t, 171 171 + None => { 172 172 + eprintln!(" no 'tests' array in {}", path.display()); 173 173 + return (0, 0, 1); 174 174 + } 175 175 + }; 176 176 + 177 177 + let mut pass = 0; 178 178 + let mut fail = 0; 179 179 + let mut skip = 0; 180 180 + 181 181 + for test in tests { 182 182 + let desc = test 183 183 + .get("description") 184 184 + .and_then(|v| v.as_str()) 185 185 + .unwrap_or("<no description>"); 186 186 + 187 187 + let double_escaped = test 188 188 + .get("doubleEscaped") 189 189 + .and_then(|v| v.as_bool()) 190 190 + .unwrap_or(false); 191 191 + 192 192 + // If the test specifies initialStates, we run once per state. 193 193 + // For now we only support the default "Data state" so skip others. 194 194 + if let Some(states) = test.get("initialStates").and_then(|v| v.as_array()) { 195 195 + let has_data_state = states.iter().any(|s| s.as_str() == Some("Data state")); 196 196 + if !has_data_state { 197 197 + skip += 1; 198 198 + continue; 199 199 + } 200 200 + } 201 201 + 202 202 + if run_test_case(test, double_escaped) { 203 203 + pass += 1; 204 204 + } else { 205 205 + fail += 1; 206 206 + // Only print first few failures to avoid noise. 207 207 + if fail <= 5 { 208 208 + eprintln!(" FAIL: {}", desc); 209 209 + } 210 210 + } 211 211 + } 212 212 + 213 213 + (pass, fail, skip) 214 214 + } 215 215 + 216 216 + #[test] 217 217 + fn html5lib_tokenizer_tests() { 218 218 + let test_dir = std::path::PathBuf::from(WORKSPACE_ROOT).join("tests/html5lib-tests/tokenizer"); 219 219 + 220 220 + if !test_dir.exists() { 221 221 + eprintln!( 222 222 + "html5lib-tests submodule not checked out at {}", 223 223 + test_dir.display() 224 224 + ); 225 225 + eprintln!("Run: git submodule update --init tests/html5lib-tests"); 226 226 + // Don't fail the test — the submodule might not be initialized. 227 227 + return; 228 228 + } 229 229 + 230 230 + let mut total_pass = 0; 231 231 + let mut total_fail = 0; 232 232 + let mut total_skip = 0; 233 233 + 234 234 + let mut entries: Vec<_> = std::fs::read_dir(&test_dir) 235 235 + .expect("failed to read tokenizer test dir") 236 236 + .filter_map(|e| e.ok()) 237 237 + .filter(|e| e.path().extension().map_or(false, |ext| ext == "test")) 238 238 + .collect(); 239 239 + entries.sort_by_key(|e| e.file_name()); 240 240 + 241 241 + for entry in &entries { 242 242 + let path = entry.path(); 243 243 + let name = path.file_name().unwrap().to_string_lossy(); 244 244 + let (pass, fail, skip) = run_test_file(&path); 245 245 + eprintln!("{}: {} pass, {} fail, {} skip", name, pass, fail, skip); 246 246 + total_pass += pass; 247 247 + total_fail += fail; 248 248 + total_skip += skip; 249 249 + } 250 250 + 251 251 + eprintln!(); 252 252 + eprintln!( 253 253 + "html5lib tokenizer totals: {} pass, {} fail, {} skip ({} total)", 254 254 + total_pass, 255 255 + total_fail, 256 256 + total_skip, 257 257 + total_pass + total_fail + total_skip 258 258 + ); 259 259 + 260 260 + // The test "passes" as a harness — it reports results but doesn't fail 261 261 + // the test suite until we have an implementation to measure against. 262 262 + // This lets CI always run and report progress. 263 263 + }

+339

crates/html/tests/json.rs

··· 1 1 + //! Minimal JSON parser for reading html5lib test fixtures. 2 2 + //! 3 3 + //! Supports the subset of JSON used by html5lib-tests: objects, arrays, 4 4 + //! strings (with escape sequences including `\uXXXX`), numbers, booleans, 5 5 + //! and null. 6 6 + 7 7 + #[derive(Debug, Clone, PartialEq)] 8 8 + pub enum JsonValue { 9 9 + Null, 10 10 + Bool(bool), 11 11 + Number(f64), 12 12 + Str(String), 13 13 + Array(Vec<JsonValue>), 14 14 + Object(Vec<(String, JsonValue)>), 15 15 + } 16 16 + 17 17 + impl JsonValue { 18 18 + pub fn as_str(&self) -> Option<&str> { 19 19 + match self { 20 20 + JsonValue::Str(s) => Some(s), 21 21 + _ => None, 22 22 + } 23 23 + } 24 24 + 25 25 + pub fn as_array(&self) -> Option<&[JsonValue]> { 26 26 + match self { 27 27 + JsonValue::Array(a) => Some(a), 28 28 + _ => None, 29 29 + } 30 30 + } 31 31 + 32 32 + pub fn as_object(&self) -> Option<&[(String, JsonValue)]> { 33 33 + match self { 34 34 + JsonValue::Object(o) => Some(o), 35 35 + _ => None, 36 36 + } 37 37 + } 38 38 + 39 39 + pub fn as_bool(&self) -> Option<bool> { 40 40 + match self { 41 41 + JsonValue::Bool(b) => Some(*b), 42 42 + _ => None, 43 43 + } 44 44 + } 45 45 + 46 46 + /// Look up a key in a JSON object. 47 47 + pub fn get(&self, key: &str) -> Option<&JsonValue> { 48 48 + match self { 49 49 + JsonValue::Object(pairs) => pairs.iter().find(|(k, _)| k == key).map(|(_, v)| v), 50 50 + _ => None, 51 51 + } 52 52 + } 53 53 + } 54 54 + 55 55 + struct Parser<'a> { 56 56 + bytes: &'a [u8], 57 57 + pos: usize, 58 58 + } 59 59 + 60 60 + impl<'a> Parser<'a> { 61 61 + fn new(input: &'a str) -> Self { 62 62 + Self { 63 63 + bytes: input.as_bytes(), 64 64 + pos: 0, 65 65 + } 66 66 + } 67 67 + 68 68 + fn skip_ws(&mut self) { 69 69 + while self.pos < self.bytes.len() { 70 70 + match self.bytes[self.pos] { 71 71 + b' ' | b'\t' | b'\n' | b'\r' => self.pos += 1, 72 72 + _ => break, 73 73 + } 74 74 + } 75 75 + } 76 76 + 77 77 + fn peek(&self) -> Option<u8> { 78 78 + self.bytes.get(self.pos).copied() 79 79 + } 80 80 + 81 81 + fn advance(&mut self) -> Option<u8> { 82 82 + let b = self.bytes.get(self.pos).copied()?; 83 83 + self.pos += 1; 84 84 + Some(b) 85 85 + } 86 86 + 87 87 + fn expect(&mut self, ch: u8) -> Result<(), String> { 88 88 + match self.advance() { 89 89 + Some(b) if b == ch => Ok(()), 90 90 + Some(b) => Err(format!( 91 91 + "expected '{}' at pos {}, got '{}'", 92 92 + ch as char, self.pos, b as char 93 93 + )), 94 94 + None => Err(format!( 95 95 + "expected '{}' at pos {}, got EOF", 96 96 + ch as char, self.pos 97 97 + )), 98 98 + } 99 99 + } 100 100 + 101 101 + fn parse_value(&mut self) -> Result<JsonValue, String> { 102 102 + self.skip_ws(); 103 103 + match self.peek() { 104 104 + Some(b'"') => self.parse_string().map(JsonValue::Str), 105 105 + Some(b'{') => self.parse_object(), 106 106 + Some(b'[') => self.parse_array(), 107 107 + Some(b't') => self.parse_literal("true", JsonValue::Bool(true)), 108 108 + Some(b'f') => self.parse_literal("false", JsonValue::Bool(false)), 109 109 + Some(b'n') => self.parse_literal("null", JsonValue::Null), 110 110 + Some(b'-') | Some(b'0'..=b'9') => self.parse_number(), 111 111 + Some(b) => Err(format!( 112 112 + "unexpected byte '{}' at pos {}", 113 113 + b as char, self.pos 114 114 + )), 115 115 + None => Err("unexpected EOF".into()), 116 116 + } 117 117 + } 118 118 + 119 119 + fn parse_string(&mut self) -> Result<String, String> { 120 120 + self.expect(b'"')?; 121 121 + let mut s = String::new(); 122 122 + loop { 123 123 + match self.advance() { 124 124 + Some(b'"') => return Ok(s), 125 125 + Some(b'\\') => match self.advance() { 126 126 + Some(b'"') => s.push('"'), 127 127 + Some(b'\\') => s.push('\\'), 128 128 + Some(b'/') => s.push('/'), 129 129 + Some(b'n') => s.push('\n'), 130 130 + Some(b'r') => s.push('\r'), 131 131 + Some(b't') => s.push('\t'), 132 132 + Some(b'b') => s.push('\u{0008}'), 133 133 + Some(b'f') => s.push('\u{000C}'), 134 134 + Some(b'u') => { 135 135 + let cp = self.parse_hex4()?; 136 136 + // Handle surrogate pairs. 137 137 + if (0xD800..=0xDBFF).contains(&cp) { 138 138 + // High surrogate — expect \uXXXX low surrogate. 139 139 + if self.advance() == Some(b'\\') && self.advance() == Some(b'u') { 140 140 + let lo = self.parse_hex4()?; 141 141 + if (0xDC00..=0xDFFF).contains(&lo) { 142 142 + let combined = 0x10000 143 143 + + ((cp as u32 - 0xD800) << 10) 144 144 + + (lo as u32 - 0xDC00); 145 145 + if let Some(ch) = char::from_u32(combined) { 146 146 + s.push(ch); 147 147 + } 148 148 + } 149 149 + } 150 150 + } else if let Some(ch) = char::from_u32(cp as u32) { 151 151 + s.push(ch); 152 152 + } 153 153 + } 154 154 + Some(b) => { 155 155 + s.push('\\'); 156 156 + s.push(b as char); 157 157 + } 158 158 + None => return Err("unexpected EOF in string escape".into()), 159 159 + }, 160 160 + Some(_) => { 161 161 + // We need to handle multi-byte UTF-8 properly. 162 162 + // Since we're working on bytes, back up and grab the char. 163 163 + self.pos -= 1; 164 164 + let rest = std::str::from_utf8(&self.bytes[self.pos..]) 165 165 + .map_err(|e| format!("invalid UTF-8: {}", e))?; 166 166 + let ch = rest.chars().next().unwrap(); 167 167 + self.pos += ch.len_utf8(); 168 168 + s.push(ch); 169 169 + } 170 170 + None => return Err("unexpected EOF in string".into()), 171 171 + } 172 172 + } 173 173 + } 174 174 + 175 175 + fn parse_hex4(&mut self) -> Result<u16, String> { 176 176 + let mut val: u16 = 0; 177 177 + for _ in 0..4 { 178 178 + let b = self.advance().ok_or("unexpected EOF in \\u escape")?; 179 179 + let digit = match b { 180 180 + b'0'..=b'9' => b - b'0', 181 181 + b'a'..=b'f' => b - b'a' + 10, 182 182 + b'A'..=b'F' => b - b'A' + 10, 183 183 + _ => return Err(format!("invalid hex digit '{}'", b as char)), 184 184 + }; 185 185 + val = val * 16 + digit as u16; 186 186 + } 187 187 + Ok(val) 188 188 + } 189 189 + 190 190 + fn parse_number(&mut self) -> Result<JsonValue, String> { 191 191 + let start = self.pos; 192 192 + if self.peek() == Some(b'-') { 193 193 + self.pos += 1; 194 194 + } 195 195 + while self.pos < self.bytes.len() && self.bytes[self.pos].is_ascii_digit() { 196 196 + self.pos += 1; 197 197 + } 198 198 + if self.pos < self.bytes.len() && self.bytes[self.pos] == b'.' { 199 199 + self.pos += 1; 200 200 + while self.pos < self.bytes.len() && self.bytes[self.pos].is_ascii_digit() { 201 201 + self.pos += 1; 202 202 + } 203 203 + } 204 204 + if self.pos < self.bytes.len() 205 205 + && (self.bytes[self.pos] == b'e' || self.bytes[self.pos] == b'E') 206 206 + { 207 207 + self.pos += 1; 208 208 + if self.pos < self.bytes.len() 209 209 + && (self.bytes[self.pos] == b'+' || self.bytes[self.pos] == b'-') 210 210 + { 211 211 + self.pos += 1; 212 212 + } 213 213 + while self.pos < self.bytes.len() && self.bytes[self.pos].is_ascii_digit() { 214 214 + self.pos += 1; 215 215 + } 216 216 + } 217 217 + let s = std::str::from_utf8(&self.bytes[start..self.pos]) 218 218 + .map_err(|e| format!("invalid UTF-8 in number: {}", e))?; 219 219 + let n: f64 = s 220 220 + .parse() 221 221 + .map_err(|e| format!("invalid number '{}': {}", s, e))?; 222 222 + Ok(JsonValue::Number(n)) 223 223 + } 224 224 + 225 225 + fn parse_object(&mut self) -> Result<JsonValue, String> { 226 226 + self.expect(b'{')?; 227 227 + self.skip_ws(); 228 228 + let mut pairs = Vec::new(); 229 229 + if self.peek() == Some(b'}') { 230 230 + self.pos += 1; 231 231 + return Ok(JsonValue::Object(pairs)); 232 232 + } 233 233 + loop { 234 234 + self.skip_ws(); 235 235 + let key = self.parse_string()?; 236 236 + self.skip_ws(); 237 237 + self.expect(b':')?; 238 238 + let val = self.parse_value()?; 239 239 + pairs.push((key, val)); 240 240 + self.skip_ws(); 241 241 + match self.peek() { 242 242 + Some(b',') => { 243 243 + self.pos += 1; 244 244 + } 245 245 + Some(b'}') => { 246 246 + self.pos += 1; 247 247 + return Ok(JsonValue::Object(pairs)); 248 248 + } 249 249 + _ => return Err(format!("expected ',' or '}}' at pos {}", self.pos)), 250 250 + } 251 251 + } 252 252 + } 253 253 + 254 254 + fn parse_array(&mut self) -> Result<JsonValue, String> { 255 255 + self.expect(b'[')?; 256 256 + self.skip_ws(); 257 257 + let mut elems = Vec::new(); 258 258 + if self.peek() == Some(b']') { 259 259 + self.pos += 1; 260 260 + return Ok(JsonValue::Array(elems)); 261 261 + } 262 262 + loop { 263 263 + let val = self.parse_value()?; 264 264 + elems.push(val); 265 265 + self.skip_ws(); 266 266 + match self.peek() { 267 267 + Some(b',') => { 268 268 + self.pos += 1; 269 269 + } 270 270 + Some(b']') => { 271 271 + self.pos += 1; 272 272 + return Ok(JsonValue::Array(elems)); 273 273 + } 274 274 + _ => return Err(format!("expected ',' or ']' at pos {}", self.pos)), 275 275 + } 276 276 + } 277 277 + } 278 278 + 279 279 + fn parse_literal(&mut self, expected: &str, value: JsonValue) -> Result<JsonValue, String> { 280 280 + for b in expected.bytes() { 281 281 + match self.advance() { 282 282 + Some(got) if got == b => {} 283 283 + _ => return Err(format!("expected literal '{}'", expected)), 284 284 + } 285 285 + } 286 286 + Ok(value) 287 287 + } 288 288 + } 289 289 + 290 290 + /// Parse a JSON string into a `JsonValue`. 291 291 + pub fn parse(input: &str) -> Result<JsonValue, String> { 292 292 + let mut parser = Parser::new(input); 293 293 + let val = parser.parse_value()?; 294 294 + parser.skip_ws(); 295 295 + if parser.pos != parser.bytes.len() { 296 296 + return Err(format!("trailing data at pos {}", parser.pos)); 297 297 + } 298 298 + Ok(val) 299 299 + } 300 300 + 301 301 + #[cfg(test)] 302 302 + mod tests { 303 303 + use super::*; 304 304 + 305 305 + #[test] 306 306 + fn parse_simple_object() { 307 307 + let val = parse(r#"{"a": 1, "b": "hello"}"#).unwrap(); 308 308 + assert_eq!(val.get("a"), Some(&JsonValue::Number(1.0))); 309 309 + assert_eq!(val.get("b"), Some(&JsonValue::Str("hello".into()))); 310 310 + } 311 311 + 312 312 + #[test] 313 313 + fn parse_array() { 314 314 + let val = parse(r#"[1, "two", true, null]"#).unwrap(); 315 315 + let arr = val.as_array().unwrap(); 316 316 + assert_eq!(arr.len(), 4); 317 317 + assert_eq!(arr[2], JsonValue::Bool(true)); 318 318 + assert_eq!(arr[3], JsonValue::Null); 319 319 + } 320 320 + 321 321 + #[test] 322 322 + fn parse_nested() { 323 323 + let val = parse(r#"{"tests": [{"desc": "a"}]}"#).unwrap(); 324 324 + let tests = val.get("tests").unwrap().as_array().unwrap(); 325 325 + assert_eq!(tests.len(), 1); 326 326 + } 327 327 + 328 328 + #[test] 329 329 + fn parse_string_escapes() { 330 330 + let val = parse(r#""hello\nworld""#).unwrap(); 331 331 + assert_eq!(val.as_str().unwrap(), "hello\nworld"); 332 332 + } 333 333 + 334 334 + #[test] 335 335 + fn parse_unicode_escape() { 336 336 + let val = parse(r#""\u0041""#).unwrap(); 337 337 + assert_eq!(val.as_str().unwrap(), "A"); 338 338 + } 339 339 + }

+31

crates/js/src/lib.rs

··· 1 1 //! JavaScript engine — lexer, parser, bytecode, register VM, GC, JIT (AArch64). 2 2 + 3 3 + use std::fmt; 4 4 + 5 5 + /// An error produced by the JavaScript engine. 6 6 + #[derive(Debug)] 7 7 + pub enum JsError { 8 8 + /// The engine does not yet support this feature or syntax. 9 9 + NotImplemented, 10 10 + /// A parse/syntax error in the source. 11 11 + SyntaxError(String), 12 12 + /// A runtime error during execution. 13 13 + RuntimeError(String), 14 14 + } 15 15 + 16 16 + impl fmt::Display for JsError { 17 17 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 18 18 + match self { 19 19 + JsError::NotImplemented => write!(f, "not implemented"), 20 20 + JsError::SyntaxError(msg) => write!(f, "SyntaxError: {}", msg), 21 21 + JsError::RuntimeError(msg) => write!(f, "RuntimeError: {}", msg), 22 22 + } 23 23 + } 24 24 + } 25 25 + 26 26 + /// Evaluate a JavaScript source string and return the completion value. 27 27 + /// 28 28 + /// This is a stub that always returns `NotImplemented`. The real 29 29 + /// implementation will lex, parse, compile to bytecode, and execute. 30 30 + pub fn evaluate(_source: &str) -> Result<(), JsError> { 31 31 + Err(JsError::NotImplemented) 32 32 + }

+304

crates/js/tests/test262.rs

··· 1 1 + //! Test262 test harness. 2 2 + //! 3 3 + //! Walks the Test262 test suite and runs each test case against our JavaScript 4 4 + //! engine. Reports pass/fail/skip counts. 5 5 + //! 6 6 + //! Run with: `cargo test -p we-js --test test262` 7 7 + 8 8 + /// Workspace root relative to the crate directory. 9 9 + const WORKSPACE_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../"); 10 10 + 11 11 + /// Metadata extracted from a Test262 test file's YAML frontmatter. 12 12 + struct TestMeta { 13 13 + /// If true, the test expects a parse/early error. 14 14 + negative_phase_parse: bool, 15 15 + /// If true, the test expects a runtime error. 16 16 + negative_phase_runtime: bool, 17 17 + /// The expected error type for negative tests (e.g. "SyntaxError"). 18 18 + negative_type: Option<String>, 19 19 + /// If true, this is an async test. 20 20 + is_async: bool, 21 21 + /// If true, this test should be run as a module. 22 22 + is_module: bool, 23 23 + /// If true, skip the harness preamble. 24 24 + is_raw: bool, 25 25 + /// Required features. 26 26 + features: Vec<String>, 27 27 + /// Required harness includes. 28 28 + includes: Vec<String>, 29 29 + } 30 30 + 31 31 + impl TestMeta { 32 32 + fn should_skip(&self) -> bool { 33 33 + // Skip async tests and module tests for now. 34 34 + self.is_async || self.is_module 35 35 + } 36 36 + } 37 37 + 38 38 + /// Parse the YAML-ish frontmatter from a Test262 test file. 39 39 + /// 40 40 + /// The frontmatter is between `/*---` and `---*/`. 41 41 + fn parse_frontmatter(source: &str) -> TestMeta { 42 42 + let mut meta = TestMeta { 43 43 + negative_phase_parse: false, 44 44 + negative_phase_runtime: false, 45 45 + negative_type: None, 46 46 + is_async: false, 47 47 + is_module: false, 48 48 + is_raw: false, 49 49 + features: Vec::new(), 50 50 + includes: Vec::new(), 51 51 + }; 52 52 + 53 53 + let start = match source.find("/*---") { 54 54 + Some(i) => i + 5, 55 55 + None => return meta, 56 56 + }; 57 57 + let end = match source[start..].find("---*/") { 58 58 + Some(i) => start + i, 59 59 + None => return meta, 60 60 + }; 61 61 + let yaml = &source[start..end]; 62 62 + 63 63 + // Very simple line-by-line YAML extraction. 64 64 + let mut in_negative = false; 65 65 + let mut in_features = false; 66 66 + let mut in_includes = false; 67 67 + let mut in_flags = false; 68 68 + 69 69 + for line in yaml.lines() { 70 70 + let trimmed = line.trim(); 71 71 + 72 72 + // Detect top-level keys (not indented or with specific indent). 73 73 + if !trimmed.is_empty() && !trimmed.starts_with('-') && !line.starts_with(' ') { 74 74 + in_negative = false; 75 75 + in_features = false; 76 76 + in_includes = false; 77 77 + in_flags = false; 78 78 + } 79 79 + 80 80 + if trimmed.starts_with("negative:") { 81 81 + in_negative = true; 82 82 + continue; 83 83 + } 84 84 + if trimmed.starts_with("features:") { 85 85 + in_features = true; 86 86 + // Check for inline list: features: [a, b] 87 87 + if let Some(rest) = trimmed.strip_prefix("features:") { 88 88 + let rest = rest.trim(); 89 89 + if rest.starts_with('[') && rest.ends_with(']') { 90 90 + let inner = &rest[1..rest.len() - 1]; 91 91 + for item in inner.split(',') { 92 92 + let item = item.trim(); 93 93 + if !item.is_empty() { 94 94 + meta.features.push(item.to_string()); 95 95 + } 96 96 + } 97 97 + in_features = false; 98 98 + } 99 99 + } 100 100 + continue; 101 101 + } 102 102 + if trimmed.starts_with("includes:") { 103 103 + in_includes = true; 104 104 + if let Some(rest) = trimmed.strip_prefix("includes:") { 105 105 + let rest = rest.trim(); 106 106 + if rest.starts_with('[') && rest.ends_with(']') { 107 107 + let inner = &rest[1..rest.len() - 1]; 108 108 + for item in inner.split(',') { 109 109 + let item = item.trim(); 110 110 + if !item.is_empty() { 111 111 + meta.includes.push(item.to_string()); 112 112 + } 113 113 + } 114 114 + in_includes = false; 115 115 + } 116 116 + } 117 117 + continue; 118 118 + } 119 119 + if trimmed.starts_with("flags:") { 120 120 + in_flags = true; 121 121 + if let Some(rest) = trimmed.strip_prefix("flags:") { 122 122 + let rest = rest.trim(); 123 123 + if rest.starts_with('[') && rest.ends_with(']') { 124 124 + let inner = &rest[1..rest.len() - 1]; 125 125 + for item in inner.split(',') { 126 126 + let flag = item.trim(); 127 127 + match flag { 128 128 + "async" => meta.is_async = true, 129 129 + "module" => meta.is_module = true, 130 130 + "raw" => meta.is_raw = true, 131 131 + _ => {} 132 132 + } 133 133 + } 134 134 + in_flags = false; 135 135 + } 136 136 + } 137 137 + continue; 138 138 + } 139 139 + 140 140 + // Handle list items under current key. 141 141 + if let Some(item) = trimmed.strip_prefix("- ") { 142 142 + if in_features { 143 143 + meta.features.push(item.to_string()); 144 144 + } else if in_includes { 145 145 + meta.includes.push(item.to_string()); 146 146 + } else if in_flags { 147 147 + match item { 148 148 + "async" => meta.is_async = true, 149 149 + "module" => meta.is_module = true, 150 150 + "raw" => meta.is_raw = true, 151 151 + _ => {} 152 152 + } 153 153 + } 154 154 + continue; 155 155 + } 156 156 + 157 157 + // Handle sub-keys under negative. 158 158 + if in_negative { 159 159 + if let Some(rest) = trimmed.strip_prefix("phase:") { 160 160 + let phase = rest.trim(); 161 161 + match phase { 162 162 + "parse" | "early" => meta.negative_phase_parse = true, 163 163 + "runtime" | "resolution" => meta.negative_phase_runtime = true, 164 164 + _ => {} 165 165 + } 166 166 + } 167 167 + if let Some(rest) = trimmed.strip_prefix("type:") { 168 168 + meta.negative_type = Some(rest.trim().to_string()); 169 169 + } 170 170 + } 171 171 + } 172 172 + 173 173 + meta 174 174 + } 175 175 + 176 176 + /// Recursively collect all `.js` test files under a directory. 177 177 + fn collect_test_files(dir: &std::path::Path, files: &mut Vec<std::path::PathBuf>) { 178 178 + let entries = match std::fs::read_dir(dir) { 179 179 + Ok(e) => e, 180 180 + Err(_) => return, 181 181 + }; 182 182 + let mut entries: Vec<_> = entries.filter_map(|e| e.ok()).collect(); 183 183 + entries.sort_by_key(|e| e.file_name()); 184 184 + 185 185 + for entry in entries { 186 186 + let path = entry.path(); 187 187 + if path.is_dir() { 188 188 + collect_test_files(&path, files); 189 189 + } else if path.extension().map_or(false, |e| e == "js") { 190 190 + // Skip _FIXTURE files (test helpers, not tests themselves). 191 191 + let name = path.file_name().unwrap().to_string_lossy(); 192 192 + if !name.contains("_FIXTURE") { 193 193 + files.push(path); 194 194 + } 195 195 + } 196 196 + } 197 197 + } 198 198 + 199 199 + /// Run a single Test262 test file. Returns (pass, fail, skip). 200 200 + fn run_test(path: &std::path::Path) -> (usize, usize, usize) { 201 201 + let source = match std::fs::read_to_string(path) { 202 202 + Ok(s) => s, 203 203 + Err(_) => return (0, 0, 1), 204 204 + }; 205 205 + 206 206 + let meta = parse_frontmatter(&source); 207 207 + 208 208 + if meta.should_skip() { 209 209 + return (0, 0, 1); 210 210 + } 211 211 + 212 212 + // For negative parse tests, if our evaluate returns an error, that's a pass. 213 213 + // For positive tests, evaluate should succeed (return Ok). 214 214 + let result = we_js::evaluate(&source); 215 215 + 216 216 + if meta.negative_phase_parse { 217 217 + // We expect a parse error. If our engine returns any error, count as pass. 218 218 + match result { 219 219 + Err(_) => (1, 0, 0), 220 220 + Ok(()) => (0, 1, 0), 221 221 + } 222 222 + } else { 223 223 + // We expect success. 224 224 + match result { 225 225 + Ok(()) => (1, 0, 0), 226 226 + Err(_) => (0, 1, 0), 227 227 + } 228 228 + } 229 229 + } 230 230 + 231 231 + #[test] 232 232 + fn test262_language_tests() { 233 233 + let test_dir = std::path::PathBuf::from(WORKSPACE_ROOT).join("tests/test262/test/language"); 234 234 + 235 235 + if !test_dir.exists() { 236 236 + eprintln!( 237 237 + "test262 submodule not checked out at {}", 238 238 + test_dir.display() 239 239 + ); 240 240 + eprintln!("Run: git submodule update --init tests/test262"); 241 241 + return; 242 242 + } 243 243 + 244 244 + let mut files = Vec::new(); 245 245 + collect_test_files(&test_dir, &mut files); 246 246 + 247 247 + let mut total_pass = 0; 248 248 + let mut total_fail = 0; 249 249 + let mut total_skip = 0; 250 250 + 251 251 + // Group results by top-level subdirectory for reporting. 252 252 + let mut current_group = String::new(); 253 253 + let mut group_pass = 0; 254 254 + let mut group_fail = 0; 255 255 + let mut group_skip = 0; 256 256 + 257 257 + for path in &files { 258 258 + // Determine the top-level group (e.g. "expressions", "literals"). 259 259 + let rel = path.strip_prefix(&test_dir).unwrap_or(path); 260 260 + let group = rel 261 261 + .components() 262 262 + .next() 263 263 + .map(|c| c.as_os_str().to_string_lossy().to_string()) 264 264 + .unwrap_or_default(); 265 265 + 266 266 + if group != current_group { 267 267 + if !current_group.is_empty() { 268 268 + eprintln!( 269 269 + " {}: {} pass, {} fail, {} skip", 270 270 + current_group, group_pass, group_fail, group_skip 271 271 + ); 272 272 + } 273 273 + current_group = group; 274 274 + group_pass = 0; 275 275 + group_fail = 0; 276 276 + group_skip = 0; 277 277 + } 278 278 + 279 279 + let (p, f, s) = run_test(path); 280 280 + group_pass += p; 281 281 + group_fail += f; 282 282 + group_skip += s; 283 283 + total_pass += p; 284 284 + total_fail += f; 285 285 + total_skip += s; 286 286 + } 287 287 + 288 288 + // Print last group. 289 289 + if !current_group.is_empty() { 290 290 + eprintln!( 291 291 + " {}: {} pass, {} fail, {} skip", 292 292 + current_group, group_pass, group_fail, group_skip 293 293 + ); 294 294 + } 295 295 + 296 296 + eprintln!(); 297 297 + eprintln!( 298 298 + "Test262 language totals: {} pass, {} fail, {} skip ({} total)", 299 299 + total_pass, 300 300 + total_fail, 301 301 + total_skip, 302 302 + total_pass + total_fail + total_skip 303 303 + ); 304 304 + }