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.rs251
1 files changed, 75 insertions, 176 deletions
diff --git a/helix-loader/src/lib.rs b/helix-loader/src/lib.rs
index 705e016b..80d44a82 100644
--- a/helix-loader/src/lib.rs
+++ b/helix-loader/src/lib.rs
@@ -1,119 +1,55 @@
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};
+use std::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);
+pub static RUNTIME_DIR: once_cell::sync::Lazy<PathBuf> = once_cell::sync::Lazy::new(runtime_dir);
static CONFIG_FILE: once_cell::sync::OnceCell<PathBuf> = once_cell::sync::OnceCell::new();
-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);
+ let config_file = specified_file.unwrap_or_else(|| {
+ let config_dir = config_dir();
+
+ if !config_dir.exists() {
+ std::fs::create_dir_all(&config_dir).ok();
+ }
+
+ config_dir.join("config.toml")
+ });
+
+ // We should only initialize this value once.
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() -> 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);
+ let path = std::path::PathBuf::from(dir).parent().unwrap().join(RT_DIR);
log::debug!("runtime dir: {}", path.to_string_lossy());
- rt_dirs.push(path);
+ return path;
}
- 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));
+ const RT_DIR: &str = "runtime";
+ let conf_dir = config_dir().join(RT_DIR);
+ if conf_dir.exists() {
+ return conf_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
- }
- })
-}
-
-/// 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()
- })
+ .unwrap()
}
pub fn config_dir() -> PathBuf {
@@ -124,66 +60,67 @@ pub fn config_dir() -> PathBuf {
path
}
+pub fn local_config_dirs() -> Vec<PathBuf> {
+ let directories = find_local_config_dirs()
+ .into_iter()
+ .map(|path| path.join(".helix"))
+ .collect();
+ log::debug!("Located configuration folders: {:?}", directories);
+ directories
+}
+
pub fn cache_dir() -> 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 log_file() -> PathBuf {
- LOG_FILE.get().map(|path| path.to_path_buf()).unwrap()
-}
-
-pub fn workspace_config_file() -> PathBuf {
- find_workspace().0.join(".helix").join("config.toml")
+ CONFIG_FILE
+ .get()
+ .map(|path| path.to_path_buf())
+ .unwrap_or_else(|| config_dir().join("config.toml"))
}
pub fn lang_config_file() -> PathBuf {
config_dir().join("languages.toml")
}
-pub fn default_log_file() -> PathBuf {
+pub fn log_file() -> PathBuf {
cache_dir().join("helix.log")
}
+pub fn find_local_config_dirs() -> Vec<PathBuf> {
+ let current_dir = std::env::current_dir().expect("unable to determine current directory");
+ let mut directories = Vec::new();
+
+ for ancestor in current_dir.ancestors() {
+ if ancestor.join(".git").exists() {
+ directories.push(ancestor.to_path_buf());
+ // Don't go higher than repo if we're in one
+ break;
+ } else if ancestor.join(".helix").is_dir() {
+ 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:
-///
-/// 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" }
-/// ```
+/// 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`.
///
-/// thus it overrides the third depth-level of b with values of a if they exist,
-/// but otherwise merges their values
+/// `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_depth: usize) -> toml::Value {
use toml::Value;
@@ -193,6 +130,11 @@ 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)) => {
+ // 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_depth > 0 {
left_items.reserve(right_items.len());
for rvalue in right_items {
@@ -235,49 +177,8 @@ pub fn merge_toml_values(left: toml::Value, right: toml::Value, merge_depth: usi
}
}
-/// 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,9 +191,8 @@ 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);
@@ -324,9 +224,8 @@ 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);