use std::ffi::OsString;
use std::sync::Arc;
use std::{backtrace::Backtrace, env, panic};
use ::gitu::cli::Args;
use ::gitu::config::{self, ColorMode, Config, EnabledFeatures, RendererGitConfig};
use ::gitu::{error::Error, term, Res};
use clap::{CommandFactory, FromArgMatches};
use crate::git_config::GitConfig;
const ABOUT: &str = "An interactive git client and pager, with delta as its renderer.
Based on gitu by altsem (https://github.com/altsem/gitu), a git client inspired \
by Magit, embedded via the delta-gitu fork (https://github.com/dandavison/gitu).";
const DELTA_OPTIONS_GO_IN_GIT_CONFIG: &str = "delta's own options cannot be given with --tui. \
Set them in git config's [delta] section, or turn delta features on and off in the TUI with S, L and H.";
pub fn main(args: impl IntoIterator<Item = OsString>) -> i32 {
let args = match parse(args) {
Ok(args) => args,
Err(err) => {
let message = error_message(&err);
if err.use_stderr() {
eprint!("{message}");
} else {
print!("{message}");
}
return err.exit_code();
}
};
match run(&args) {
Ok(code) => code,
Err(err) => {
eprintln!("Error: {err}");
2
}
}
}
fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Args, clap::Error> {
let matches = Args::command()
.name("delta --tui")
.bin_name("delta --tui")
.about(ABOUT)
.try_get_matches_from(std::iter::once("delta --tui".into()).chain(args))?;
Args::from_arg_matches(&matches)
}
fn error_message(err: &clap::Error) -> String {
let mut message = err.render().to_string();
if err.kind() == clap::error::ErrorKind::UnknownArgument {
message.push_str(&format!("\n{DELTA_OPTIONS_GO_IN_GIT_CONFIG}\n"));
}
message
}
pub fn misplaced_tui(args: impl IntoIterator<Item = OsString>) -> Option<String> {
let mut args = args.into_iter().skip(1);
if args.next().is_some_and(|arg| is_tui(&arg)) {
return None;
}
args.any(|arg| is_tui(&arg)).then(|| {
format!("--tui must be delta's first argument, as in `delta --tui`. {DELTA_OPTIONS_GO_IN_GIT_CONFIG}")
})
}
pub fn is_tui(arg: &OsString) -> bool {
arg == "--tui" || arg == "--gitu"
}
fn run(args: &Args) -> Res<i32> {
if args.version {
println!("delta {}", env!("CARGO_PKG_VERSION"));
return Ok(0);
}
if args.log {
simple_logging::log_to_file(::gitu::LOG_FILE_NAME, log::LevelFilter::Debug)
.map_err(Error::OpenLogFile)?;
}
let mut config = config::init_config(args.config.clone())?;
let delta = env::current_exe().map_err(Error::Term)?;
use_delta_as_renderer(&mut config, &delta.to_string_lossy());
let env = crate::env::DeltaEnv::init();
let opt = delta_options(&env, GitConfig::try_create(&env));
tell_gitu_about_delta(&mut config, &opt);
if let Some(mode) = opt.computed.terminal_color_mode {
let mode = match mode {
crate::color::ColorMode::Dark => "dark",
crate::color::ColorMode::Light => "light",
};
env::set_var(crate::env::DELTA_TERMINAL_COLOR_MODE, mode);
}
let config = Arc::new(config);
let hook_config = config.clone();
panic::set_hook(Box::new(move |panic_info| {
if let Err(err) = term::backend().reset_term(&hook_config) {
eprintln!("Error: {err}");
}
eprintln!("{panic_info}");
eprintln!("trace: \n{}", Backtrace::force_capture());
}));
::gitu::run(config, args, &mut term::backend())
}
fn use_delta_as_renderer(config: &mut Config, delta: &str) {
let diff = &mut config.general.diff_renderer;
diff.command = vec![delta.into()];
}
fn tell_gitu_about_delta(config: &mut Config, opt: &crate::cli::Opt) {
let renderer = &mut config.general.diff_renderer;
renderer.color_mode = Some(color_mode(opt));
renderer.enabled_features = EnabledFeatures::new(|dir| {
let env = crate::env::DeltaEnv {
current_dir: Some(dir.to_path_buf()),
..crate::env::DeltaEnv::init()
};
enabled_features(&env, GitConfig::try_create(&env))
});
renderer.git_config = RendererGitConfig::new(|dir| crate::git_config::open(Some(dir)).1);
}
fn enabled_features(env: &crate::env::DeltaEnv, git_config: Option<GitConfig>) -> Vec<String> {
let env = crate::env::DeltaEnv {
columns: Some(u32::MAX.to_string()),
..env.clone()
};
let args = ["delta", "--detect-dark-light=never"];
let opt = crate::cli::Opt::from_iter_and_git_config(&env, args, git_config);
opt.features
.as_deref()
.unwrap_or_default()
.split_whitespace()
.filter(|feature| opt.computed.features_named_by_user.contains(*feature))
.map(String::from)
.collect()
}
fn delta_options(env: &crate::env::DeltaEnv, git_config: Option<GitConfig>) -> crate::cli::Opt {
crate::cli::Opt::from_iter_and_git_config(env, ["delta"], git_config)
}
fn color_mode(opt: &crate::cli::Opt) -> ColorMode {
match opt.computed.color_mode {
crate::color::ColorMode::Dark => ColorMode::Dark,
crate::color::ColorMode::Light => ColorMode::Light,
}
}
#[cfg(test)]
mod tests {
use std::fs;
use std::path::PathBuf;
use super::*;
const DELTA: &str = "/path to/delta";
fn os_args(args: &[&str]) -> Vec<OsString> {
args.iter().map(OsString::from).collect()
}
#[test]
fn test_deltas_options_given_to_delta_tui_say_where_they_go() {
let err = parse(os_args(&["--side-by-side"])).unwrap_err();
let message = error_message(&err);
assert!(message.contains("'--side-by-side'"), "{}", message);
assert!(message.contains("[delta]"), "{}", message);
}
#[test]
fn test_tui_after_other_arguments_says_it_must_come_first() {
let message = misplaced_tui(os_args(&["delta", "--side-by-side", "--tui"])).unwrap();
assert!(message.contains("first"), "{}", message);
assert!(message.contains("[delta]"), "{}", message);
assert_eq!(misplaced_tui(os_args(&["delta", "--tui"])), None);
assert_eq!(misplaced_tui(os_args(&["delta", "a", "b"])), None);
}
#[test]
fn test_renderers_without_config_file() {
let config = configure("");
let diff = &config.general.diff_renderer;
assert_eq!(diff.command, [DELTA]);
}
#[test]
fn test_diff_renderer_is_always_this_delta() {
let config = configure(
r#"
[general]
diff_renderer.command = ["delta", "--color-only"]
"#,
);
let diff = &config.general.diff_renderer;
assert_eq!(diff.command, [DELTA]);
}
#[test]
fn test_gitu_is_told_the_mode_delta_renders_in() {
assert_eq!(
color_mode_with("[delta]\n light = true\n"),
ColorMode::Light
);
assert_eq!(
color_mode_with("[delta]\n dark = true\n"),
ColorMode::Dark
);
}
#[test]
fn test_a_feature_in_git_config_can_set_the_mode() {
assert_eq!(
color_mode_with("[delta]\n features = mine\n[delta \"mine\"]\n light = true\n"),
ColorMode::Light
);
}
fn color_mode_with(git_config: &str) -> ColorMode {
color_mode(&options_with(git_config))
}
#[test]
fn test_gitu_reads_the_git_config_delta_reads() {
let repo = std::env::temp_dir().join(format!(
"delta-gitu-test-repo-{}-{:?}",
std::process::id(),
std::thread::current().id()
));
let git_repo = git2::Repository::init(&repo).unwrap();
git_repo
.config()
.unwrap()
.set_bool("delta.mine.dark", true)
.unwrap();
let mut config = configure("");
tell_gitu_about_delta(&mut config, &options_with("[delta]\n"));
let git_config = config.general.diff_renderer.git_config.open(&repo);
fs::remove_dir_all(&repo).unwrap();
let git_config = git_config
.expect("delta says how it opens git config")
.unwrap();
assert_eq!(git_config.get_bool("delta.mine.dark").ok(), Some(true));
}
#[test]
fn test_gitu_is_told_the_features_delta_uses() {
let in_force = enabled_with(
"[delta]\n side-by-side = true\n features = mine\n[delta \"mine\"]\n navigate = true\n",
);
for feature in ["side-by-side", "mine", "navigate"] {
assert!(
in_force.iter().any(|f| f == feature),
"{}: {:?}",
feature,
in_force
);
}
for feature in ["line-numbers", "keep-plus-minus-markers"] {
assert!(
!in_force.iter().any(|f| f == feature),
"{}: {:?}",
feature,
in_force
);
}
}
#[test]
fn test_gitu_is_told_each_feature_the_users_config_enables_whatever_the_width() {
let cases: [(&str, &str, bool); 19] = [
("[delta]\n side-by-side = true\n", "line-numbers", false),
("[delta]\n side-by-side = 99999\n", "line-numbers", false),
("[delta]\n raw = true\n", "keep-plus-minus-markers", false),
(
"[delta]\n side-by-side = true\n line-numbers = true\n",
"line-numbers",
true,
),
(
"[delta]\n features = side-by-side line-numbers\n",
"line-numbers",
true,
),
(
"[delta]\n side-by-side = true\n features = mine\n[delta \"mine\"]\n line-numbers = true\n",
"line-numbers",
true,
),
("[delta]\n side-by-side = 99999\n", "side-by-side", true),
("[delta]\n side-by-side = hunk,99999\n", "side-by-side", true),
("[delta]\n features = side-by-side\n", "side-by-side", true),
(
"[delta]\n features = mine\n[delta \"mine\"]\n side-by-side = 99999\n",
"side-by-side",
true,
),
(
"[delta]\n side-by-side = false\n features = side-by-side\n",
"side-by-side",
false,
),
(
"[delta \"side-by-side\"]\n line-numbers-left-format = x\n",
"side-by-side",
false,
),
(
"[delta]\n side-by-side = true\n[delta \"side-by-side\"]\n line-numbers-left-format = x\n",
"side-by-side",
true,
),
("[delta]\n raw = true\n", "raw", true),
("[delta \"raw\"]\n file-style = red\n", "raw", false),
(
"[delta]\n features = raw\n[delta \"raw\"]\n file-style = red\n",
"raw",
true,
),
("[delta \"mine\"]\n file-style = red\n", "mine", false),
(
"[delta]\n features = mine\n[delta \"mine\"]\n file-style = red\n",
"mine",
true,
),
(
"[delta]\n features = mine\n[delta \"mine\"]\n features = child\n[delta \"child\"]\n file-style = red\n",
"child",
true,
),
];
let failures: Vec<String> = cases
.iter()
.filter_map(|(git_config, feature, expected)| {
let in_force = enabled_with(git_config);
let enabled = in_force.iter().any(|f| f == feature);
(enabled != *expected).then(|| {
format!(
"{feature} should be {} with {git_config:?}: {in_force:?}",
if *expected { "enabled" } else { "disabled" }
)
})
})
.collect();
assert!(failures.is_empty(), "\n{}", failures.join("\n"));
}
fn options_with(git_config: &str) -> crate::cli::Opt {
let path = std::env::temp_dir().join(format!(
"delta-gitu-test-{}-{:?}.gitconfig",
std::process::id(),
std::thread::current().id()
));
let env = crate::env::DeltaEnv::default();
let git_config = crate::tests::integration_test_utils::make_git_config(
&env,
git_config.as_bytes(),
path.to_str().unwrap(),
false,
);
let opt = delta_options(&env, Some(git_config));
fs::remove_file(path).unwrap();
opt
}
fn enabled_with(git_config: &str) -> Vec<String> {
let path = std::env::temp_dir().join(format!(
"delta-gitu-test-enabled-{}-{:?}.gitconfig",
std::process::id(),
std::thread::current().id()
));
let env = crate::env::DeltaEnv::default();
let git_config = crate::tests::integration_test_utils::make_git_config(
&env,
git_config.as_bytes(),
path.to_str().unwrap(),
false,
);
let enabled = enabled_features(&env, Some(git_config));
fs::remove_file(path).unwrap();
enabled
}
fn configure(toml: &str) -> Config {
let path = config_file(toml);
let mut config = config::init_config(Some(path.clone())).unwrap();
fs::remove_file(path).unwrap();
use_delta_as_renderer(&mut config, DELTA);
config
}
fn config_file(toml: &str) -> PathBuf {
let path = std::env::temp_dir().join(format!(
"delta-gitu-test-{}-{:?}.toml",
std::process::id(),
std::thread::current().id()
));
fs::write(&path, toml).unwrap();
path
}
}