(&contents)
- 847 | .context(format!("Failed to parse {filename}"))
- 848 | .map(|_| true)
- 849 | }
- 850 | })
- 851 | .transpose()?;
- 852 | if json == Some(true) {
- 853 | return Ok(pathbuf.parent().unwrap().to_path_buf());
- 854 | }
- 855 | pathbuf.pop(); // filename
- 856 | if !pathbuf.pop() {
- 857 | return Err(anyhow!(format!(
- 858 | concat!(
- 859 | "Failed to locate a {} file,",
- 860 | " please ensure you have one, and if you don't then consult the docs",
- 861 | ),
- 862 | filename
- 863 | )));
- 864 | }
- 865 | pathbuf.push(filename);
- 866 | }
- 867 | }
- |
- 868 | fn generate_file(
- 869 | path: &Path,
- 870 | template: &str,
- 871 | language_name: &str,
- 872 | generate_opts: &GenerateOpts,
- 873 | ) -> Result<()> {
- 874 | let filename = path.file_name().unwrap().to_str().unwrap();
- |
- 875 | let mut replacement = template
- 876 | .replace(
- 877 | CAMEL_PARSER_NAME_PLACEHOLDER,
- 878 | generate_opts.camel_parser_name,
- 879 | )
- 880 | .replace(
- 881 | TITLE_PARSER_NAME_PLACEHOLDER,
- 882 | generate_opts.title_parser_name,
- 883 | )
- 884 | .replace(
- 885 | UPPER_PARSER_NAME_PLACEHOLDER,
- 886 | &language_name.to_shouty_snake_case(),
- 887 | )
- 888 | .replace(
- 889 | LOWER_PARSER_NAME_PLACEHOLDER,
- 890 | &language_name.to_snake_case(),
- 891 | )
- 892 | .replace(
- 893 | KEBAB_PARSER_NAME_PLACEHOLDER,
- 894 | &language_name.to_kebab_case(),
- 895 | )
- 896 | .replace(PARSER_NAME_PLACEHOLDER, language_name)
- 897 | .replace(CLI_VERSION_PLACEHOLDER, CLI_VERSION)
- 898 | .replace(RUST_BINDING_VERSION_PLACEHOLDER, RUST_BINDING_VERSION)
- 899 | .replace(ABI_VERSION_MAX_PLACEHOLDER, &ABI_VERSION_MAX.to_string())
- 900 | .replace(
- 901 | PARSER_VERSION_PLACEHOLDER,
- 902 | &generate_opts.version.to_string(),
- 903 | )
- 904 | .replace(PARSER_CLASS_NAME_PLACEHOLDER, generate_opts.class_name);
- |
- 905 | if let Some(name) = generate_opts.author_name {
- 906 | replacement = replacement.replace(AUTHOR_NAME_PLACEHOLDER, name);
- 907 | } else {
- 908 | match filename {
- 909 | "package.json" => {
- 910 | replacement = replacement.replace(AUTHOR_NAME_PLACEHOLDER_JS, "");
- 911 | }
- 912 | "pyproject.toml" => {
- 913 | replacement = replacement.replace(AUTHOR_NAME_PLACEHOLDER_PY, "");
- 914 | }
- 915 | "grammar.js" => {
- 916 | replacement = replacement.replace(AUTHOR_NAME_PLACEHOLDER_GRAMMAR, "");
- 917 | }
- 918 | "Cargo.toml" => {
- 919 | replacement = replacement.replace(AUTHOR_NAME_PLACEHOLDER_RS, "");
- 920 | }
- 921 | _ => {}
- 922 | }
- 923 | }
- |
- 924 | if let Some(email) = generate_opts.author_email {
- 925 | replacement = match filename {
- 926 | "Cargo.toml" | "grammar.js" => {
- 927 | replacement.replace(AUTHOR_EMAIL_PLACEHOLDER, &format!("<{email}>"))
- 928 | }
- 929 | _ => replacement.replace(AUTHOR_EMAIL_PLACEHOLDER, email),
- 930 | }
- 931 | } else {
- 932 | match filename {
- 933 | "package.json" => {
- 934 | replacement = replacement.replace(AUTHOR_EMAIL_PLACEHOLDER_JS, "");
- 935 | }
- 936 | "pyproject.toml" => {
- 937 | replacement = replacement.replace(AUTHOR_EMAIL_PLACEHOLDER_PY, "");
- 938 | }
- 939 | "grammar.js" => {
- 940 | replacement = replacement.replace(AUTHOR_EMAIL_PLACEHOLDER_GRAMMAR, "");
- 941 | }
- 942 | "Cargo.toml" => {
- 943 | replacement = replacement.replace(AUTHOR_EMAIL_PLACEHOLDER_RS, "");
- 944 | }
- 945 | _ => {}
- 946 | }
- 947 | }
- |
- 948 | if filename == "package.json" {
- 949 | if let Some(url) = generate_opts.author_url {
- 950 | replacement = replacement.replace(AUTHOR_URL_PLACEHOLDER, url);
- 951 | } else {
- 952 | replacement = replacement.replace(AUTHOR_URL_PLACEHOLDER_JS, "");
- 953 | }
- 954 | }
- |
- 955 | if generate_opts.author_name.is_none()
- 956 | && generate_opts.author_email.is_none()
- 957 | && generate_opts.author_url.is_none()
- 958 | && filename == "package.json"
- 959 | {
- 960 | if let Some(start_idx) = replacement.find(AUTHOR_BLOCK_JS) {
- 961 | if let Some(end_idx) = replacement[start_idx..]
- 962 | .find("},")
- 963 | .map(|i| i + start_idx + 2)
- 964 | {
- 965 | replacement.replace_range(start_idx..end_idx, "");
- 966 | }
- 967 | }
- 968 | } else if generate_opts.author_name.is_none() && generate_opts.author_email.is_none() {
- 969 | match filename {
- 970 | "pyproject.toml" => {
- 971 | if let Some(start_idx) = replacement.find(AUTHOR_BLOCK_PY) {
- 972 | if let Some(end_idx) = replacement[start_idx..]
- 973 | .find("}]")
- 974 | .map(|i| i + start_idx + 2)
- 975 | {
- 976 | replacement.replace_range(start_idx..end_idx, "");
- 977 | }
- 978 | }
- 979 | }
- 980 | "grammar.js" => {
- 981 | if let Some(start_idx) = replacement.find(AUTHOR_BLOCK_GRAMMAR) {
- 982 | if let Some(end_idx) = replacement[start_idx..]
- 983 | .find(" \n")
- 984 | .map(|i| i + start_idx + 1)
- 985 | {
- 986 | replacement.replace_range(start_idx..end_idx, "");
- 987 | }
- 988 | }
- 989 | }
- 990 | "Cargo.toml" => {
- 991 | if let Some(start_idx) = replacement.find(AUTHOR_BLOCK_RS) {
- 992 | if let Some(end_idx) = replacement[start_idx..]
- 993 | .find("\"]")
- 994 | .map(|i| i + start_idx + 2)
- 995 | {
- 996 | replacement.replace_range(start_idx..end_idx, "");
- 997 | }
- 998 | }
- 999 | }
-1000 | _ => {}
-1001 | }
-1002 | }
- |
-1003 | if let Some(license) = generate_opts.license {
-1004 | replacement = replacement.replace(PARSER_LICENSE_PLACEHOLDER, license);
-1005 | } else {
-1006 | replacement = replacement.replace(PARSER_LICENSE_PLACEHOLDER, "MIT");
-1007 | }
- |
-1008 | if let Some(description) = generate_opts.description {
-1009 | replacement = replacement.replace(PARSER_DESCRIPTION_PLACEHOLDER, description);
-1010 | } else {
-1011 | replacement = replacement.replace(
-1012 | PARSER_DESCRIPTION_PLACEHOLDER,
-1013 | &format!(
-1014 | "{} grammar for tree-sitter",
-1015 | generate_opts.camel_parser_name,
-1016 | ),
-1017 | );
-1018 | }
- |
-1019 | if let Some(repository) = generate_opts.repository {
-1020 | replacement = replacement
-1021 | .replace(
-1022 | PARSER_URL_STRIPPED_PLACEHOLDER,
-1023 | &repository.replace("https://", "").to_lowercase(),
-1024 | )
-1025 | .replace(PARSER_URL_PLACEHOLDER, &repository.to_lowercase());
-1026 | } else {
-1027 | replacement = replacement
-1028 | .replace(
-1029 | PARSER_URL_STRIPPED_PLACEHOLDER,
-1030 | &format!(
-1031 | "github.com/tree-sitter/tree-sitter-{}",
-1032 | language_name.to_lowercase()
-1033 | ),
-1034 | )
-1035 | .replace(
-1036 | PARSER_URL_PLACEHOLDER,
-1037 | &format!(
-1038 | "https://github.com/tree-sitter/tree-sitter-{}",
-1039 | language_name.to_lowercase()
-1040 | ),
-1041 | );
-1042 | }
- |
-1043 | if let Some(funding_url) = generate_opts.funding {
-1044 | match filename {
-1045 | "pyproject.toml" | "package.json" => {
-1046 | replacement = replacement.replace(FUNDING_URL_PLACEHOLDER, funding_url);
-1047 | }
-1048 | _ => {}
-1049 | }
-1050 | } else {
-1051 | match filename {
-1052 | "package.json" => {
-1053 | replacement = replacement.replace(" \"funding\": \"FUNDING_URL\",\n", "");
-1054 | }
-1055 | "pyproject.toml" => {
-1056 | replacement = replacement.replace("Funding = \"FUNDING_URL\"\n", "");
-1057 | }
-1058 | _ => {}
-1059 | }
-1060 | }
- |
-1061 | if filename == "build.zig.zon" {
-1062 | let id = thread_rng().gen_range(1u32..0xFFFF_FFFFu32);
-1063 | let checksum = crc32(format!("tree_sitter_{language_name}").as_bytes());
-1064 | replacement = replacement.replace(
-1065 | PARSER_FINGERPRINT_PLACEHOLDER,
-1066 | #[cfg(target_endian = "little")]
-1067 | &format!("0x{checksum:x}{id:x}"),
-1068 | #[cfg(target_endian = "big")]
-1069 | &format!("0x{id:x}{checksum:x}"),
-1070 | );
-1071 | }
- |
-1072 | write_file(path, replacement)?;
-1073 | Ok(())
-1074 | }
- |
-1075 | fn create_dir(path: &Path) -> Result<()> {
-1076 | fs::create_dir_all(path)
-1077 | .with_context(|| format!("Failed to create {:?}", path.to_string_lossy()))
-1078 | }
- |
-1079 | #[derive(PartialEq, Eq, Debug)]
-1080 | enum PathState
-1081 | where
-1082 | P: AsRef,
-1083 | {
-1084 | Exists(P),
-1085 | Missing(P),
-1086 | }
- |
-1087 | #[allow(dead_code)]
-1088 | impl PathState
-1089 | where
-1090 | P: AsRef,
-1091 | {
-1092 | fn exists(&self, mut action: impl FnMut(&Path) -> Result<()>) -> Result<&Self> {
-1093 | if let Self::Exists(path) = self {
-1094 | action(path.as_ref())?;
-1095 | }
-1096 | Ok(self)
-1097 | }
- |
-1098 | fn missing(&self, mut action: impl FnMut(&Path) -> Result<()>) -> Result<&Self> {
-1099 | if let Self::Missing(path) = self {
-1100 | action(path.as_ref())?;
-1101 | }
-1102 | Ok(self)
-1103 | }
- |
-1104 | fn apply(&self, mut action: impl FnMut(&Path) -> Result<()>) -> Result<&Self> {
-1105 | action(self.as_path())?;
-1106 | Ok(self)
-1107 | }
- |
-1108 | fn apply_state(&self, mut action: impl FnMut(&Self) -> Result<()>) -> Result<&Self> {
-1109 | action(self)?;
-1110 | Ok(self)
-1111 | }
- |
-1112 | fn as_path(&self) -> &Path {
-1113 | match self {
-1114 | Self::Exists(path) | Self::Missing(path) => path.as_ref(),
-1115 | }
-1116 | }
-1117 | }
- |
-1118 | fn missing_path(path: P, mut action: F) -> Result>
-1119 | where
-1120 | P: AsRef,
-1121 | F: FnMut(&Path) -> Result<()>,
-1122 | {
-1123 | let path_ref = path.as_ref();
-1124 | if !path_ref.exists() {
-1125 | action(path_ref)?;
-1126 | Ok(PathState::Missing(path))
-1127 | } else {
-1128 | Ok(PathState::Exists(path))
-1129 | }
-1130 | }
- |
-1131 | fn missing_path_else(
-1132 | path: P,
-1133 | allow_update: bool,
-1134 | mut action: T,
-1135 | mut else_action: F,
-1136 | ) -> Result>
-1137 | where
-1138 | P: AsRef,
-1139 | T: FnMut(&Path) -> Result<()>,
-1140 | F: FnMut(&Path) -> Result<()>,
-1141 | {
-1142 | let path_ref = path.as_ref();
-1143 | if !path_ref.exists() {
-1144 | action(path_ref)?;
-1145 | Ok(PathState::Missing(path))
-1146 | } else {
-1147 | if allow_update {
-1148 | else_action(path_ref)?;
-1149 | }
-1150 | Ok(PathState::Exists(path))
-1151 | }
-1152 | }
-
-
-
---------------------------------------------------------------------------------
-/crates/cli/src/input.rs:
---------------------------------------------------------------------------------
- 1 | use std::{
- 2 | fs,
- 3 | io::{Read, Write},
- 4 | path::{Path, PathBuf},
- 5 | sync::{
- 6 | atomic::{AtomicUsize, Ordering},
- 7 | mpsc, Arc,
- 8 | },
- 9 | };
- |
- 10 | use anyhow::{anyhow, bail, Context, Result};
- 11 | use glob::glob;
- |
- 12 | use crate::test::{parse_tests, TestEntry};
- |
- 13 | pub enum CliInput {
- 14 | Paths(Vec),
- 15 | Test {
- 16 | name: String,
- 17 | contents: Vec,
- 18 | languages: Vec>,
- 19 | },
- 20 | Stdin(Vec),
- 21 | }
- |
- 22 | pub fn get_input(
- 23 | paths_file: Option<&Path>,
- 24 | paths: Option>,
- 25 | test_number: Option,
- 26 | cancellation_flag: &Arc,
- 27 | ) -> Result {
- 28 | if let Some(paths_file) = paths_file {
- 29 | return Ok(CliInput::Paths(
- 30 | fs::read_to_string(paths_file)
- 31 | .with_context(|| format!("Failed to read paths file {}", paths_file.display()))?
- 32 | .trim()
- 33 | .lines()
- 34 | .map(PathBuf::from)
- 35 | .collect::>(),
- 36 | ));
- 37 | }
- |
- 38 | if let Some(test_number) = test_number {
- 39 | let current_dir = std::env::current_dir().unwrap();
- 40 | let test_dir = current_dir.join("test").join("corpus");
- |
- 41 | if !test_dir.exists() {
- 42 | return Err(anyhow!(
- 43 | "Test corpus directory not found in current directory, see https://tree-sitter.github.io/tree-sitter/creating-parsers/5-writing-tests"
- 44 | ));
- 45 | }
- |
- 46 | let test_entry = parse_tests(&test_dir)?;
- 47 | let mut test_num = 0;
- 48 | let Some((name, contents, languages)) =
- 49 | get_test_info(&test_entry, test_number.max(1) - 1, &mut test_num)
- 50 | else {
- 51 | return Err(anyhow!("Failed to fetch contents of test #{test_number}"));
- 52 | };
- |
- 53 | return Ok(CliInput::Test {
- 54 | name,
- 55 | contents,
- 56 | languages,
- 57 | });
- 58 | }
- |
- 59 | if let Some(paths) = paths {
- 60 | let mut result = Vec::new();
- |
- 61 | let mut incorporate_path = |path: PathBuf, positive| {
- 62 | if positive {
- 63 | result.push(path);
- 64 | } else if let Some(index) = result.iter().position(|p| *p == path) {
- 65 | result.remove(index);
- 66 | }
- 67 | };
- |
- 68 | for mut path in paths {
- 69 | let mut positive = true;
- 70 | if path.starts_with("!") {
- 71 | positive = false;
- 72 | path = path.strip_prefix("!").unwrap().to_path_buf();
- 73 | }
- |
- 74 | if path.exists() {
- 75 | incorporate_path(path, positive);
- 76 | } else {
- 77 | let Some(path_str) = path.to_str() else {
- 78 | bail!("Invalid path: {}", path.display());
- 79 | };
- 80 | let paths = glob(path_str)
- 81 | .with_context(|| format!("Invalid glob pattern {}", path.display()))?;
- 82 | for path in paths {
- 83 | incorporate_path(path?, positive);
- 84 | }
- 85 | }
- 86 | }
- |
- 87 | if result.is_empty() {
- 88 | return Err(anyhow!(
- 89 | "No files were found at or matched by the provided pathname/glob"
- 90 | ));
- 91 | }
- |
- 92 | return Ok(CliInput::Paths(result));
- 93 | }
- |
- 94 | let reader_flag = cancellation_flag.clone();
- 95 | let (tx, rx) = mpsc::channel();
- |
- 96 | // Spawn a thread to read from stdin, until ctrl-c or EOF is received
- 97 | std::thread::spawn(move || {
- 98 | let mut input = Vec::new();
- 99 | let stdin = std::io::stdin();
- 100 | let mut handle = stdin.lock();
- |
- 101 | // Read in chunks, so we can check the ctrl-c flag
- 102 | loop {
- 103 | if reader_flag.load(Ordering::Relaxed) == 1 {
- 104 | break;
- 105 | }
- 106 | let mut buffer = [0; 1024];
- 107 | match handle.read(&mut buffer) {
- 108 | Ok(0) | Err(_) => break,
- 109 | Ok(n) => input.extend_from_slice(&buffer[..n]),
- 110 | }
- 111 | }
- |
- 112 | // Signal to the main thread that we're done
- 113 | tx.send(input).ok();
- 114 | });
- |
- 115 | loop {
- 116 | // If we've received a ctrl-c signal, exit
- 117 | if cancellation_flag.load(Ordering::Relaxed) == 1 {
- 118 | bail!("\n");
- 119 | }
- |
- 120 | // If we're done receiving input from stdin, return it
- 121 | if let Ok(input) = rx.try_recv() {
- 122 | return Ok(CliInput::Stdin(input));
- 123 | }
- |
- 124 | std::thread::sleep(std::time::Duration::from_millis(50));
- 125 | }
- 126 | }
- |
- 127 | #[allow(clippy::type_complexity)]
- 128 | pub fn get_test_info(
- 129 | test_entry: &TestEntry,
- 130 | target_test: u32,
- 131 | test_num: &mut u32,
- 132 | ) -> Option<(String, Vec, Vec>)> {
- 133 | match test_entry {
- 134 | TestEntry::Example {
- 135 | name,
- 136 | input,
- 137 | attributes,
- 138 | ..
- 139 | } => {
- 140 | if *test_num == target_test {
- 141 | return Some((name.clone(), input.clone(), attributes.languages.clone()));
- 142 | }
- 143 | *test_num += 1;
- 144 | }
- 145 | TestEntry::Group { children, .. } => {
- 146 | for child in children {
- 147 | if let Some((name, input, languages)) = get_test_info(child, target_test, test_num)
- 148 | {
- 149 | return Some((name, input, languages));
- 150 | }
- 151 | }
- 152 | }
- 153 | }
- |
- 154 | None
- 155 | }
- |
- 156 | /// Writes `contents` to a temporary file and returns the path to that file.
- 157 | pub fn get_tmp_source_file(contents: &[u8]) -> Result {
- 158 | let parse_path = std::env::temp_dir().join(".tree-sitter-temp");
- 159 | let mut parse_file = std::fs::File::create(&parse_path)?;
- 160 | parse_file.write_all(contents)?;
- |
- 161 | Ok(parse_path)
- 162 | }
-
-
-
---------------------------------------------------------------------------------
-/crates/cli/src/logger.rs:
---------------------------------------------------------------------------------
- 1 | use std::io::Write;
- |
- 2 | use anstyle::{AnsiColor, Color, Style};
- 3 | use log::{Level, LevelFilter, Log, Metadata, Record};
- |
- 4 | pub fn paint(color: Option>, text: &str) -> String {
- 5 | let style = Style::new().fg_color(color.map(Into::into));
- 6 | format!("{style}{text}{style:#}")
- 7 | }
- |
- 8 | struct Logger;
- |
- 9 | impl Log for Logger {
- 10 | fn enabled(&self, _: &Metadata) -> bool {
- 11 | true
- 12 | }
- |
- 13 | fn log(&self, record: &Record) {
- 14 | match record.level() {
- 15 | Level::Error => eprintln!(
- 16 | "{} {}",
- 17 | paint(Some(AnsiColor::Red), "Error:"),
- 18 | record.args()
- 19 | ),
- 20 | Level::Warn => eprintln!(
- 21 | "{} {}",
- 22 | paint(Some(AnsiColor::Yellow), "Warning:"),
- 23 | record.args()
- 24 | ),
- 25 | Level::Info | Level::Debug => eprintln!("{}", record.args()),
- 26 | Level::Trace => eprintln!(
- 27 | "[{}] {}",
- 28 | record
- 29 | .module_path()
- 30 | .unwrap_or_default()
- 31 | .trim_start_matches("rust_tree_sitter_cli::"),
- 32 | record.args()
- 33 | ),
- 34 | }
- 35 | }
- |
- 36 | fn flush(&self) {
- 37 | let mut stderr = std::io::stderr().lock();
- 38 | let _ = stderr.flush();
- 39 | }
- 40 | }
- |
- 41 | pub fn init() {
- 42 | log::set_boxed_logger(Box::new(Logger {})).unwrap();
- 43 | log::set_max_level(LevelFilter::Info);
- 44 | }
- |
- 45 | pub fn enable_debug() {
- 46 | log::set_max_level(LevelFilter::Debug);
- 47 | }
-
-
-
---------------------------------------------------------------------------------
-/crates/cli/src/main.rs:
---------------------------------------------------------------------------------
- 1 | use std::{
- 2 | collections::HashSet,
- 3 | env, fs,
- 4 | path::{Path, PathBuf},
- 5 | };
- |
- 6 | use anstyle::{AnsiColor, Color, Style};
- 7 | use anyhow::{anyhow, Context, Result};
- 8 | use clap::{crate_authors, Args, Command, FromArgMatches as _, Subcommand, ValueEnum};
- 9 | use clap_complete::generate;
- 10 | use dialoguer::{theme::ColorfulTheme, Confirm, FuzzySelect, Input, MultiSelect};
- 11 | use heck::ToUpperCamelCase;
- 12 | use log::{error, info, warn};
- 13 | use regex::Regex;
- 14 | use semver::Version as SemverVersion;
- 15 | use tree_sitter::{ffi, Parser, Point};
- 16 | use tree_sitter_cli::{
- 17 | fuzz::{
- 18 | fuzz_language_corpus, FuzzOptions, EDIT_COUNT, ITERATION_COUNT, LOG_ENABLED,
- 19 | LOG_GRAPH_ENABLED, START_SEED,
- 20 | },
- 21 | highlight::{self, HighlightOptions},
- 22 | init::{generate_grammar_files, JsonConfigOpts},
- 23 | input::{get_input, get_tmp_source_file, CliInput},
- 24 | logger,
- 25 | parse::{self, ParseDebugType, ParseFileOptions, ParseOutput, ParseTheme},
- 26 | playground, query,
- 27 | tags::{self, TagsOptions},
- 28 | test::{self, TestOptions, TestStats},
- 29 | test_highlight, test_tags, util, version,
- 30 | version::BumpLevel,
- 31 | wasm,
- 32 | };
- 33 | use tree_sitter_config::Config;
- 34 | use tree_sitter_generate::OptLevel;
- 35 | use tree_sitter_highlight::Highlighter;
- 36 | use tree_sitter_loader::{self as loader, Bindings, TreeSitterJSON};
- 37 | use tree_sitter_tags::TagsContext;
- |
- 38 | const BUILD_VERSION: &str = env!("CARGO_PKG_VERSION");
- 39 | const BUILD_SHA: Option<&'static str> = option_env!("BUILD_SHA");
- 40 | const DEFAULT_GENERATE_ABI_VERSION: usize = 15;
- |
- 41 | #[derive(Subcommand)]
- 42 | #[command(about="Generates and tests parsers", author=crate_authors!("\n"), styles=get_styles())]
- 43 | enum Commands {
- 44 | /// Generate a default config file
- 45 | InitConfig(InitConfig),
- 46 | /// Initialize a grammar repository
- 47 | Init(Init),
- 48 | /// Generate a parser
- 49 | Generate(Generate),
- 50 | /// Compile a parser
- 51 | Build(Build),
- 52 | /// Parse files
- 53 | Parse(Parse),
- 54 | /// Run a parser's tests
- 55 | Test(Test),
- 56 | /// Display or increment the version of a grammar
- 57 | Version(Version),
- 58 | /// Fuzz a parser
- 59 | Fuzz(Fuzz),
- 60 | /// Search files using a syntax tree query
- 61 | Query(Query),
- 62 | /// Highlight a file
- 63 | Highlight(Highlight),
- 64 | /// Generate a list of tags
- 65 | Tags(Tags),
- 66 | /// Start local playground for a parser in the browser
- 67 | Playground(Playground),
- 68 | /// Print info about all known language parsers
- 69 | DumpLanguages(DumpLanguages),
- 70 | /// Generate shell completions
- 71 | Complete(Complete),
- 72 | }
- |
- 73 | #[derive(Args)]
- 74 | struct InitConfig;
- |
- 75 | #[derive(Args)]
- 76 | #[command(alias = "i")]
- 77 | struct Init {
- 78 | /// Update outdated files
- 79 | #[arg(long, short)]
- 80 | pub update: bool,
- 81 | /// The path to the tree-sitter grammar directory
- 82 | #[arg(long, short = 'p')]
- 83 | pub grammar_path: Option,
- 84 | }
- |
- 85 | #[derive(Clone, Debug, Default, ValueEnum, PartialEq, Eq)]
- 86 | enum GenerationEmit {
- 87 | /// Generate `grammar.json` and `node-types.json`
- 88 | Json,
- 89 | /// Generate `parser.c` and related files
- 90 | #[default]
- 91 | Parser,
- 92 | /// Compile to a library
- 93 | Lib,
- 94 | }
- |
- 95 | #[derive(Args)]
- 96 | #[command(alias = "gen", alias = "g")]
- 97 | struct Generate {
- 98 | /// The path to the grammar file
- 99 | #[arg(index = 1)]
- 100 | pub grammar_path: Option,
- 101 | /// Show debug log during generation
- 102 | #[arg(long, short)]
- 103 | pub log: bool,
- 104 | #[arg(
- 105 | long = "abi",
- 106 | value_name = "VERSION",
- 107 | env = "TREE_SITTER_ABI_VERSION",
- 108 | help = format!(concat!(
- 109 | "Select the language ABI version to generate (default {}).\n",
- 110 | "Use --abi=latest to generate the newest supported version ({}).",
- 111 | ),
- 112 | DEFAULT_GENERATE_ABI_VERSION,
- 113 | tree_sitter::LANGUAGE_VERSION,
- 114 | )
- 115 | )]
- 116 | pub abi_version: Option,
- 117 | /// What generated files to emit
- 118 | #[arg(long)]
- 119 | #[clap(value_enum, default_value_t=GenerationEmit::Parser)]
- 120 | pub emit: GenerationEmit,
- 121 | /// Deprecated: use --emit=lib.
- 122 | #[arg(long, short = 'b', conflicts_with = "emit")]
- 123 | pub build: bool,
- 124 | /// Compile a parser in debug mode
- 125 | #[arg(long, short = '0')]
- 126 | pub debug_build: bool,
- 127 | /// The path to the directory containing the parser library
- 128 | #[arg(long, value_name = "PATH")]
- 129 | pub libdir: Option,
- 130 | /// The path to output the generated source files
- 131 | #[arg(long, short, value_name = "DIRECTORY")]
- 132 | pub output: Option,
- 133 | /// Produce a report of the states for the given rule, use `-` to report every rule
- 134 | #[arg(long)]
- 135 | pub report_states_for_rule: Option,
- 136 | /// Report conflicts in a JSON format
- 137 | #[arg(long)]
- 138 | pub json: bool,
- 139 | /// The name or path of the JavaScript runtime to use for generating parsers
- 140 | #[cfg(not(feature = "qjs-rt"))]
- 141 | #[arg(
- 142 | long,
- 143 | value_name = "EXECUTABLE",
- 144 | env = "TREE_SITTER_JS_RUNTIME",
- 145 | default_value = "node"
- 146 | )]
- 147 | pub js_runtime: Option,
- |
- 148 | #[cfg(feature = "qjs-rt")]
- 149 | #[arg(
- 150 | long,
- 151 | value_name = "EXECUTABLE",
- 152 | env = "TREE_SITTER_JS_RUNTIME",
- 153 | default_value = "node"
- 154 | )]
- 155 | /// The name or path of the JavaScript runtime to use for generating parsers, specify `native`
- 156 | /// to use the native `QuickJS` runtime
- 157 | pub js_runtime: Option,
- |
- 158 | /// Disable optimizations when generating the parser. Currently, this only affects
- 159 | /// the merging of compatible parse states.
- 160 | #[arg(long)]
- 161 | pub disable_optimizations: bool,
- 162 | }
- |
- 163 | #[derive(Args)]
- 164 | #[command(alias = "b")]
- 165 | struct Build {
- 166 | /// Build a Wasm module instead of a dynamic library
- 167 | #[arg(short, long)]
- 168 | pub wasm: bool,
- 169 | /// The path to output the compiled file
- 170 | #[arg(short, long)]
- 171 | pub output: Option,
- 172 | /// The path to the grammar directory
- 173 | #[arg(index = 1, num_args = 1)]
- 174 | pub path: Option,
- 175 | /// Make the parser reuse the same allocator as the library
- 176 | #[arg(long)]
- 177 | pub reuse_allocator: bool,
- 178 | /// Compile a parser in debug mode
- 179 | #[arg(long, short = '0')]
- 180 | pub debug: bool,
- 181 | }
- |
- 182 | #[derive(Args)]
- 183 | #[command(alias = "p")]
- 184 | struct Parse {
- 185 | /// The path to a file with paths to source file(s)
- 186 | #[arg(long = "paths")]
- 187 | pub paths_file: Option,
- 188 | /// The source file(s) to use
- 189 | #[arg(num_args=1..)]
- 190 | pub paths: Option>,
- 191 | /// The path to the tree-sitter grammar directory, implies --rebuild
- 192 | #[arg(long, short = 'p', conflicts_with = "rebuild")]
- 193 | pub grammar_path: Option,
- 194 | /// The path to the parser's dynamic library
- 195 | #[arg(long, short = 'l')]
- 196 | pub lib_path: Option,
- 197 | /// If `--lib-path` is used, the name of the language used to extract the
- 198 | /// library's language function
- 199 | #[arg(long)]
- 200 | pub lang_name: Option,
- 201 | /// Select a language by the scope instead of a file extension
- 202 | #[arg(long)]
- 203 | pub scope: Option,
- 204 | /// Show parsing debug log
- 205 | #[arg(long, short = 'd')] // TODO: Rework once clap adds `default_missing_value_t`
- 206 | #[allow(clippy::option_option)]
- 207 | pub debug: Option>,
- 208 | /// Compile a parser in debug mode
- 209 | #[arg(long, short = '0')]
- 210 | pub debug_build: bool,
- 211 | /// Produce the log.html file with debug graphs
- 212 | #[arg(long, short = 'D')]
- 213 | pub debug_graph: bool,
- 214 | /// Compile parsers to Wasm instead of native dynamic libraries
- 215 | #[arg(long)]
- 216 | pub wasm: bool,
- 217 | /// Output the parse data with graphviz dot
- 218 | #[arg(long = "dot")]
- 219 | pub output_dot: bool,
- 220 | /// Output the parse data in XML format
- 221 | #[arg(long = "xml", short = 'x')]
- 222 | pub output_xml: bool,
- 223 | /// Output the parse data in a pretty-printed CST format
- 224 | #[arg(long = "cst", short = 'c')]
- 225 | pub output_cst: bool,
- 226 | /// Show parsing statistic
- 227 | #[arg(long, short)]
- 228 | pub stat: bool,
- 229 | /// Interrupt the parsing process by timeout (µs)
- 230 | #[arg(long)]
- 231 | pub timeout: Option,
- 232 | /// Measure execution time
- 233 | #[arg(long, short)]
- 234 | pub time: bool,
- 235 | /// Suppress main output
- 236 | #[arg(long, short)]
- 237 | pub quiet: bool,
- 238 | #[allow(clippy::doc_markdown)]
- 239 | /// Apply edits in the format: \"row,col|position delcount insert_text\", can be supplied
- 240 | /// multiple times
- 241 | #[arg(
- 242 | long,
- 243 | num_args = 1..,
- 244 | )]
- 245 | pub edits: Option>,
- 246 | /// The encoding of the input files
- 247 | #[arg(long)]
- 248 | pub encoding: Option,
- 249 | /// Open `log.html` in the default browser, if `--debug-graph` is supplied
- 250 | #[arg(long)]
- 251 | pub open_log: bool,
- 252 | /// Output parsing results in a JSON format
- 253 | #[arg(long, short = 'j')]
- 254 | pub json: bool,
- 255 | /// The path to an alternative config.json file
- 256 | #[arg(long)]
- 257 | pub config_path: Option,
- 258 | /// Parse the contents of a specific test
- 259 | #[arg(long, short = 'n')]
- 260 | #[clap(conflicts_with = "paths", conflicts_with = "paths_file")]
- 261 | pub test_number: Option,
- 262 | /// Force rebuild the parser
- 263 | #[arg(short, long)]
- 264 | pub rebuild: bool,
- 265 | /// Omit ranges in the output
- 266 | #[arg(long)]
- 267 | pub no_ranges: bool,
- 268 | }
- |
- 269 | #[derive(ValueEnum, Clone)]
- 270 | pub enum Encoding {
- 271 | Utf8,
- 272 | Utf16LE,
- 273 | Utf16BE,
- 274 | }
- |
- 275 | #[derive(Args)]
- 276 | #[command(alias = "t")]
- 277 | struct Test {
- 278 | /// Only run corpus test cases whose name matches the given regex
- 279 | #[arg(long, short)]
- 280 | pub include: Option,
- 281 | /// Only run corpus test cases whose name does not match the given regex
- 282 | #[arg(long, short)]
- 283 | pub exclude: Option,
- 284 | /// Only run corpus test cases from a given filename
- 285 | #[arg(long)]
- 286 | pub file_name: Option,
- 287 | /// The path to the tree-sitter grammar directory, implies --rebuild
- 288 | #[arg(long, short = 'p', conflicts_with = "rebuild")]
- 289 | pub grammar_path: Option,
- 290 | /// The path to the parser's dynamic library
- 291 | #[arg(long, short = 'l')]
- 292 | pub lib_path: Option,
- 293 | /// If `--lib-path` is used, the name of the language used to extract the
- 294 | /// library's language function
- 295 | #[arg(long)]
- 296 | pub lang_name: Option,
- 297 | /// Update all syntax trees in corpus files with current parser output
- 298 | #[arg(long, short)]
- 299 | pub update: bool,
- 300 | /// Show parsing debug log
- 301 | #[arg(long, short = 'd')]
- 302 | pub debug: bool,
- 303 | /// Compile a parser in debug mode
- 304 | #[arg(long, short = '0')]
- 305 | pub debug_build: bool,
- 306 | /// Produce the log.html file with debug graphs
- 307 | #[arg(long, short = 'D')]
- 308 | pub debug_graph: bool,
- 309 | /// Compile parsers to Wasm instead of native dynamic libraries
- 310 | #[arg(long)]
- 311 | pub wasm: bool,
- 312 | /// Open `log.html` in the default browser, if `--debug-graph` is supplied
- 313 | #[arg(long)]
- 314 | pub open_log: bool,
- 315 | /// The path to an alternative config.json file
- 316 | #[arg(long)]
- 317 | pub config_path: Option,
- 318 | /// Force showing fields in test diffs
- 319 | #[arg(long)]
- 320 | pub show_fields: bool,
- 321 | /// Show parsing statistics
- 322 | #[arg(long)]
- 323 | pub stat: Option,
- 324 | /// Force rebuild the parser
- 325 | #[arg(short, long)]
- 326 | pub rebuild: bool,
- 327 | /// Show only the pass-fail overview tree
- 328 | #[arg(long)]
- 329 | pub overview_only: bool,
- 330 | }
- |
- 331 | #[derive(Args)]
- 332 | #[command(alias = "publish")]
- 333 | /// Display or increment the version of a grammar
- 334 | struct Version {
- 335 | /// The version to bump to
- 336 | #[arg(
- 337 | conflicts_with = "bump",
- 338 | long_help = "\
- 339 | The version to bump to\n\
- 340 | \n\
- 341 | Examples:\n \
- 342 | tree-sitter version: display the current version\n \
- 343 | tree-sitter version : bump to specified version\n \
- 344 | tree-sitter version --bump : automatic bump"
- 345 | )]
- 346 | pub version: Option,
- 347 | /// The path to the tree-sitter grammar directory
- 348 | #[arg(long, short = 'p')]
- 349 | pub grammar_path: Option,
- 350 | /// Automatically bump from the current version
- 351 | #[arg(long, value_enum, conflicts_with = "version")]
- 352 | pub bump: Option,
- 353 | }
- |
- 354 | #[derive(Args)]
- 355 | #[command(alias = "f")]
- 356 | struct Fuzz {
- 357 | /// List of test names to skip
- 358 | #[arg(long, short)]
- 359 | pub skip: Option>,
- 360 | /// Subdirectory to the language
- 361 | #[arg(long)]
- 362 | pub subdir: Option,
- 363 | /// The path to the tree-sitter grammar directory, implies --rebuild
- 364 | #[arg(long, short = 'p', conflicts_with = "rebuild")]
- 365 | pub grammar_path: Option,
- 366 | /// The path to the parser's dynamic library
- 367 | #[arg(long)]
- 368 | pub lib_path: Option,
- 369 | /// If `--lib-path` is used, the name of the language used to extract the
- 370 | /// library's language function
- 371 | #[arg(long)]
- 372 | pub lang_name: Option,
- 373 | /// Maximum number of edits to perform per fuzz test
- 374 | #[arg(long)]
- 375 | pub edits: Option,
- 376 | /// Number of fuzzing iterations to run per test
- 377 | #[arg(long)]
- 378 | pub iterations: Option,
- 379 | /// Only fuzz corpus test cases whose name matches the given regex
- 380 | #[arg(long, short)]
- 381 | pub include: Option,
- 382 | /// Only fuzz corpus test cases whose name does not match the given regex
- 383 | #[arg(long, short)]
- 384 | pub exclude: Option,
- 385 | /// Enable logging of graphs and input
- 386 | #[arg(long)]
- 387 | pub log_graphs: bool,
- 388 | /// Enable parser logging
- 389 | #[arg(long, short)]
- 390 | pub log: bool,
- 391 | /// Force rebuild the parser
- 392 | #[arg(short, long)]
- 393 | pub rebuild: bool,
- 394 | }
- |
- 395 | #[derive(Args)]
- 396 | #[command(alias = "q")]
- 397 | struct Query {
- 398 | /// Path to a file with queries
- 399 | #[arg(index = 1, required = true)]
- 400 | query_path: PathBuf,
- 401 | /// The path to the tree-sitter grammar directory, implies --rebuild
- 402 | #[arg(long, short = 'p', conflicts_with = "rebuild")]
- 403 | pub grammar_path: Option,
- 404 | /// The path to the parser's dynamic library
- 405 | #[arg(long, short = 'l')]
- 406 | pub lib_path: Option,
- 407 | /// If `--lib-path` is used, the name of the language used to extract the
- 408 | /// library's language function
- 409 | #[arg(long)]
- 410 | pub lang_name: Option,
- 411 | /// Measure execution time
- 412 | #[arg(long, short)]
- 413 | pub time: bool,
- 414 | /// Suppress main output
- 415 | #[arg(long, short)]
- 416 | pub quiet: bool,
- 417 | /// The path to a file with paths to source file(s)
- 418 | #[arg(long = "paths")]
- 419 | pub paths_file: Option,
- 420 | /// The source file(s) to use
- 421 | #[arg(index = 2, num_args=1..)]
- 422 | pub paths: Option>,
- 423 | /// The range of byte offsets in which the query will be executed
- 424 | #[arg(long)]
- 425 | pub byte_range: Option,
- 426 | /// The range of rows in which the query will be executed
- 427 | #[arg(long)]
- 428 | pub row_range: Option,
- 429 | /// Select a language by the scope instead of a file extension
- 430 | #[arg(long)]
- 431 | pub scope: Option,
- 432 | /// Order by captures instead of matches
- 433 | #[arg(long, short)]
- 434 | pub captures: bool,
- 435 | /// Whether to run query tests or not
- 436 | #[arg(long)]
- 437 | pub test: bool,
- 438 | /// The path to an alternative config.json file
- 439 | #[arg(long)]
- 440 | pub config_path: Option,
- 441 | /// Query the contents of a specific test
- 442 | #[arg(long, short = 'n')]
- 443 | #[clap(conflicts_with = "paths", conflicts_with = "paths_file")]
- 444 | pub test_number: Option,
- 445 | /// Force rebuild the parser
- 446 | #[arg(short, long)]
- 447 | pub rebuild: bool,
- 448 | }
- |
- 449 | #[derive(Args)]
- 450 | #[command(alias = "hi")]
- 451 | struct Highlight {
- 452 | /// Generate highlighting as an HTML document
- 453 | #[arg(long, short = 'H')]
- 454 | pub html: bool,
- 455 | /// When generating HTML, use css classes rather than inline styles
- 456 | #[arg(long)]
- 457 | pub css_classes: bool,
- 458 | /// Check that highlighting captures conform strictly to standards
- 459 | #[arg(long)]
- 460 | pub check: bool,
- 461 | /// The path to a file with captures
- 462 | #[arg(long)]
- 463 | pub captures_path: Option,
- 464 | /// The paths to files with queries
- 465 | #[arg(long, num_args = 1..)]
- 466 | pub query_paths: Option>,
- 467 | /// Select a language by the scope instead of a file extension
- 468 | #[arg(long)]
- 469 | pub scope: Option,
- 470 | /// Measure execution time
- 471 | #[arg(long, short)]
- 472 | pub time: bool,
- 473 | /// Suppress main output
- 474 | #[arg(long, short)]
- 475 | pub quiet: bool,
- 476 | /// The path to a file with paths to source file(s)
- 477 | #[arg(long = "paths")]
- 478 | pub paths_file: Option,
- 479 | /// The source file(s) to use
- 480 | #[arg(num_args = 1..)]
- 481 | pub paths: Option>,
- 482 | /// The path to the tree-sitter grammar directory, implies --rebuild
- 483 | #[arg(long, short = 'p', conflicts_with = "rebuild")]
- 484 | pub grammar_path: Option,
- 485 | /// The path to an alternative config.json file
- 486 | #[arg(long)]
- 487 | pub config_path: Option,
- 488 | /// Highlight the contents of a specific test
- 489 | #[arg(long, short = 'n')]
- 490 | #[clap(conflicts_with = "paths", conflicts_with = "paths_file")]
- 491 | pub test_number: Option,
- 492 | /// Force rebuild the parser
- 493 | #[arg(short, long)]
- 494 | pub rebuild: bool,
- 495 | }
- |
- 496 | #[derive(Args)]
- 497 | struct Tags {
- 498 | /// Select a language by the scope instead of a file extension
- 499 | #[arg(long)]
- 500 | pub scope: Option,
- 501 | /// Measure execution time
- 502 | #[arg(long, short)]
- 503 | pub time: bool,
- 504 | /// Suppress main output
- 505 | #[arg(long, short)]
- 506 | pub quiet: bool,
- 507 | /// The path to a file with paths to source file(s)
- 508 | #[arg(long = "paths")]
- 509 | pub paths_file: Option,
- 510 | /// The source file(s) to use
- 511 | #[arg(num_args = 1..)]
- 512 | pub paths: Option>,
- 513 | /// The path to the tree-sitter grammar directory, implies --rebuild
- 514 | #[arg(long, short = 'p', conflicts_with = "rebuild")]
- 515 | pub grammar_path: Option,
- 516 | /// The path to an alternative config.json file
- 517 | #[arg(long)]
- 518 | pub config_path: Option,
- 519 | /// Generate tags from the contents of a specific test
- 520 | #[arg(long, short = 'n')]
- 521 | #[clap(conflicts_with = "paths", conflicts_with = "paths_file")]
- 522 | pub test_number: Option,
- 523 | /// Force rebuild the parser
- 524 | #[arg(short, long)]
- 525 | pub rebuild: bool,
- 526 | }
- |
- 527 | #[derive(Args)]
- 528 | #[command(alias = "play", alias = "pg", alias = "web-ui")]
- 529 | struct Playground {
- 530 | /// Don't open in default browser
- 531 | #[arg(long, short)]
- 532 | pub quiet: bool,
- 533 | /// Path to the directory containing the grammar and Wasm files
- 534 | #[arg(long)]
- 535 | pub grammar_path: Option,
- 536 | /// Export playground files to specified directory instead of serving them
- 537 | #[arg(long, short)]
- 538 | pub export: Option,
- 539 | }
- |
- 540 | #[derive(Args)]
- 541 | #[command(alias = "langs")]
- 542 | struct DumpLanguages {
- 543 | /// The path to an alternative config.json file
- 544 | #[arg(long)]
- 545 | pub config_path: Option,
- 546 | }
- |
- 547 | #[derive(Args)]
- 548 | #[command(alias = "comp")]
- 549 | struct Complete {
- 550 | /// The shell to generate completions for
- 551 | #[arg(long, short, value_enum)]
- 552 | pub shell: Shell,
- 553 | }
- |
- 554 | #[derive(ValueEnum, Clone)]
- 555 | pub enum Shell {
- 556 | Bash,
- 557 | Elvish,
- 558 | Fish,
- 559 | PowerShell,
- 560 | Zsh,
- 561 | Nushell,
- 562 | }
- |
- 563 | impl InitConfig {
- 564 | fn run() -> Result<()> {
- 565 | if let Ok(Some(config_path)) = Config::find_config_file() {
- 566 | return Err(anyhow!(
- 567 | "Remove your existing config file first: {}",
- 568 | config_path.to_string_lossy()
- 569 | ));
- 570 | }
- 571 | let mut config = Config::initial()?;
- 572 | config.add(tree_sitter_loader::Config::initial())?;
- 573 | config.add(tree_sitter_cli::highlight::ThemeConfig::default())?;
- 574 | config.save()?;
- 575 | info!(
- 576 | "Saved initial configuration to {}",
- 577 | config.location.display()
- 578 | );
- 579 | Ok(())
- 580 | }
- 581 | }
- |
- 582 | impl Init {
- 583 | fn run(self, current_dir: &Path) -> Result<()> {
- 584 | let configure_json = !current_dir.join("tree-sitter.json").exists();
- |
- 585 | let (language_name, json_config_opts) = if configure_json {
- 586 | let mut opts = JsonConfigOpts::default();
- |
- 587 | let name = || {
- 588 | Input::::with_theme(&ColorfulTheme::default())
- 589 | .with_prompt("Parser name")
- 590 | .validate_with(|input: &String| {
- 591 | if input.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_') {
- 592 | Ok(())
- 593 | } else {
- 594 | Err("The name must be lowercase and contain only letters, digits, and underscores")
- 595 | }
- 596 | })
- 597 | .interact_text()
- 598 | };
- |
- 599 | let camelcase_name = |name: &str| {
- 600 | Input::::with_theme(&ColorfulTheme::default())
- 601 | .with_prompt("CamelCase name")
- 602 | .default(name.to_upper_camel_case())
- 603 | .validate_with(|input: &String| {
- 604 | if input
- 605 | .chars()
- 606 | .all(|c| c.is_ascii_alphabetic() || c.is_ascii_digit() || c == '_')
- 607 | {
- 608 | Ok(())
- 609 | } else {
- 610 | Err("The name must contain only letters, digits, and underscores")
- 611 | }
- 612 | })
- 613 | .interact_text()
- 614 | };
- |
- 615 | let title = |name: &str| {
- 616 | Input::::with_theme(&ColorfulTheme::default())
- 617 | .with_prompt("Title (human-readable name)")
- 618 | .default(name.to_upper_camel_case())
- 619 | .interact_text()
- 620 | };
- |
- 621 | let description = |name: &str| {
- 622 | Input::::with_theme(&ColorfulTheme::default())
- 623 | .with_prompt("Description")
- 624 | .default(format!(
- 625 | "{} grammar for tree-sitter",
- 626 | name.to_upper_camel_case()
- 627 | ))
- 628 | .show_default(false)
- 629 | .allow_empty(true)
- 630 | .interact_text()
- 631 | };
- |
- 632 | let repository = |name: &str| {
- 633 | Input::::with_theme(&ColorfulTheme::default())
- 634 | .with_prompt("Repository URL")
- 635 | .allow_empty(true)
- 636 | .default(format!("https://github.com/tree-sitter/tree-sitter-{name}"))
- 637 | .show_default(false)
- 638 | .interact_text()
- 639 | };
- |
- 640 | let funding = || {
- 641 | Input::::with_theme(&ColorfulTheme::default())
- 642 | .with_prompt("Funding URL")
- 643 | .allow_empty(true)
- 644 | .interact_text()
- 645 | .map(|e| Some(e.trim().to_string()))
- 646 | };
- |
- 647 | let scope = |name: &str| {
- 648 | Input::::with_theme(&ColorfulTheme::default())
- 649 | .with_prompt("TextMate scope")
- 650 | .default(format!("source.{name}"))
- 651 | .validate_with(|input: &String| {
- 652 | if input.starts_with("source.") || input.starts_with("text.") {
- 653 | Ok(())
- 654 | } else {
- 655 | Err("The scope must start with 'source.' or 'text.'")
- 656 | }
- 657 | })
- 658 | .interact_text()
- 659 | };
- |
- 660 | let file_types = |name: &str| {
- 661 | Input::::with_theme(&ColorfulTheme::default())
- 662 | .with_prompt("File types (space-separated)")
- 663 | .default(name.to_string())
- 664 | .interact_text()
- 665 | .map(|ft| {
- 666 | let mut set = HashSet::new();
- 667 | for ext in ft.split(' ') {
- 668 | let ext = ext.trim();
- 669 | if !ext.is_empty() {
- 670 | set.insert(ext.to_string());
- 671 | }
- 672 | }
- 673 | set.into_iter().collect::>()
- 674 | })
- 675 | };
- |
- 676 | let initial_version = || {
- 677 | Input::::with_theme(&ColorfulTheme::default())
- 678 | .with_prompt("Version")
- 679 | .default(SemverVersion::new(0, 1, 0))
- 680 | .interact_text()
- 681 | };
- |
- 682 | let license = || {
- 683 | Input::::with_theme(&ColorfulTheme::default())
- 684 | .with_prompt("License")
- 685 | .default("MIT".to_string())
- 686 | .allow_empty(true)
- 687 | .interact()
- 688 | };
- |
- 689 | let author = || {
- 690 | Input::::with_theme(&ColorfulTheme::default())
- 691 | .with_prompt("Author name")
- 692 | .interact_text()
- 693 | };
- |
- 694 | let email = || {
- 695 | Input::::with_theme(&ColorfulTheme::default())
- 696 | .with_prompt("Author email")
- 697 | .allow_empty(true)
- 698 | .interact_text()
- 699 | .map(|e| (!e.trim().is_empty()).then_some(e))
- 700 | };
- |
- 701 | let url = || {
- 702 | Input::::with_theme(&ColorfulTheme::default())
- 703 | .with_prompt("Author URL")
- 704 | .allow_empty(true)
- 705 | .interact_text()
- 706 | .map(|e| Some(e.trim().to_string()))
- 707 | };
- |
- 708 | let bindings = || {
- 709 | let languages = Bindings::default().languages();
- |
- 710 | let enabled = MultiSelect::new()
- 711 | .with_prompt("Bindings")
- 712 | .items_checked(&languages)
- 713 | .interact()?
- 714 | .into_iter()
- 715 | .map(|i| languages[i].0);
- |
- 716 | let out = Bindings::with_enabled_languages(enabled)
- 717 | .expect("unexpected unsupported language");
- 718 | anyhow::Ok(out)
- 719 | };
- |
- 720 | let choices = [
- 721 | "name",
- 722 | "camelcase",
- 723 | "title",
- 724 | "description",
- 725 | "repository",
- 726 | "funding",
- 727 | "scope",
- 728 | "file_types",
- 729 | "version",
- 730 | "license",
- 731 | "author",
- 732 | "email",
- 733 | "url",
- 734 | "bindings",
- 735 | "exit",
- 736 | ];
- |
- 737 | macro_rules! set_choice {
- 738 | ($choice:expr) => {
- 739 | match $choice {
- 740 | "name" => opts.name = name()?,
- 741 | "camelcase" => opts.camelcase = camelcase_name(&opts.name)?,
- 742 | "title" => opts.title = title(&opts.name)?,
- 743 | "description" => opts.description = description(&opts.name)?,
- 744 | "repository" => opts.repository = Some(repository(&opts.name)?),
- 745 | "funding" => opts.funding = funding()?,
- 746 | "scope" => opts.scope = scope(&opts.name)?,
- 747 | "file_types" => opts.file_types = file_types(&opts.name)?,
- 748 | "version" => opts.version = initial_version()?,
- 749 | "license" => opts.license = license()?,
- 750 | "author" => opts.author = author()?,
- 751 | "email" => opts.email = email()?,
- 752 | "url" => opts.url = url()?,
- 753 | "bindings" => opts.bindings = bindings()?,
- 754 | "exit" => break,
- 755 | _ => unreachable!(),
- 756 | }
- 757 | };
- 758 | }
- |
- 759 | // Initial configuration
- 760 | for choice in choices.iter().take(choices.len() - 1) {
- 761 | set_choice!(*choice);
- 762 | }
- |
- 763 | // Loop for editing the configuration
- 764 | loop {
- 765 | info!(
- 766 | "Your current configuration:\n{}",
- 767 | serde_json::to_string_pretty(&opts)?
- 768 | );
- |
- 769 | if Confirm::with_theme(&ColorfulTheme::default())
- 770 | .with_prompt("Does the config above look correct?")
- 771 | .interact()?
- 772 | {
- 773 | break;
- 774 | }
- |
- 775 | let idx = FuzzySelect::with_theme(&ColorfulTheme::default())
- 776 | .with_prompt("Which field would you like to change?")
- 777 | .items(&choices)
- 778 | .interact()?;
- |
- 779 | set_choice!(choices[idx]);
- 780 | }
- |
- 781 | (opts.name.clone(), Some(opts))
- 782 | } else {
- 783 | let mut json = serde_json::from_str::(
- 784 | &fs::read_to_string(current_dir.join("tree-sitter.json"))
- 785 | .with_context(|| "Failed to read tree-sitter.json")?,
- 786 | )?;
- 787 | (json.grammars.swap_remove(0).name, None)
- 788 | };
- |
- 789 | generate_grammar_files(
- 790 | current_dir,
- 791 | &language_name,
- 792 | self.update,
- 793 | json_config_opts.as_ref(),
- 794 | )?;
- |
- 795 | Ok(())
- 796 | }
- 797 | }
- |
- 798 | impl Generate {
- 799 | fn run(self, mut loader: loader::Loader, current_dir: &Path) -> Result<()> {
- 800 | if self.log {
- 801 | logger::enable_debug();
- 802 | }
- 803 | let abi_version =
- 804 | self.abi_version
- 805 | .as_ref()
- 806 | .map_or(DEFAULT_GENERATE_ABI_VERSION, |version| {
- 807 | if version == "latest" {
- 808 | tree_sitter::LANGUAGE_VERSION
- 809 | } else {
- 810 | version.parse().expect("invalid abi version flag")
- 811 | }
- 812 | });
- 813 | if self.build {
- 814 | warn!("--build is deprecated, use --emit=lib instead");
- 815 | }
- |
- 816 | if let Err(err) = tree_sitter_generate::generate_parser_in_directory(
- 817 | current_dir,
- 818 | self.output.as_deref(),
- 819 | self.grammar_path.as_deref(),
- 820 | abi_version,
- 821 | self.report_states_for_rule.as_deref(),
- 822 | self.js_runtime.as_deref(),
- 823 | self.emit != GenerationEmit::Json,
- 824 | if self.disable_optimizations {
- 825 | OptLevel::empty()
- 826 | } else {
- 827 | OptLevel::default()
- 828 | },
- 829 | ) {
- 830 | if self.json {
- 831 | eprintln!("{}", serde_json::to_string_pretty(&err)?);
- 832 | // Exit early to prevent errors from being printed a second time in the caller
- 833 | std::process::exit(1);
- 834 | } else {
- 835 | // Removes extra context associated with the error
- 836 | Err(anyhow!(err.to_string())).with_context(|| "Error when generating parser")?;
- 837 | }
- 838 | }
- 839 | if self.emit == GenerationEmit::Lib || self.build {
- 840 | if let Some(path) = self.libdir {
- 841 | loader = loader::Loader::with_parser_lib_path(path);
- 842 | }
- 843 | loader.debug_build(self.debug_build);
- 844 | loader.languages_at_path(current_dir)?;
- 845 | }
- 846 | Ok(())
- 847 | }
- 848 | }
- |
- 849 | impl Build {
- 850 | fn run(self, mut loader: loader::Loader, current_dir: &Path) -> Result<()> {
- 851 | let grammar_path = current_dir.join(self.path.unwrap_or_default());
- |
- 852 | loader.debug_build(self.debug);
- |
- 853 | if self.wasm {
- 854 | let output_path = self.output.map(|path| current_dir.join(path));
- 855 | wasm::compile_language_to_wasm(&loader, &grammar_path, current_dir, output_path)?;
- 856 | } else {
- 857 | let output_path = if let Some(ref path) = self.output {
- 858 | let path = Path::new(path);
- 859 | if path.is_absolute() {
- 860 | path.to_path_buf()
- 861 | } else {
- 862 | current_dir.join(path)
- 863 | }
- 864 | } else {
- 865 | let file_name = grammar_path
- 866 | .file_stem()
- 867 | .unwrap()
- 868 | .to_str()
- 869 | .unwrap()
- 870 | .strip_prefix("tree-sitter-")
- 871 | .unwrap_or("parser");
- 872 | current_dir
- 873 | .join(file_name)
- 874 | .with_extension(env::consts::DLL_EXTENSION)
- 875 | };
- |
- 876 | let flags: &[&str] = match (self.reuse_allocator, self.debug) {
- 877 | (true, true) => &["TREE_SITTER_REUSE_ALLOCATOR", "TREE_SITTER_DEBUG"],
- 878 | (true, false) => &["TREE_SITTER_REUSE_ALLOCATOR"],
- 879 | (false, true) => &["TREE_SITTER_DEBUG"],
- 880 | (false, false) => &[],
- 881 | };
- |
- 882 | loader.force_rebuild(true);
- |
- 883 | let config = Config::load(None)?;
- 884 | let loader_config = config.get()?;
- 885 | loader.find_all_languages(&loader_config).unwrap();
- 886 | loader
- 887 | .compile_parser_at_path(&grammar_path, output_path, flags)
- 888 | .unwrap();
- 889 | }
- 890 | Ok(())
- 891 | }
- 892 | }
- |
- 893 | impl Parse {
- 894 | fn run(self, mut loader: loader::Loader, current_dir: &Path) -> Result<()> {
- 895 | let config = Config::load(self.config_path)?;
- 896 | let color = env::var("NO_COLOR").map_or(true, |v| v != "1");
- 897 | let output = if self.output_dot {
- 898 | ParseOutput::Dot
- 899 | } else if self.output_xml {
- 900 | ParseOutput::Xml
- 901 | } else if self.output_cst {
- 902 | ParseOutput::Cst
- 903 | } else if self.quiet || self.json {
- 904 | ParseOutput::Quiet
- 905 | } else {
- 906 | ParseOutput::Normal
- 907 | };
- |
- 908 | let parse_theme = if color {
- 909 | config
- 910 | .get::()
- 911 | .with_context(|| "Failed to parse CST theme")?
- 912 | .parse_theme
- 913 | .unwrap_or_default()
- 914 | .into()
- 915 | } else {
- 916 | ParseTheme::empty()
- 917 | };
- |
- 918 | let encoding = self.encoding.map(|e| match e {
- 919 | Encoding::Utf8 => ffi::TSInputEncodingUTF8,
- 920 | Encoding::Utf16LE => ffi::TSInputEncodingUTF16LE,
- 921 | Encoding::Utf16BE => ffi::TSInputEncodingUTF16BE,
- 922 | });
- |
- 923 | let time = self.time;
- 924 | let edits = self.edits.unwrap_or_default();
- 925 | let cancellation_flag = util::cancel_on_signal();
- 926 | let mut parser = Parser::new();
- |
- 927 | loader.debug_build(self.debug_build);
- 928 | loader.force_rebuild(self.rebuild || self.grammar_path.is_some());
- |
- 929 | #[cfg(feature = "wasm")]
- 930 | if self.wasm {
- 931 | let engine = tree_sitter::wasmtime::Engine::default();
- 932 | parser
- 933 | .set_wasm_store(tree_sitter::WasmStore::new(&engine).unwrap())
- 934 | .unwrap();
- 935 | loader.use_wasm(&engine);
- 936 | }
- |
- 937 | let timeout = self.timeout.unwrap_or_default();
- |
- 938 | let mut has_error = false;
- 939 | let loader_config = config.get()?;
- 940 | loader.find_all_languages(&loader_config)?;
- |
- 941 | let should_track_stats = self.stat;
- 942 | let mut stats = parse::ParseStats::default();
- 943 | let debug: ParseDebugType = match self.debug {
- 944 | None => ParseDebugType::Quiet,
- 945 | Some(None) => ParseDebugType::Normal,
- 946 | Some(Some(specifier)) => specifier,
- 947 | };
- |
- 948 | let mut options = ParseFileOptions {
- 949 | edits: &edits
- 950 | .iter()
- 951 | .map(std::string::String::as_str)
- 952 | .collect::
