Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
21 kB · 453 lines
Zig
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454const std = @import("std");
const Allocator = std.mem.Allocator;
pub const KeywordCase = enum { sensitive, ascii_insensitive,};
pub const BlockComment = struct { start: []const u8, end: []const u8,};
pub const Detection = enum { none, typescript_assertion, json, shell_shebang, python_header, sql_select, dockerfile_from, go_package, rust_function,};
pub const Profile = struct { label: []const u8, aliases: []const []const u8, line_comments: []const []const u8 = &.{}, block_comment: ?BlockComment = null, quotes: []const u8 = &.{}, keywords: []const []const u8 = &.{}, literals: []const []const u8 = &.{}, keyword_case: KeywordCase = .sensitive, detection: Detection = .none,};
const double_quote = &[_]u8{'"'};const double_single_quotes = &[_]u8{ '"', '\'' };const shell_quotes = &[_]u8{ '"', '\'', '`' };
const profiles = [_]Profile{ .{ .label = "zig", .aliases = &.{"zig"}, .line_comments = &.{"//"}, .quotes = double_quote, .keywords = &.{ "const", "var", "fn", "pub", "return", "if", "else", "while", "for", "struct", "enum", "union", "try", "catch", "comptime", "defer", "errdefer", "async", "await", "anytype", "void" }, }, .{ .label = "ts", .aliases = &.{ "js", "jsx", "javascript", "ts", "tsx", "typescript" }, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = shell_quotes, .keywords = &.{ "const", "let", "var", "function", "class", "interface", "type", "export", "import", "from", "return", "if", "else", "for", "while", "async", "await", "new", "extends", "implements", "public", "private", "readonly" }, .literals = &.{ "true", "false", "null", "undefined" }, .detection = .typescript_assertion, }, .{ .label = "json", .aliases = &.{"json"}, .quotes = double_quote, .literals = &.{ "true", "false", "null" }, .detection = .json, }, .{ .label = "sh", .aliases = &.{ "sh", "bash", "zsh", "shell" }, .line_comments = &.{"#"}, .quotes = shell_quotes, .keywords = &.{ "if", "then", "fi", "for", "do", "done", "in", "case", "esac", "function", "local", "export", "readonly", "return" }, .literals = &.{ "true", "false", "null" }, .detection = .shell_shebang, }, .{ .label = "python", .aliases = &.{ "python", "py" }, .line_comments = &.{"#"}, .quotes = double_single_quotes, .keywords = &.{ "def", "class", "return", "if", "elif", "else", "for", "while", "in", "import", "from", "as", "try", "except", "with", "lambda", "async", "await", "pass", "raise", "yield", "match", "case" }, .literals = &.{ "True", "False", "None" }, .detection = .python_header, }, .{ .label = "yaml", .aliases = &.{ "yaml", "yml" }, .line_comments = &.{"#"}, .quotes = double_single_quotes, .literals = &.{ "true", "false", "null", "yes", "no", "on", "off" }, }, .{ .label = "toml", .aliases = &.{"toml"}, .line_comments = &.{"#"}, .quotes = double_single_quotes, .literals = &.{ "true", "false" }, }, .{ .label = "sql", .aliases = &.{"sql"}, .line_comments = &.{"--"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "select", "from", "where", "join", "left", "right", "inner", "outer", "on", "insert", "into", "values", "update", "set", "delete", "create", "alter", "drop", "table", "index", "group", "by", "order", "having", "limit", "as", "and", "or", "not", "distinct", "union" }, .literals = &.{ "true", "false", "null" }, .keyword_case = .ascii_insensitive, .detection = .sql_select, }, .{ .label = "dockerfile", .aliases = &.{ "dockerfile", "docker" }, .line_comments = &.{"#"}, .quotes = double_single_quotes, .keywords = &.{ "from", "run", "cmd", "entrypoint", "copy", "add", "workdir", "env", "arg", "expose", "volume", "user", "label", "onbuild", "stopsignal", "healthcheck", "shell", "maintainer" }, .keyword_case = .ascii_insensitive, .detection = .dockerfile_from, }, .{ .label = "rust", .aliases = &.{ "rust", "rs" }, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "fn", "let", "mut", "pub", "struct", "enum", "impl", "trait", "use", "mod", "crate", "return", "if", "else", "match", "for", "while", "loop", "async", "await", "move", "where", "self", "super" }, .literals = &.{ "true", "false", "None", "Some" }, .detection = .rust_function, }, .{ .label = "go", .aliases = &.{"go"}, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = &[_]u8{ '"', '`' }, .keywords = &.{ "package", "import", "func", "var", "const", "type", "struct", "interface", "return", "if", "else", "for", "range", "switch", "case", "go", "defer", "select", "chan", "map" }, .literals = &.{ "true", "false", "nil" }, .detection = .go_package, }, .{ .label = "c", .aliases = &.{ "c", "h" }, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "int", "long", "return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while" }, .literals = &.{ "true", "false", "NULL" }, }, .{ .label = "cpp", .aliases = &.{ "cpp", "c++", "cc", "cxx", "hpp" }, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "auto", "bool", "class", "const", "constexpr", "decltype", "delete", "enum", "explicit", "friend", "inline", "namespace", "new", "nullptr", "private", "protected", "public", "template", "this", "typename", "using", "virtual", "void" }, .literals = &.{ "true", "false", "nullptr", "NULL" }, }, .{ .label = "csharp", .aliases = &.{ "csharp", "cs" }, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "class", "namespace", "using", "public", "private", "protected", "internal", "static", "void", "string", "int", "var", "new", "return", "if", "else", "for", "foreach", "while", "async", "await", "interface", "record", "get", "set" }, .literals = &.{ "true", "false", "null" }, }, .{ .label = "java", .aliases = &.{"java"}, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "class", "interface", "package", "import", "public", "private", "protected", "static", "final", "void", "new", "return", "if", "else", "for", "while", "try", "catch", "throws", "extends", "implements", "record", "var" }, .literals = &.{ "true", "false", "null" }, }, .{ .label = "kotlin", .aliases = &.{ "kotlin", "kt", "kts" }, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "fun", "val", "var", "class", "object", "interface", "package", "import", "public", "private", "return", "if", "else", "when", "for", "while", "try", "catch", "data", "sealed", "suspend" }, .literals = &.{ "true", "false", "null" }, }, .{ .label = "php", .aliases = &.{"php"}, .line_comments = &.{ "//", "#" }, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "function", "class", "public", "private", "protected", "namespace", "use", "return", "if", "else", "foreach", "for", "while", "try", "catch", "new", "static", "const", "echo", "yield" }, .literals = &.{ "true", "false", "null" }, }, .{ .label = "ruby", .aliases = &.{ "ruby", "rb" }, .line_comments = &.{"#"}, .quotes = double_single_quotes, .keywords = &.{ "def", "class", "module", "end", "return", "if", "elsif", "else", "unless", "case", "when", "do", "while", "for", "in", "begin", "rescue", "require", "attr_reader" }, .literals = &.{ "true", "false", "nil" }, }, .{ .label = "swift", .aliases = &.{"swift"}, .line_comments = &.{"//"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "func", "let", "var", "class", "struct", "enum", "protocol", "extension", "import", "public", "private", "return", "if", "else", "guard", "for", "while", "switch", "case", "async", "await", "throws", "try" }, .literals = &.{ "true", "false", "nil" }, }, .{ .label = "powershell", .aliases = &.{ "powershell", "ps1", "pwsh", "ps" }, .line_comments = &.{"#"}, .block_comment = .{ .start = "<#", .end = "#>" }, .quotes = double_single_quotes, .keywords = &.{ "function", "param", "if", "else", "elseif", "foreach", "for", "while", "switch", "return", "throw", "try", "catch", "finally", "begin", "process", "end", "filter", "class", "enum" }, .literals = &.{ "true", "false", "null" }, .keyword_case = .ascii_insensitive, }, .{ .label = "lua", .aliases = &.{"lua"}, .line_comments = &.{"--"}, .block_comment = .{ .start = "--[[", .end = "]]" }, .quotes = double_single_quotes, .keywords = &.{ "and", "break", "do", "else", "elseif", "end", "false", "for", "function", "goto", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while" }, .literals = &.{ "true", "false", "nil" }, }, .{ .label = "html", .aliases = &.{ "html", "htm" }, .block_comment = .{ .start = "<!--", .end = "-->" }, .quotes = double_single_quotes, .keywords = &.{ "html", "head", "body", "main", "header", "footer", "section", "article", "div", "span", "a", "p", "script", "style", "link", "meta", "title", "button", "input", "form", "img", "ul", "li" }, }, .{ .label = "xml", .aliases = &.{"xml"}, .block_comment = .{ .start = "<!--", .end = "-->" }, .quotes = double_single_quotes, .keywords = &.{ "xml", "version", "encoding", "DOCTYPE", "CDATA" }, }, .{ .label = "css", .aliases = &.{"css"}, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "color", "background", "display", "position", "margin", "padding", "border", "font", "width", "height", "flex", "grid", "align", "justify", "transition", "transform", "animation", "media" }, }, .{ .label = "hcl", .aliases = &.{ "hcl", "terraform", "tf" }, .line_comments = &.{ "#", "//" }, .block_comment = .{ .start = "/*", .end = "*/" }, .quotes = double_single_quotes, .keywords = &.{ "resource", "module", "variable", "output", "provider", "terraform", "locals", "data", "dynamic", "for_each", "count" }, .literals = &.{ "true", "false", "null" }, },};
pub fn resolve(label: []const u8) ?*const Profile { for (&profiles) |*profile| { for (profile.aliases) |alias| { if (std.ascii.eqlIgnoreCase(label, alias)) return profile; } } return null;}
pub fn infer(alloc: Allocator, source: []const u8) ?*const Profile { for (&profiles) |*profile| { if (matchesDetection(alloc, profile.detection, source)) return profile; } return null;}
fn matchesDetection(alloc: Allocator, detection: Detection, source: []const u8) bool { return switch (detection) { .none => false, .typescript_assertion => matchesTypeScriptAssertion(source), .json => isValidJson(alloc, source), .shell_shebang => matchesShellShebang(source), .python_header => matchesPythonHeader(source), .sql_select => matchesSqlSelect(source), .dockerfile_from => startsWithIgnoreCase(firstNonblankLine(source), "from "), .go_package => startsWith(firstNonblankLine(source), "package ") and containsLineStart(source, "func "), .rust_function => matchesRustFunction(source), };}
fn matchesTypeScriptAssertion(source: []const u8) bool { var start: usize = 0; while (std.mem.indexOfPos(u8, source, start, "} as ")) |assertion_start| { const type_start = assertion_start + "} as ".len; if (type_start < source.len and std.ascii.isUpper(source[type_start])) return true; start = type_start; } return false;}
fn isValidJson(alloc: Allocator, source: []const u8) bool { const trimmed = std.mem.trim(u8, source, " \t\r\n"); if (trimmed.len == 0 or (trimmed[0] != '{' and trimmed[0] != '[')) return false; var parsed = std.json.parseFromSlice(std.json.Value, alloc, trimmed, .{}) catch return false; defer parsed.deinit(); return parsed.value == .object or parsed.value == .array;}
fn matchesShellShebang(source: []const u8) bool { const line = firstNonblankLine(source); return std.mem.startsWith(u8, line, "#!") and (std.mem.indexOf(u8, line, "bash") != null or std.mem.indexOf(u8, line, "zsh") != null or std.mem.indexOf(u8, line, "/sh") != null);}
fn matchesPythonHeader(source: []const u8) bool { const line = firstNonblankLine(source); return (std.mem.startsWith(u8, line, "def ") or std.mem.startsWith(u8, line, "class ")) and std.mem.endsWith(u8, line, ":");}
fn matchesSqlSelect(source: []const u8) bool { const line = firstNonblankLine(source); return startsWithIgnoreCase(line, "select ") and containsWordIgnoreCase(source, "from");}
fn matchesRustFunction(source: []const u8) bool { const line = firstNonblankLine(source); if (!std.mem.startsWith(u8, line, "fn ") and !std.mem.startsWith(u8, line, "pub fn ")) return false; return std.mem.indexOf(u8, source, "let ") != null or std.mem.indexOf(u8, source, "println!") != null or std.mem.indexOf(u8, line, "->") != null;}
fn firstNonblankLine(source: []const u8) []const u8 { var lines = std.mem.splitScalar(u8, source, '\n'); while (lines.next()) |line| { const trimmed = std.mem.trim(u8, line, " \t\r"); if (trimmed.len > 0) return trimmed; } return "";}
fn containsLineStart(source: []const u8, prefix: []const u8) bool { if (std.mem.startsWith(u8, source, prefix)) return true; var start: usize = 0; while (std.mem.indexOfPos(u8, source, start, "\n")) |newline| { const line_start = newline + 1; if (std.mem.startsWith(u8, source[line_start..], prefix)) return true; start = line_start; } return false;}
fn startsWith(text: []const u8, prefix: []const u8) bool { return text.len >= prefix.len and std.mem.eql(u8, text[0..prefix.len], prefix);}
fn startsWithIgnoreCase(text: []const u8, prefix: []const u8) bool { return text.len >= prefix.len and std.ascii.eqlIgnoreCase(text[0..prefix.len], prefix);}
fn containsWordIgnoreCase(source: []const u8, word: []const u8) bool { if (word.len > source.len) return false; var index: usize = 0; while (index + word.len <= source.len) : (index += 1) { const end = index + word.len; if (std.ascii.eqlIgnoreCase(source[index..end], word) and (index == 0 or !isWordByte(source[index - 1])) and (end == source.len or !isWordByte(source[end]))) return true; } return false;}
fn isWordByte(byte: u8) bool { return std.ascii.isAlphanumeric(byte) or byte == '_';}
test "TypeScript assertions infer the canonical TypeScript label" { const source = "const hook = await resumeHook(token, { cleanup: true } as CleanupSignal);";
try std.testing.expectEqualStrings("ts", infer(std.testing.allocator, source).?.label); try std.testing.expect(infer(std.testing.allocator, "const value = 1;") == null); try std.testing.expect(infer(std.testing.allocator, "const value = {} as cleanupSignal;") == null);}
test "supported code fence labels resolve case insensitively" { const cases = [_]struct { label: []const u8, profile: []const u8 }{ .{ .label = "Zig", .profile = "zig" }, .{ .label = "js", .profile = "ts" }, .{ .label = "JSX", .profile = "ts" }, .{ .label = "javascript", .profile = "ts" }, .{ .label = "TS", .profile = "ts" }, .{ .label = "tsx", .profile = "ts" }, .{ .label = "TypeScript", .profile = "ts" }, .{ .label = "JSON", .profile = "json" }, .{ .label = "sh", .profile = "sh" }, .{ .label = "BASH", .profile = "sh" }, .{ .label = "zsh", .profile = "sh" }, .{ .label = "Shell", .profile = "sh" }, }; for (cases) |case| try std.testing.expectEqualStrings(case.profile, resolve(case.label).?.label); try std.testing.expect(resolve("") == null); try std.testing.expect(resolve("text") == null);}
test "expanded code fence labels resolve through the language registry" { const cases = [_]struct { label: []const u8, profile: []const u8 }{ .{ .label = "python", .profile = "python" }, .{ .label = "py", .profile = "python" }, .{ .label = "yaml", .profile = "yaml" }, .{ .label = "yml", .profile = "yaml" }, .{ .label = "toml", .profile = "toml" }, .{ .label = "sql", .profile = "sql" }, .{ .label = "dockerfile", .profile = "dockerfile" }, .{ .label = "rust", .profile = "rust" }, .{ .label = "rs", .profile = "rust" }, .{ .label = "go", .profile = "go" }, .{ .label = "c", .profile = "c" }, .{ .label = "cpp", .profile = "cpp" }, .{ .label = "c++", .profile = "cpp" }, .{ .label = "csharp", .profile = "csharp" }, .{ .label = "cs", .profile = "csharp" }, .{ .label = "java", .profile = "java" }, .{ .label = "kotlin", .profile = "kotlin" }, .{ .label = "php", .profile = "php" }, .{ .label = "ruby", .profile = "ruby" }, .{ .label = "swift", .profile = "swift" }, .{ .label = "powershell", .profile = "powershell" }, .{ .label = "ps1", .profile = "powershell" }, .{ .label = "lua", .profile = "lua" }, .{ .label = "html", .profile = "html" }, .{ .label = "xml", .profile = "xml" }, .{ .label = "css", .profile = "css" }, .{ .label = "hcl", .profile = "hcl" }, .{ .label = "terraform", .profile = "hcl" }, .{ .label = "tf", .profile = "hcl" }, }; for (cases) |case| try std.testing.expectEqualStrings(case.profile, resolve(case.label).?.label);}
test "high-confidence source shapes infer registered profiles" { const alloc = std.testing.allocator; const cases = [_]struct { source: []const u8, profile: []const u8 }{ .{ .source = "{\"ready\": true}", .profile = "json" }, .{ .source = "#!/usr/bin/env bash\necho ready", .profile = "sh" }, .{ .source = "def render(value):\n return value", .profile = "python" }, .{ .source = "SELECT id FROM users", .profile = "sql" }, .{ .source = "FROM alpine:3.20\nRUN echo ready", .profile = "dockerfile" }, .{ .source = "package main\nfunc main() {}", .profile = "go" }, .{ .source = "fn main() { println!(\"ready\"); }", .profile = "rust" }, };
for (cases) |case| try std.testing.expectEqualStrings(case.profile, infer(alloc, case.source).?.label); try std.testing.expect(infer(alloc, "const value = 1;") == null); try std.testing.expect(infer(alloc, "title: ready") == null);}
test "aliases do not collide across profiles" { for (profiles, 0..) |profile, profile_index| { for (profile.aliases) |alias| { for (profiles[profile_index + 1 ..]) |other| { for (other.aliases) |other_alias| { try std.testing.expect(!std.ascii.eqlIgnoreCase(alias, other_alias)); } } } }}