bendns' repos / helix
Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'helix-loader/src/lib.rs')
-rw-r--r--helix-loader/src/lib.rs307
1 files changed, 98 insertions, 209 deletions
diff --git a/helix-loader/src/lib.rs b/helix-loader/src/lib.rs
index 705e016b..767bff7a 100644
--- a/helix-loader/src/lib.rs
+++ b/helix-loader/src/lib.rs
@@ -1,122 +1,35 @@
pub mod config;
pub mod grammar;
-use helix_stdx::{env::current_working_dir, path};
-
use etcetera::base_strategy::{choose_base_strategy, BaseStrategy};
-use std::path::{Path, PathBuf};
-
-pub const VERSION_AND_GIT_HASH: &str = env!("VERSION_AND_GIT_HASH");
-
-static RUNTIME_DIRS: once_cell::sync::Lazy<Vec<PathBuf>> =
- once_cell::sync::Lazy::new(prioritize_runtime_dirs);
-static CONFIG_FILE: once_cell::sync::OnceCell<PathBuf> = once_cell::sync::OnceCell::new();
+pub static RUNTIME_DIR: once_cell::sync::Lazy<std::path::PathBuf> =
+ once_cell::sync::Lazy::new(runtime_dir);
-static LOG_FILE: once_cell::sync::OnceCell<PathBuf> = once_cell::sync::OnceCell::new();
-
-pub fn initialize_config_file(specified_file: Option<PathBuf>) {
- let config_file = specified_file.unwrap_or_else(default_config_file);
- ensure_parent_dir(&config_file);
- CONFIG_FILE.set(config_file).ok();
-}
-
-pub fn initialize_log_file(specified_file: Option<PathBuf>) {
- let log_file = specified_file.unwrap_or_else(default_log_file);
- ensure_parent_dir(&log_file);
- LOG_FILE.set(log_file).ok();
-}
+pub fn runtime_dir() -> std::path::PathBuf {
+ if let Ok(dir) = std::env::var("HELIX_RUNTIME") {
+ return dir.into();
+ }
-/// A list of runtime directories from highest to lowest priority
-///
-/// The priority is:
-///
-/// 1. sibling directory to `CARGO_MANIFEST_DIR` (if environment variable is set)
-/// 2. subdirectory of user config directory (always included)
-/// 3. `HELIX_RUNTIME` (if environment variable is set)
-/// 4. `HELIX_DEFAULT_RUNTIME` (if environment variable is set *at build time*)
-/// 5. subdirectory of path to helix executable (always included)
-///
-/// Postcondition: returns at least two paths (they might not exist).
-fn prioritize_runtime_dirs() -> Vec<PathBuf> {
const RT_DIR: &str = "runtime";
- // Adding higher priority first
- let mut rt_dirs = Vec::new();
- if let Ok(dir) = std::env::var("CARGO_MANIFEST_DIR") {
- // this is the directory of the crate being run by cargo, we need the workspace path so we take the parent
- let path = PathBuf::from(dir).parent().unwrap().join(RT_DIR);
- log::debug!("runtime dir: {}", path.to_string_lossy());
- rt_dirs.push(path);
+ let conf_dir = config_dir().join(RT_DIR);
+ if conf_dir.exists() {
+ return conf_dir;
}
- let conf_rt_dir = config_dir().join(RT_DIR);
- rt_dirs.push(conf_rt_dir);
-
- if let Ok(dir) = std::env::var("HELIX_RUNTIME") {
- let dir = path::expand_tilde(Path::new(&dir));
- rt_dirs.push(path::normalize(dir));
+ if let Ok(dir) = std::env::var("CARGO_MANIFEST_DIR") {
+ // this is the directory of the crate being run by cargo, we need the workspace path so we take the parent
+ return std::path::PathBuf::from(dir).parent().unwrap().join(RT_DIR);
}
- // If this variable is set during build time, it will always be included
- // in the lookup list. This allows downstream packagers to set a fallback
- // directory to a location that is conventional on their distro so that they
- // need not resort to a wrapper script or a global environment variable.
- if let Some(dir) = std::option_env!("HELIX_DEFAULT_RUNTIME") {
- rt_dirs.push(dir.into());
- }
// fallback to location of the executable being run
- // canonicalize the path in case the executable is symlinked
- let exe_rt_dir = std::env::current_exe()
+ std::env::current_exe()
.ok()
- .and_then(|path| std::fs::canonicalize(path).ok())
.and_then(|path| path.parent().map(|path| path.to_path_buf().join(RT_DIR)))
- .unwrap();
- rt_dirs.push(exe_rt_dir);
- rt_dirs.push(PathBuf::from("/usr/lib/helix/runtime/"));
- rt_dirs
-}
-
-/// Runtime directories ordered from highest to lowest priority
-///
-/// All directories should be checked when looking for files.
-///
-/// Postcondition: returns at least one path (it might not exist).
-pub fn runtime_dirs() -> &'static [PathBuf] {
- &RUNTIME_DIRS
-}
-
-/// Find file with path relative to runtime directory
-///
-/// `rel_path` should be the relative path from within the `runtime/` directory.
-/// The valid runtime directories are searched in priority order and the first
-/// file found to exist is returned, otherwise None.
-fn find_runtime_file(rel_path: &Path) -> Option<PathBuf> {
- RUNTIME_DIRS.iter().find_map(|rt_dir| {
- let path = rt_dir.join(rel_path);
- if path.exists() {
- Some(path)
- } else {
- None
- }
- })
+ .unwrap()
}
-/// Find file with path relative to runtime directory
-///
-/// `rel_path` should be the relative path from within the `runtime/` directory.
-/// The valid runtime directories are searched in priority order and the first
-/// file found to exist is returned, otherwise the path to the final attempt
-/// that failed.
-pub fn runtime_file(rel_path: impl AsRef<Path>) -> PathBuf {
- find_runtime_file(rel_path.as_ref()).unwrap_or_else(|| {
- RUNTIME_DIRS
- .last()
- .map(|dir| dir.join(rel_path))
- .unwrap_or_default()
- })
-}
-
-pub fn config_dir() -> PathBuf {
+pub fn config_dir() -> std::path::PathBuf {
// TODO: allow env var override
let strategy = choose_base_strategy().expect("Unable to find the config directory!");
let mut path = strategy.config_dir();
@@ -124,67 +37,85 @@ pub fn config_dir() -> PathBuf {
path
}
-pub fn cache_dir() -> PathBuf {
+pub fn local_config_dirs() -> Vec<std::path::PathBuf> {
+ let directories = find_root_impl(None, &[".helix".to_string()])
+ .into_iter()
+ .map(|path| path.join(".helix"))
+ .collect();
+ log::debug!("Located configuration folders: {:?}", directories);
+ directories
+}
+
+pub fn cache_dir() -> std::path::PathBuf {
// TODO: allow env var override
- let strategy = choose_base_strategy().expect("Unable to find the cache directory!");
+ let strategy = choose_base_strategy().expect("Unable to find the config directory!");
let mut path = strategy.cache_dir();
path.push("helix");
path
}
-pub fn config_file() -> PathBuf {
- CONFIG_FILE.get().map(|path| path.to_path_buf()).unwrap()
+pub fn config_file() -> std::path::PathBuf {
+ config_dir().join("config.toml")
}
-pub fn log_file() -> PathBuf {
- LOG_FILE.get().map(|path| path.to_path_buf()).unwrap()
+pub fn lang_config_file() -> std::path::PathBuf {
+ config_dir().join("languages.toml")
}
-pub fn workspace_config_file() -> PathBuf {
- find_workspace().0.join(".helix").join("config.toml")
+pub fn log_file() -> std::path::PathBuf {
+ cache_dir().join("helix.log")
}
-pub fn lang_config_file() -> PathBuf {
- config_dir().join("languages.toml")
-}
+pub fn find_root_impl(root: Option<&str>, root_markers: &[String]) -> Vec<std::path::PathBuf> {
+ let current_dir = std::env::current_dir().expect("unable to determine current directory");
+ let mut directories = Vec::new();
-pub fn default_log_file() -> PathBuf {
- cache_dir().join("helix.log")
+ let root = match root {
+ Some(root) => {
+ let root = std::path::Path::new(root);
+ if root.is_absolute() {
+ root.to_path_buf()
+ } else {
+ current_dir.join(root)
+ }
+ }
+ None => current_dir,
+ };
+
+ for ancestor in root.ancestors() {
+ // don't go higher than repo
+ if ancestor.join(".git").is_dir() {
+ // Use workspace if detected from marker
+ directories.push(ancestor.to_path_buf());
+ break;
+ } else if root_markers
+ .iter()
+ .any(|marker| ancestor.join(marker).exists())
+ {
+ directories.push(ancestor.to_path_buf());
+ }
+ }
+ directories
}
/// Merge two TOML documents, merging values from `right` onto `left`
///
-/// `merge_depth` sets the nesting depth up to which values are merged instead
-/// of overridden.
-///
-/// When a table exists in both `left` and `right`, the merged table consists of
-/// all keys in `left`'s table unioned with all keys in `right` with the values
-/// of `right` being merged recursively onto values of `left`.
-///
-/// `crate::merge_toml_values(a, b, 3)` combines, for example:
+/// When an array exists in both `left` and `right`, `right`'s array is
+/// used. When a table exists in both `left` and `right`, the merged table
+/// consists of all keys in `left`'s table unioned with all keys in `right`
+/// with the values of `right` being merged recursively onto values of
+/// `left`.
///
-/// b:
-/// ```toml
-/// [[language]]
-/// name = "toml"
-/// language-server = { command = "taplo", args = ["lsp", "stdio"] }
-/// ```
-/// a:
-/// ```toml
-/// [[language]]
-/// language-server = { command = "/usr/bin/taplo" }
-/// ```
-///
-/// into:
-/// ```toml
-/// [[language]]
-/// name = "toml"
-/// language-server = { command = "/usr/bin/taplo" }
-/// ```
-///
-/// thus it overrides the third depth-level of b with values of a if they exist,
-/// but otherwise merges their values
-pub fn merge_toml_values(left: toml::Value, right: toml::Value, merge_depth: usize) -> toml::Value {
+/// `merge_toplevel_arrays` controls whether a top-level array in the TOML
+/// document is merged instead of overridden. This is useful for TOML
+/// documents that use a top-level array of values like the `languages.toml`,
+/// where one usually wants to override or add to the array instead of
+/// replacing it altogether.
+pub fn merge_toml_values(
+ left: toml::Value,
+ right: toml::Value,
+ merge_toplevel_arrays: bool,
+) -> toml::Value {
use toml::Value;
fn get_name(v: &Value) -> Option<&str> {
@@ -193,7 +124,12 @@ pub fn merge_toml_values(left: toml::Value, right: toml::Value, merge_depth: usi
match (left, right) {
(Value::Array(mut left_items), Value::Array(right_items)) => {
- if merge_depth > 0 {
+ // The top-level arrays should be merged but nested arrays should
+ // act as overrides. For the `languages.toml` config, this means
+ // that you can specify a sub-set of languages in an overriding
+ // `languages.toml` but that nested arrays like Language Server
+ // arguments are replaced instead of merged.
+ if merge_toplevel_arrays {
left_items.reserve(right_items.len());
for rvalue in right_items {
let lvalue = get_name(&rvalue)
@@ -202,7 +138,7 @@ pub fn merge_toml_values(left: toml::Value, right: toml::Value, merge_depth: usi
})
.map(|lpos| left_items.remove(lpos));
let mvalue = match lvalue {
- Some(lvalue) => merge_toml_values(lvalue, rvalue, merge_depth - 1),
+ Some(lvalue) => merge_toml_values(lvalue, rvalue, false),
None => rvalue,
};
left_items.push(mvalue);
@@ -213,71 +149,26 @@ pub fn merge_toml_values(left: toml::Value, right: toml::Value, merge_depth: usi
}
}
(Value::Table(mut left_map), Value::Table(right_map)) => {
- if merge_depth > 0 {
- for (rname, rvalue) in right_map {
- match left_map.remove(&rname) {
- Some(lvalue) => {
- let merged_value = merge_toml_values(lvalue, rvalue, merge_depth - 1);
- left_map.insert(rname, merged_value);
- }
- None => {
- left_map.insert(rname, rvalue);
- }
+ for (rname, rvalue) in right_map {
+ match left_map.remove(&rname) {
+ Some(lvalue) => {
+ let merged_value = merge_toml_values(lvalue, rvalue, merge_toplevel_arrays);
+ left_map.insert(rname, merged_value);
+ }
+ None => {
+ left_map.insert(rname, rvalue);
}
}
- Value::Table(left_map)
- } else {
- Value::Table(right_map)
}
+ Value::Table(left_map)
}
// Catch everything else we didn't handle, and use the right value
(_, value) => value,
}
}
-/// Finds the current workspace folder.
-/// Used as a ceiling dir for LSP root resolution, the filepicker and potentially as a future filewatching root
-///
-/// This function starts searching the FS upward from the CWD
-/// and returns the first directory that contains either `.git`, `.svn`, `.jj` or `.helix`.
-/// If no workspace was found returns (CWD, true).
-/// Otherwise (workspace, false) is returned
-pub fn find_workspace() -> (PathBuf, bool) {
- let current_dir = current_working_dir();
- find_workspace_in(current_dir)
-}
-
-pub fn find_workspace_in(dir: impl AsRef<Path>) -> (PathBuf, bool) {
- let dir = dir.as_ref();
- for ancestor in dir.ancestors() {
- if ancestor.join(".git").exists()
- || ancestor.join(".svn").exists()
- || ancestor.join(".jj").exists()
- || ancestor.join(".helix").exists()
- {
- return (ancestor.to_owned(), false);
- }
- }
-
- (dir.to_owned(), true)
-}
-
-fn default_config_file() -> PathBuf {
- config_dir().join("config.toml")
-}
-
-fn ensure_parent_dir(path: &Path) {
- if let Some(parent) = path.parent() {
- if !parent.exists() {
- std::fs::create_dir_all(parent).ok();
- }
- }
-}
-
#[cfg(test)]
mod merge_toml_tests {
- use std::str;
-
use super::merge_toml_values;
use toml::Value;
@@ -290,12 +181,11 @@ mod merge_toml_tests {
indent = { tab-width = 4, unit = " ", test = "aaa" }
"#;
- let base = include_bytes!("../../languages.toml");
- let base = str::from_utf8(base).expect("Couldn't parse built-in languages config");
- let base: Value = toml::from_str(base).expect("Couldn't parse built-in languages config");
+ let base: Value = toml::from_slice(include_bytes!("../../languages.toml"))
+ .expect("Couldn't parse built-in languages config");
let user: Value = toml::from_str(USER).unwrap();
- let merged = merge_toml_values(base, user, 3);
+ let merged = merge_toml_values(base, user, true);
let languages = merged.get("language").unwrap().as_array().unwrap();
let nix = languages
.iter()
@@ -324,12 +214,11 @@ mod merge_toml_tests {
language-server = { command = "deno", args = ["lsp"] }
"#;
- let base = include_bytes!("../../languages.toml");
- let base = str::from_utf8(base).expect("Couldn't parse built-in languages config");
- let base: Value = toml::from_str(base).expect("Couldn't parse built-in languages config");
+ let base: Value = toml::from_slice(include_bytes!("../../languages.toml"))
+ .expect("Couldn't parse built-in languages config");
let user: Value = toml::from_str(USER).unwrap();
- let merged = merge_toml_values(base, user, 3);
+ let merged = merge_toml_values(base, user, true);
let languages = merged.get("language").unwrap().as_array().unwrap();
let ts = languages
.iter()