forked from extern/nushell
b2c5af457e
This improves incremental build time when working on what was previously the root package. For example, previously all plugins would be rebuilt with a change to `src/commands/classified/external.rs`, but now only `nu-cli` will have to be rebuilt (and anything that depends on it).
142 lines
3.6 KiB
Rust
142 lines
3.6 KiB
Rust
mod conf;
|
|
mod nuconfig;
|
|
|
|
#[cfg(test)]
|
|
pub mod tests;
|
|
|
|
pub(crate) use conf::Conf;
|
|
pub(crate) use nuconfig::NuConfig;
|
|
|
|
use crate::commands::from_toml::convert_toml_value_to_nu_value;
|
|
use crate::commands::to_toml::value_to_toml_value;
|
|
use crate::prelude::*;
|
|
use app_dirs::*;
|
|
use indexmap::IndexMap;
|
|
use log::trace;
|
|
use nu_errors::ShellError;
|
|
use nu_protocol::{Dictionary, ShellTypeName, UntaggedValue, Value};
|
|
use nu_source::Tag;
|
|
use std::fs::{self, OpenOptions};
|
|
use std::io;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
pub const APP_INFO: AppInfo = AppInfo {
|
|
name: "nu",
|
|
author: "nu shell developers",
|
|
};
|
|
|
|
pub fn config_path() -> Result<PathBuf, ShellError> {
|
|
app_path(AppDataType::UserConfig, "config")
|
|
}
|
|
|
|
pub fn default_path() -> Result<PathBuf, ShellError> {
|
|
default_path_for(&None)
|
|
}
|
|
|
|
pub fn default_path_for(file: &Option<PathBuf>) -> Result<PathBuf, ShellError> {
|
|
let filename = &mut config_path()?;
|
|
let filename = match file {
|
|
None => {
|
|
filename.push("config.toml");
|
|
filename
|
|
}
|
|
Some(file) => {
|
|
filename.push(file);
|
|
filename
|
|
}
|
|
};
|
|
|
|
Ok(filename.clone())
|
|
}
|
|
|
|
pub fn user_data() -> Result<PathBuf, ShellError> {
|
|
app_path(AppDataType::UserData, "user data")
|
|
}
|
|
|
|
pub fn app_path(app_data_type: AppDataType, display: &str) -> Result<PathBuf, ShellError> {
|
|
let path = app_root(app_data_type, &APP_INFO).map_err(|err| {
|
|
ShellError::untagged_runtime_error(&format!("Couldn't open {} path:\n{}", display, err))
|
|
})?;
|
|
|
|
Ok(path)
|
|
}
|
|
|
|
pub fn read(
|
|
tag: impl Into<Tag>,
|
|
at: &Option<PathBuf>,
|
|
) -> Result<IndexMap<String, Value>, ShellError> {
|
|
let filename = default_path()?;
|
|
|
|
let filename = match at {
|
|
None => filename,
|
|
Some(ref file) => file.clone(),
|
|
};
|
|
|
|
touch(&filename)?;
|
|
|
|
trace!("config file = {}", filename.display());
|
|
|
|
let tag = tag.into();
|
|
let contents = fs::read_to_string(filename)
|
|
.map(|v| v.tagged(&tag))
|
|
.map_err(|err| {
|
|
ShellError::labeled_error(
|
|
&format!("Couldn't read config file:\n{}", err),
|
|
"file name",
|
|
&tag,
|
|
)
|
|
})?;
|
|
|
|
let parsed: toml::Value = toml::from_str(&contents).map_err(|err| {
|
|
ShellError::labeled_error(
|
|
&format!("Couldn't parse config file:\n{}", err),
|
|
"file name",
|
|
&tag,
|
|
)
|
|
})?;
|
|
|
|
let value = convert_toml_value_to_nu_value(&parsed, tag);
|
|
let tag = value.tag();
|
|
match value.value {
|
|
UntaggedValue::Row(Dictionary { entries }) => Ok(entries),
|
|
other => Err(ShellError::type_error(
|
|
"Dictionary",
|
|
other.type_name().spanned(tag.span),
|
|
)),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn config(tag: impl Into<Tag>) -> Result<IndexMap<String, Value>, ShellError> {
|
|
read(tag, &None)
|
|
}
|
|
|
|
pub fn write(config: &IndexMap<String, Value>, at: &Option<PathBuf>) -> Result<(), ShellError> {
|
|
let filename = &mut default_path()?;
|
|
let filename = match at {
|
|
None => filename,
|
|
Some(file) => {
|
|
filename.pop();
|
|
filename.push(file);
|
|
filename
|
|
}
|
|
};
|
|
|
|
let contents = value_to_toml_value(
|
|
&UntaggedValue::Row(Dictionary::new(config.clone())).into_untagged_value(),
|
|
)?;
|
|
|
|
let contents = toml::to_string(&contents)?;
|
|
|
|
fs::write(&filename, &contents)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// A simple implementation of `% touch path` (ignores existing files)
|
|
fn touch(path: &Path) -> io::Result<()> {
|
|
match OpenOptions::new().create(true).write(true).open(path) {
|
|
Ok(_) => Ok(()),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|