2022-04-28 11:53:59 -06:00
|
|
|
use std::{
|
|
|
|
io::prelude::*,
|
|
|
|
path::{Path, PathBuf},
|
2023-07-14 13:44:08 -06:00
|
|
|
str::FromStr,
|
2022-04-28 11:53:59 -06:00
|
|
|
};
|
2021-03-10 14:24:08 -07:00
|
|
|
|
2023-07-14 13:44:08 -06:00
|
|
|
use atuin_common::record::HostId;
|
2022-04-28 11:53:59 -06:00
|
|
|
use chrono::{prelude::*, Utc};
|
2022-12-18 11:26:09 -07:00
|
|
|
use clap::ValueEnum;
|
2022-03-17 15:26:57 -06:00
|
|
|
use config::{Config, Environment, File as ConfigFile, FileFormat};
|
2021-11-17 04:50:34 -07:00
|
|
|
use eyre::{eyre, Context, Result};
|
2022-04-28 11:53:59 -06:00
|
|
|
use fs_err::{create_dir_all, File};
|
2021-04-13 12:14:07 -06:00
|
|
|
use parse_duration::parse;
|
2023-02-14 00:14:05 -07:00
|
|
|
use regex::RegexSet;
|
2022-10-14 03:59:21 -06:00
|
|
|
use semver::Version;
|
2022-04-28 11:53:59 -06:00
|
|
|
use serde::Deserialize;
|
2023-07-14 13:44:08 -06:00
|
|
|
use uuid::Uuid;
|
2021-03-10 14:24:08 -07:00
|
|
|
|
2021-04-13 12:14:07 -06:00
|
|
|
pub const HISTORY_PAGE_SIZE: i64 = 100;
|
2022-10-14 03:59:21 -06:00
|
|
|
pub const LAST_SYNC_FILENAME: &str = "last_sync_time";
|
|
|
|
pub const LAST_VERSION_CHECK_FILENAME: &str = "last_version_check_time";
|
|
|
|
pub const LATEST_VERSION_FILENAME: &str = "latest_version";
|
2023-06-14 14:18:24 -06:00
|
|
|
pub const HOST_ID_FILENAME: &str = "host_id";
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2023-03-19 14:49:57 -06:00
|
|
|
#[derive(Clone, Debug, Deserialize, Copy, ValueEnum, PartialEq)]
|
2021-05-09 01:33:56 -06:00
|
|
|
pub enum SearchMode {
|
|
|
|
#[serde(rename = "prefix")]
|
|
|
|
Prefix,
|
|
|
|
|
|
|
|
#[serde(rename = "fulltext")]
|
2023-03-09 02:13:31 -07:00
|
|
|
#[clap(aliases = &["fulltext"])]
|
2021-05-09 01:33:56 -06:00
|
|
|
FullText,
|
2021-06-01 01:38:19 -06:00
|
|
|
|
|
|
|
#[serde(rename = "fuzzy")]
|
|
|
|
Fuzzy,
|
2023-03-19 14:49:57 -06:00
|
|
|
|
|
|
|
#[serde(rename = "skim")]
|
|
|
|
Skim,
|
2021-05-09 01:33:56 -06:00
|
|
|
}
|
|
|
|
|
2023-03-22 10:16:59 -06:00
|
|
|
impl SearchMode {
|
|
|
|
pub fn as_str(&self) -> &'static str {
|
|
|
|
match self {
|
|
|
|
SearchMode::Prefix => "PREFIX",
|
|
|
|
SearchMode::FullText => "FULLTXT",
|
|
|
|
SearchMode::Fuzzy => "FUZZY",
|
|
|
|
SearchMode::Skim => "SKIM",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub fn next(&self, settings: &Settings) -> Self {
|
|
|
|
match self {
|
|
|
|
SearchMode::Prefix => SearchMode::FullText,
|
2023-03-26 08:47:38 -06:00
|
|
|
// if the user is using skim, we go to skim
|
|
|
|
SearchMode::FullText if settings.search_mode == SearchMode::Skim => SearchMode::Skim,
|
|
|
|
// otherwise fuzzy.
|
|
|
|
SearchMode::FullText => SearchMode::Fuzzy,
|
|
|
|
SearchMode::Fuzzy | SearchMode::Skim => SearchMode::Prefix,
|
2023-03-22 10:16:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-18 11:26:09 -07:00
|
|
|
#[derive(Clone, Debug, Deserialize, Copy, PartialEq, Eq, ValueEnum)]
|
2022-04-22 14:05:02 -06:00
|
|
|
pub enum FilterMode {
|
|
|
|
#[serde(rename = "global")]
|
2022-09-11 09:24:16 -06:00
|
|
|
Global = 0,
|
2022-04-22 14:05:02 -06:00
|
|
|
|
|
|
|
#[serde(rename = "host")]
|
2022-09-11 09:24:16 -06:00
|
|
|
Host = 1,
|
2022-04-22 14:05:02 -06:00
|
|
|
|
|
|
|
#[serde(rename = "session")]
|
2022-09-11 09:24:16 -06:00
|
|
|
Session = 2,
|
2022-04-22 14:05:02 -06:00
|
|
|
|
|
|
|
#[serde(rename = "directory")]
|
2022-09-11 09:24:16 -06:00
|
|
|
Directory = 3,
|
2023-07-14 13:58:20 -06:00
|
|
|
|
|
|
|
#[serde(rename = "workspace")]
|
|
|
|
Workspace = 4,
|
2022-09-11 09:24:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl FilterMode {
|
|
|
|
pub fn as_str(&self) -> &'static str {
|
|
|
|
match self {
|
|
|
|
FilterMode::Global => "GLOBAL",
|
|
|
|
FilterMode::Host => "HOST",
|
|
|
|
FilterMode::Session => "SESSION",
|
|
|
|
FilterMode::Directory => "DIRECTORY",
|
2023-07-14 13:58:20 -06:00
|
|
|
FilterMode::Workspace => "WORKSPACE",
|
2022-09-11 09:24:16 -06:00
|
|
|
}
|
|
|
|
}
|
2022-04-22 14:05:02 -06:00
|
|
|
}
|
|
|
|
|
2022-11-06 01:34:14 -06:00
|
|
|
#[derive(Clone, Debug, Deserialize, Copy)]
|
|
|
|
pub enum ExitMode {
|
|
|
|
#[serde(rename = "return-original")]
|
|
|
|
ReturnOriginal,
|
|
|
|
|
|
|
|
#[serde(rename = "return-query")]
|
|
|
|
ReturnQuery,
|
|
|
|
}
|
|
|
|
|
2021-05-09 04:39:39 -06:00
|
|
|
// FIXME: Can use upstream Dialect enum if https://github.com/stevedonovan/chrono-english/pull/16 is merged
|
2022-10-21 13:21:14 -06:00
|
|
|
// FIXME: Above PR was merged, but dependency was changed to interim (fork of chrono-english) in the ... interim
|
2021-05-09 04:39:39 -06:00
|
|
|
#[derive(Clone, Debug, Deserialize, Copy)]
|
|
|
|
pub enum Dialect {
|
|
|
|
#[serde(rename = "us")]
|
|
|
|
Us,
|
|
|
|
|
|
|
|
#[serde(rename = "uk")]
|
|
|
|
Uk,
|
|
|
|
}
|
|
|
|
|
2022-10-21 13:21:14 -06:00
|
|
|
impl From<Dialect> for interim::Dialect {
|
|
|
|
fn from(d: Dialect) -> interim::Dialect {
|
2021-05-09 04:39:39 -06:00
|
|
|
match d {
|
2022-10-21 13:21:14 -06:00
|
|
|
Dialect::Uk => interim::Dialect::Uk,
|
|
|
|
Dialect::Us => interim::Dialect::Us,
|
2021-05-09 04:39:39 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-04 21:59:01 -06:00
|
|
|
#[derive(Clone, Debug, Deserialize, Copy)]
|
|
|
|
pub enum Style {
|
|
|
|
#[serde(rename = "auto")]
|
|
|
|
Auto,
|
|
|
|
|
|
|
|
#[serde(rename = "full")]
|
|
|
|
Full,
|
|
|
|
|
|
|
|
#[serde(rename = "compact")]
|
|
|
|
Compact,
|
|
|
|
}
|
|
|
|
|
2023-03-05 11:49:09 -07:00
|
|
|
#[derive(Clone, Debug, Deserialize, Copy)]
|
|
|
|
pub enum WordJumpMode {
|
|
|
|
#[serde(rename = "emacs")]
|
|
|
|
Emacs,
|
|
|
|
|
|
|
|
#[serde(rename = "subl")]
|
|
|
|
Subl,
|
|
|
|
}
|
|
|
|
|
2021-04-13 12:14:07 -06:00
|
|
|
#[derive(Clone, Debug, Deserialize)]
|
2021-04-20 14:53:07 -06:00
|
|
|
pub struct Settings {
|
2021-05-09 04:39:39 -06:00
|
|
|
pub dialect: Dialect,
|
2022-04-04 21:59:01 -06:00
|
|
|
pub style: Style,
|
2021-04-13 12:14:07 -06:00
|
|
|
pub auto_sync: bool,
|
2022-10-14 03:59:21 -06:00
|
|
|
pub update_check: bool,
|
2021-04-09 05:40:21 -06:00
|
|
|
pub sync_address: String,
|
|
|
|
pub sync_frequency: String,
|
|
|
|
pub db_path: String,
|
2023-06-14 14:18:24 -06:00
|
|
|
pub record_store_path: String,
|
2021-04-13 12:14:07 -06:00
|
|
|
pub key_path: String,
|
|
|
|
pub session_path: String,
|
2021-05-09 01:33:56 -06:00
|
|
|
pub search_mode: SearchMode,
|
2022-04-22 14:05:02 -06:00
|
|
|
pub filter_mode: FilterMode,
|
2023-03-05 11:43:03 -07:00
|
|
|
pub filter_mode_shell_up_key_binding: Option<FilterMode>,
|
2022-12-18 11:26:09 -07:00
|
|
|
pub shell_up_key_binding: bool,
|
2023-03-25 11:27:20 -06:00
|
|
|
pub inline_height: u16,
|
2023-05-21 10:42:44 -06:00
|
|
|
pub invert: bool,
|
2023-03-05 11:36:35 -07:00
|
|
|
pub show_preview: bool,
|
2023-05-22 05:10:11 -06:00
|
|
|
pub show_help: bool,
|
2022-11-06 01:34:14 -06:00
|
|
|
pub exit_mode: ExitMode,
|
2023-03-05 11:49:09 -07:00
|
|
|
pub word_jump_mode: WordJumpMode,
|
|
|
|
pub word_chars: String,
|
|
|
|
pub scroll_context_lines: usize,
|
2023-02-14 00:14:05 -07:00
|
|
|
#[serde(with = "serde_regex", default = "RegexSet::empty")]
|
|
|
|
pub history_filter: RegexSet,
|
2023-05-01 20:55:54 -06:00
|
|
|
#[serde(with = "serde_regex", default = "RegexSet::empty")]
|
|
|
|
pub cwd_filter: RegexSet,
|
2023-07-14 13:58:20 -06:00
|
|
|
pub workspaces: bool,
|
2023-07-27 02:10:40 -06:00
|
|
|
pub ctrl_n_shortcuts: bool,
|
2023-02-14 00:14:05 -07:00
|
|
|
|
2021-04-13 12:14:07 -06:00
|
|
|
// This is automatically loaded when settings is created. Do not set in
|
|
|
|
// config! Keep secrets and settings apart.
|
|
|
|
pub session_token: String,
|
2021-03-10 14:24:08 -07:00
|
|
|
}
|
|
|
|
|
2021-04-20 14:53:07 -06:00
|
|
|
impl Settings {
|
2022-10-14 03:59:21 -06:00
|
|
|
fn save_to_data_dir(filename: &str, value: &str) -> Result<()> {
|
2021-04-25 11:21:52 -06:00
|
|
|
let data_dir = atuin_common::utils::data_dir();
|
|
|
|
let data_dir = data_dir.as_path();
|
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
let path = data_dir.join(filename);
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
fs_err::write(path, value)?;
|
2021-04-13 12:14:07 -06:00
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
fn read_from_data_dir(filename: &str) -> Option<String> {
|
2021-04-25 11:21:52 -06:00
|
|
|
let data_dir = atuin_common::utils::data_dir();
|
|
|
|
let data_dir = data_dir.as_path();
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
let path = data_dir.join(filename);
|
|
|
|
|
|
|
|
if !path.exists() {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let value = fs_err::read_to_string(path);
|
|
|
|
|
|
|
|
value.ok()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn save_current_time(filename: &str) -> Result<()> {
|
|
|
|
Settings::save_to_data_dir(filename, Utc::now().to_rfc3339().as_str())?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn load_time_from_file(filename: &str) -> Result<chrono::DateTime<Utc>> {
|
|
|
|
let value = Settings::read_from_data_dir(filename);
|
|
|
|
|
|
|
|
match value {
|
|
|
|
Some(v) => {
|
|
|
|
let time = chrono::DateTime::parse_from_rfc3339(v.as_str())?;
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
Ok(time.with_timezone(&Utc))
|
|
|
|
}
|
|
|
|
None => Ok(Utc.ymd(1970, 1, 1).and_hms(0, 0, 0)),
|
2021-04-13 12:14:07 -06:00
|
|
|
}
|
2022-10-14 03:59:21 -06:00
|
|
|
}
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
pub fn save_sync_time() -> Result<()> {
|
|
|
|
Settings::save_current_time(LAST_SYNC_FILENAME)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn save_version_check_time() -> Result<()> {
|
|
|
|
Settings::save_current_time(LAST_VERSION_CHECK_FILENAME)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn last_sync() -> Result<chrono::DateTime<Utc>> {
|
|
|
|
Settings::load_time_from_file(LAST_SYNC_FILENAME)
|
|
|
|
}
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
pub fn last_version_check() -> Result<chrono::DateTime<Utc>> {
|
|
|
|
Settings::load_time_from_file(LAST_VERSION_CHECK_FILENAME)
|
2021-04-13 12:14:07 -06:00
|
|
|
}
|
|
|
|
|
2023-07-14 13:44:08 -06:00
|
|
|
pub fn host_id() -> Option<HostId> {
|
2023-06-14 14:18:24 -06:00
|
|
|
let id = Settings::read_from_data_dir(HOST_ID_FILENAME);
|
|
|
|
|
2023-07-14 13:44:08 -06:00
|
|
|
if let Some(id) = id {
|
|
|
|
let parsed =
|
|
|
|
Uuid::from_str(id.as_str()).expect("failed to parse host ID from local directory");
|
|
|
|
return Some(HostId(parsed));
|
2023-06-14 14:18:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
let uuid = atuin_common::utils::uuid_v7();
|
|
|
|
|
|
|
|
Settings::save_to_data_dir(HOST_ID_FILENAME, uuid.as_simple().to_string().as_ref())
|
|
|
|
.expect("Could not write host ID to data dir");
|
|
|
|
|
2023-07-14 13:44:08 -06:00
|
|
|
Some(HostId(uuid))
|
2023-06-14 14:18:24 -06:00
|
|
|
}
|
|
|
|
|
2021-04-13 12:14:07 -06:00
|
|
|
pub fn should_sync(&self) -> Result<bool> {
|
2023-03-06 15:46:03 -07:00
|
|
|
if !self.auto_sync || !PathBuf::from(self.session_path.as_str()).exists() {
|
2021-04-13 12:14:07 -06:00
|
|
|
return Ok(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
match parse(self.sync_frequency.as_str()) {
|
|
|
|
Ok(d) => {
|
|
|
|
let d = chrono::Duration::from_std(d).unwrap();
|
2021-04-20 14:53:07 -06:00
|
|
|
Ok(Utc::now() - Settings::last_sync()? >= d)
|
2021-04-13 12:14:07 -06:00
|
|
|
}
|
|
|
|
Err(e) => Err(eyre!("failed to check sync: {}", e)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-14 03:59:21 -06:00
|
|
|
fn needs_update_check(&self) -> Result<bool> {
|
|
|
|
let last_check = Settings::last_version_check()?;
|
|
|
|
let diff = Utc::now() - last_check;
|
|
|
|
|
|
|
|
// Check a max of once per hour
|
|
|
|
Ok(diff.num_hours() >= 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn latest_version(&self) -> Result<Version> {
|
|
|
|
// Default to the current version, and if that doesn't parse, a version so high it's unlikely to ever
|
|
|
|
// suggest upgrading.
|
|
|
|
let current =
|
|
|
|
Version::parse(env!("CARGO_PKG_VERSION")).unwrap_or(Version::new(100000, 0, 0));
|
|
|
|
|
|
|
|
if !self.needs_update_check()? {
|
|
|
|
// Worst case, we don't want Atuin to fail to start because something funky is going on with
|
|
|
|
// version checking.
|
|
|
|
let version = match Settings::read_from_data_dir(LATEST_VERSION_FILENAME) {
|
|
|
|
Some(v) => Version::parse(&v).unwrap_or(current),
|
|
|
|
None => current,
|
|
|
|
};
|
|
|
|
|
|
|
|
return Ok(version);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(feature = "sync")]
|
|
|
|
let latest = crate::api_client::latest_version().await.unwrap_or(current);
|
|
|
|
|
|
|
|
#[cfg(not(feature = "sync"))]
|
|
|
|
let latest = current;
|
|
|
|
|
|
|
|
Settings::save_version_check_time()?;
|
|
|
|
Settings::save_to_data_dir(LATEST_VERSION_FILENAME, latest.to_string().as_str())?;
|
|
|
|
|
|
|
|
Ok(latest)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return Some(latest version) if an update is needed. Otherwise, none.
|
|
|
|
pub async fn needs_update(&self) -> Option<Version> {
|
|
|
|
if !self.update_check {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let current =
|
|
|
|
Version::parse(env!("CARGO_PKG_VERSION")).unwrap_or(Version::new(100000, 0, 0));
|
|
|
|
|
|
|
|
let latest = self.latest_version().await;
|
|
|
|
|
|
|
|
if latest.is_err() {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let latest = latest.unwrap();
|
|
|
|
|
|
|
|
if latest > current {
|
|
|
|
return Some(latest);
|
|
|
|
}
|
|
|
|
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
2021-03-10 14:24:08 -07:00
|
|
|
pub fn new() -> Result<Self> {
|
2021-04-25 11:21:52 -06:00
|
|
|
let config_dir = atuin_common::utils::config_dir();
|
|
|
|
|
|
|
|
let data_dir = atuin_common::utils::data_dir();
|
2021-03-10 14:24:08 -07:00
|
|
|
|
2021-11-17 04:50:34 -07:00
|
|
|
create_dir_all(&config_dir)
|
2023-02-06 04:59:01 -07:00
|
|
|
.wrap_err_with(|| format!("could not create dir {config_dir:?}"))?;
|
|
|
|
create_dir_all(&data_dir).wrap_err_with(|| format!("could not create dir {data_dir:?}"))?;
|
2021-03-10 14:24:08 -07:00
|
|
|
|
2021-04-21 11:13:51 -06:00
|
|
|
let mut config_file = if let Ok(p) = std::env::var("ATUIN_CONFIG_DIR") {
|
2021-04-13 15:31:41 -06:00
|
|
|
PathBuf::from(p)
|
|
|
|
} else {
|
|
|
|
let mut config_file = PathBuf::new();
|
|
|
|
config_file.push(config_dir);
|
|
|
|
config_file
|
|
|
|
};
|
2021-03-10 14:24:08 -07:00
|
|
|
|
2021-04-21 11:13:51 -06:00
|
|
|
config_file.push("config.toml");
|
|
|
|
|
2021-04-25 11:21:52 -06:00
|
|
|
let db_path = data_dir.join("history.db");
|
2023-06-14 14:18:24 -06:00
|
|
|
let record_store_path = data_dir.join("records.db");
|
|
|
|
|
2021-04-25 11:21:52 -06:00
|
|
|
let key_path = data_dir.join("key");
|
|
|
|
let session_path = data_dir.join("session");
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-03-17 15:26:57 -06:00
|
|
|
let mut config_builder = Config::builder()
|
|
|
|
.set_default("db_path", db_path.to_str())?
|
2023-06-14 14:18:24 -06:00
|
|
|
.set_default("record_store_path", record_store_path.to_str())?
|
2022-03-17 15:26:57 -06:00
|
|
|
.set_default("key_path", key_path.to_str())?
|
|
|
|
.set_default("session_path", session_path.to_str())?
|
|
|
|
.set_default("dialect", "us")?
|
|
|
|
.set_default("auto_sync", true)?
|
2022-10-14 03:59:21 -06:00
|
|
|
.set_default("update_check", true)?
|
2022-03-17 15:26:57 -06:00
|
|
|
.set_default("sync_address", "https://api.atuin.sh")?
|
2023-04-05 02:32:26 -06:00
|
|
|
.set_default("sync_frequency", "1h")?
|
2022-11-02 13:35:11 -06:00
|
|
|
.set_default("search_mode", "fuzzy")?
|
2022-04-22 14:05:02 -06:00
|
|
|
.set_default("filter_mode", "global")?
|
2023-04-05 02:32:26 -06:00
|
|
|
.set_default("style", "auto")?
|
2023-03-25 11:27:20 -06:00
|
|
|
.set_default("inline_height", 0)?
|
2023-03-05 11:36:35 -07:00
|
|
|
.set_default("show_preview", false)?
|
2023-05-22 05:10:11 -06:00
|
|
|
.set_default("show_help", true)?
|
2023-05-21 10:42:44 -06:00
|
|
|
.set_default("invert", false)?
|
2022-11-06 01:34:14 -06:00
|
|
|
.set_default("exit_mode", "return-original")?
|
2023-03-05 11:49:09 -07:00
|
|
|
.set_default("word_jump_mode", "emacs")?
|
|
|
|
.set_default(
|
|
|
|
"word_chars",
|
|
|
|
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
|
|
|
|
)?
|
|
|
|
.set_default("scroll_context_lines", 1)?
|
2023-04-05 02:32:26 -06:00
|
|
|
.set_default("shell_up_key_binding", false)?
|
|
|
|
.set_default("session_token", "")?
|
2023-07-14 13:58:20 -06:00
|
|
|
.set_default("workspaces", false)?
|
2023-07-27 02:10:40 -06:00
|
|
|
.set_default("ctrl_n_shortcuts", false)?
|
2022-04-12 14:47:07 -06:00
|
|
|
.add_source(
|
|
|
|
Environment::with_prefix("atuin")
|
|
|
|
.prefix_separator("_")
|
|
|
|
.separator("__"),
|
|
|
|
);
|
2022-03-17 15:26:57 -06:00
|
|
|
|
|
|
|
config_builder = if config_file.exists() {
|
|
|
|
config_builder.add_source(ConfigFile::new(
|
|
|
|
config_file.to_str().unwrap(),
|
|
|
|
FileFormat::Toml,
|
|
|
|
))
|
2021-04-13 12:14:07 -06:00
|
|
|
} else {
|
|
|
|
let example_config = include_bytes!("../config.toml");
|
2021-11-17 04:50:34 -07:00
|
|
|
let mut file = File::create(config_file).wrap_err("could not create config file")?;
|
|
|
|
file.write_all(example_config)
|
|
|
|
.wrap_err("could not write default config file")?;
|
2021-03-10 14:24:08 -07:00
|
|
|
|
2022-03-17 15:26:57 -06:00
|
|
|
config_builder
|
|
|
|
};
|
|
|
|
|
|
|
|
let config = config_builder.build()?;
|
|
|
|
let mut settings: Settings = config
|
|
|
|
.try_deserialize()
|
|
|
|
.map_err(|e| eyre!("failed to deserialize: {}", e))?;
|
2021-04-13 15:31:41 -06:00
|
|
|
|
2021-03-10 14:24:08 -07:00
|
|
|
// all paths should be expanded
|
2022-03-17 15:26:57 -06:00
|
|
|
let db_path = settings.db_path;
|
|
|
|
let db_path = shellexpand::full(&db_path)?;
|
|
|
|
settings.db_path = db_path.to_string();
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-03-17 15:26:57 -06:00
|
|
|
let key_path = settings.key_path;
|
|
|
|
let key_path = shellexpand::full(&key_path)?;
|
|
|
|
settings.key_path = key_path.to_string();
|
2021-04-13 12:14:07 -06:00
|
|
|
|
2022-03-17 15:26:57 -06:00
|
|
|
let session_path = settings.session_path;
|
|
|
|
let session_path = shellexpand::full(&session_path)?;
|
|
|
|
settings.session_path = session_path.to_string();
|
2021-04-13 12:14:07 -06:00
|
|
|
|
|
|
|
// Finally, set the auth token
|
|
|
|
if Path::new(session_path.to_string().as_str()).exists() {
|
2022-04-13 11:08:49 -06:00
|
|
|
let token = fs_err::read_to_string(session_path.to_string())?;
|
2022-03-17 15:26:57 -06:00
|
|
|
settings.session_token = token.trim().to_string();
|
2021-04-13 12:14:07 -06:00
|
|
|
} else {
|
2022-03-17 15:26:57 -06:00
|
|
|
settings.session_token = String::from("not logged in");
|
2021-04-13 12:14:07 -06:00
|
|
|
}
|
2021-03-10 14:24:08 -07:00
|
|
|
|
2022-03-17 15:26:57 -06:00
|
|
|
Ok(settings)
|
2021-03-10 14:24:08 -07:00
|
|
|
}
|
|
|
|
}
|