-pub mod config;

-use helix_stdx::{env::current_working_dir, path};

-

-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();

-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();

-}

-/// 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> {

- // 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_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 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());

- }

- // canonicalize the path in case the executable is symlinked

- let exe_rt_dir = std::env::current_exe()

- .and_then(|path| std::fs::canonicalize(path).ok())

- .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()

- })

-}

-

-pub fn config_dir() -> PathBuf {

-pub fn cache_dir() -> PathBuf {

- let strategy = choose_base_strategy().expect("Unable to find the cache directory!");

-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")

-pub fn lang_config_file() -> PathBuf {

- config_dir().join("languages.toml")

-pub fn default_log_file() -> PathBuf {

- cache_dir().join("helix.log")

-/// 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" }

-/// ```

-///

-/// 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 {

- if merge_depth > 0 {

- left_items.reserve(right_items.len());

- for rvalue in right_items {

- let lvalue = get_name(&rvalue)

- .and_then(|rname| {

- left_items.iter().position(|v| get_name(v) == Some(rname))

- })

- .map(|lpos| left_items.remove(lpos));

- let mvalue = match lvalue {

- Some(lvalue) => merge_toml_values(lvalue, rvalue, merge_depth - 1),

- None => rvalue,

- };

- left_items.push(mvalue);

- }

- Value::Array(left_items)

- } else {

- Value::Array(right_items)

- 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);

- }

- Value::Table(left_map)

- } else {

- Value::Table(right_map)

-/// 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();

- }

- }

-}

-

- use std::str;

-

- use toml::Value;

- fn language_toml_map_merges() {

- const USER: &str = r#"

- name = "nix"

- test = "bbb"

- 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 merged = merge_toml_values(base, user, 3);

-

- #[test]

- fn language_toml_nested_array_merges() {

- const USER: &str = r#"

- [[language]]

- name = "typescript"

- 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 user: Value = toml::from_str(USER).unwrap();

-

- let merged = merge_toml_values(base, user, 3);

- let languages = merged.get("language").unwrap().as_array().unwrap();

- let ts = languages

- .iter()

- .find(|v| v.get("name").unwrap().as_str().unwrap() == "typescript")

- .unwrap();

- assert_eq!(

- ts.get("language-server")

- .unwrap()

- .get("args")

- .unwrap()

- .as_array()

- .unwrap(),

- &vec![Value::String("lsp".into())]

- )

- }