parse GIT_CONFIG_PARAMETERS, add to config

Author: pickx

src/application.rs

@@ -34,14 +34,14 @@ where ModuleProvider: module::ModuleProvider + Send + 'static
 impl<ModuleProvider> Application<ModuleProvider>
 where ModuleProvider: module::ModuleProvider + Send + 'static
 {
-	pub(crate) fn new<EventProvider, Tui>(args: Args, event_provider: EventProvider, tui: Tui) -> Result<Self, Exit>
+	pub(crate) fn new<EventProvider, Tui>(args: Args, git_config_parameters: Vec<(String, String)>, event_provider: EventProvider, tui: Tui) -> Result<Self, Exit>
 	where
 		EventProvider: EventReaderFn,
 		Tui: crate::display::Tui + Send + 'static,
 	{
 		let filepath = Self::filepath_from_args(args)?;
 		let repository = Self::open_repository()?;
-		let config_loader = ConfigLoader::from(repository);
+		let config_loader = ConfigLoader::with_overrides(repository, git_config_parameters);
 		let config = Self::load_config(&config_loader)
 			.map_err(|err| Exit::new(ExitStatus::ConfigError, format!("{err:#}").as_str()))?;
 		let todo_file = Arc::new(Mutex::new(Self::load_todo_file(filepath.as_str(), &config)?));
@@ -221,12 +221,7 @@ mod tests {
 		module::Modules,
 		runtime::{Installer, RuntimeError},
 		test_helpers::{
-			DefaultTestModule,
-			TestModuleProvider,
-			create_config,
-			create_event_reader,
-			mocks,
-			with_git_directory,
+			DefaultTestModule, TestModuleProvider, create_config, create_event_reader, mocks, with_git_directory,
 		},
 	};
 
@@ -240,8 +235,7 @@ mod tests {
 		($app:expr) => {
 			if let Err(e) = $app {
 				e
-			}
-			else {
+			} else {
 				panic!("Application is not in an error state");
 			}
 		};
@@ -251,8 +245,12 @@ mod tests {
 	#[serial_test::serial]
 	fn load_filepath_from_args_failure() {
 		let event_provider = create_event_reader(|| Ok(None));
-		let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> =
-			Application::new(Args::from_os_strings(Vec::new()).unwrap(), event_provider, create_mocked_crossterm());
+		let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> = Application::new(
+			Args::from_os_strings(Vec::new()).unwrap(),
+			Vec::new(),
+			event_provider,
+			create_mocked_crossterm(),
+		);
 		let exit = application_error!(application);
 		assert_eq!(exit.get_status(), &ExitStatus::StateError);
 		assert!(
@@ -266,8 +264,12 @@ mod tests {
 	fn load_repository_failure() {
 		with_git_directory("fixtures/not-a-repository", |_| {
 			let event_provider = create_event_reader(|| Ok(None));
-			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> =
-				Application::new(Args::from_strs(["todofile"]).unwrap(), event_provider, create_mocked_crossterm());
+			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> = Application::new(
+				Args::from_strs(["todofile"]).unwrap(),
+				Vec::new(),
+				event_provider,
+				create_mocked_crossterm(),
+			);
 			let exit = application_error!(application);
 			assert_eq!(exit.get_status(), &ExitStatus::StateError);
 			assert!(exit.get_message().unwrap().contains("Unable to load Git repository: "));
@@ -278,8 +280,12 @@ mod tests {
 	fn load_config_failure() {
 		with_git_directory("fixtures/invalid-config", |_| {
 			let event_provider = create_event_reader(|| Ok(None));
-			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> =
-				Application::new(Args::from_strs(["rebase-todo"]).unwrap(), event_provider, create_mocked_crossterm());
+			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> = Application::new(
+				Args::from_strs(["rebase-todo"]).unwrap(),
+				Vec::new(),
+				event_provider,
+				create_mocked_crossterm(),
+			);
 			let exit = application_error!(application);
 			assert_eq!(exit.get_status(), &ExitStatus::ConfigError);
 		});
@@ -319,8 +325,12 @@ mod tests {
 	fn load_todo_file_load_error() {
 		with_git_directory("fixtures/simple", |_| {
 			let event_provider = create_event_reader(|| Ok(None));
-			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> =
-				Application::new(Args::from_strs(["does-not-exist"]).unwrap(), event_provider, create_mocked_crossterm());
+			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> = Application::new(
+				Args::from_strs(["does-not-exist"]).unwrap(),
+				Vec::new(),
+				event_provider,
+				create_mocked_crossterm(),
+			);
 			let exit = application_error!(application);
 			assert_eq!(exit.get_status(), &ExitStatus::FileReadError);
 		});
@@ -333,6 +343,7 @@ mod tests {
 			let event_provider = create_event_reader(|| Ok(None));
 			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> = Application::new(
 				Args::from_strs([rebase_todo]).unwrap(),
+				Vec::new(),
 				event_provider,
 				create_mocked_crossterm(),
 			);
@@ -348,6 +359,7 @@ mod tests {
 			let event_provider = create_event_reader(|| Ok(None));
 			let application: Result<Application<TestModuleProvider<DefaultTestModule>>, Exit> = Application::new(
 				Args::from_strs([rebase_todo]).unwrap(),
+				Vec::new(),
 				event_provider,
 				create_mocked_crossterm(),
 			);
@@ -381,6 +393,7 @@ mod tests {
 			let event_provider = create_event_reader(|| Ok(Some(Event::Key(KeyEvent::from(KeyCode::Char('W'))))));
 			let mut application: Application<Modules> = Application::new(
 				Args::from_strs([rebase_todo]).unwrap(),
+				Vec::new(),
 				event_provider,
 				create_mocked_crossterm(),
 			)
@@ -407,6 +420,7 @@ mod tests {
 			let event_provider = create_event_reader(|| Ok(Some(Event::Key(KeyEvent::from(KeyCode::Char('W'))))));
 			let mut application: Application<Modules> = Application::new(
 				Args::from_strs([rebase_todo]).unwrap(),
+				Vec::new(),
 				event_provider,
 				create_mocked_crossterm(),
 			)
@@ -432,6 +446,7 @@ mod tests {
 			});
 			let mut application: Application<Modules> = Application::new(
 				Args::from_strs([rebase_todo]).unwrap(),
+				Vec::new(),
 				event_provider,
 				create_mocked_crossterm(),
 			)
@@ -448,6 +463,7 @@ mod tests {
 			let event_provider = create_event_reader(|| Ok(Some(Event::Key(KeyEvent::from(KeyCode::Char('W'))))));
 			let mut application: Application<Modules> = Application::new(
 				Args::from_strs([rebase_todo]).unwrap(),
+				Vec::new(),
 				event_provider,
 				create_mocked_crossterm(),
 			)

src/config.rs

@@ -115,7 +115,7 @@ mod tests {
 	#[test]
 	fn try_from_config_loader() {
 		with_temp_bare_repository(|repository| {
-			let loader = ConfigLoader::from(repository);
+			let loader = ConfigLoader::new(repository);
 			let config = assert_ok!(loader.load_config());
 			assert_ok!(Config::try_from(&config));
 		});

src/config/config_loader.rs

@@ -6,28 +6,44 @@ use crate::git::{Config, GitError};
 
 pub(crate) struct ConfigLoader {
 	repository: Repository,
+	overrides: Vec<(String, String)>,
 }
 
 impl ConfigLoader {
-	/// Load the git configuration for the repository.
+	#[cfg(test)]
+	pub(crate) fn new(repository: Repository) -> Self {
+		let overrides = Vec::new();
+		Self { repository, overrides }
+	}
+
+	pub(crate) fn with_overrides(repository: Repository, overrides: Vec<(String, String)>) -> Self {
+		Self { repository, overrides }
+	}
+
+	/// Load the git configuration for the repository,
+	/// with any overrides taking priority over the values defined in the repositroy
 	///
 	/// # Errors
 	/// Will result in an error if the configuration is invalid.
 	pub(crate) fn load_config(&self) -> Result<Config, GitError> {
-		self.repository.config().map_err(|e| GitError::ConfigLoad { cause: e })
+		let into_git_error = |cause| GitError::ConfigLoad { cause };
+
+		let mut config = self.repository.config().map_err(into_git_error)?;
+		for (name, value) in &self.overrides {
+			if value.is_empty() {
+				config.set_bool(name, true).map_err(into_git_error)?;
+			} else {
+				config.set_str(name, value).map_err(into_git_error)?;
+			}
+		}
+		Ok(config)
 	}
 
 	pub(crate) fn eject_repository(self) -> Repository {
 		self.repository
 	}
 }
 
-impl From<Repository> for ConfigLoader {
-	fn from(repository: Repository) -> Self {
-		Self { repository }
-	}
-}
-
 impl Debug for ConfigLoader {
 	fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
 		f.debug_struct("ConfigLoader")
@@ -49,7 +65,7 @@ mod unix_tests {
 	#[test]
 	fn load_config() {
 		with_temp_bare_repository(|repository| {
-			let config = ConfigLoader::from(repository);
+			let config = ConfigLoader::new(repository);
 			assert_ok!(config.load_config());
 		});
 	}
@@ -58,7 +74,7 @@ mod unix_tests {
 	fn fmt() {
 		with_temp_repository(|repository| {
 			let path = repository.path().canonicalize().unwrap();
-			let loader = ConfigLoader::from(repository);
+			let loader = ConfigLoader::new(repository);
 			let formatted = format!("{loader:?}");
 			assert_eq!(
 				formatted,

src/editor.rs

@@ -11,8 +11,8 @@ use crate::{
 };
 
 #[cfg(not(tarpaulin_include))]
-pub(crate) fn run(args: Args) -> Exit {
-	let mut application: Application<Modules> = match Application::new(args, read_event, CrossTerm::new()) {
+pub(crate) fn run(args: Args, git_config_parameters: Vec<(String, String)>) -> Exit {
+	let mut application: Application<Modules> = match Application::new(args, git_config_parameters, read_event, CrossTerm::new()) {
 		Ok(app) => app,
 		Err(exit) => return exit,
 	};
@@ -35,8 +35,9 @@ mod tests {
 		with_git_directory("fixtures/simple", |path| {
 			let todo_file = Path::new(path).join("rebase-todo-empty").into_os_string();
 			let args = Args::from_os_strings(vec![todo_file]).unwrap();
+			let git_config_parameters = Vec::new();
 			assert_eq!(
-				run(args).get_status(),
+				run(args, git_config_parameters).get_status(),
 				&ExitStatus::Good
 			);
 		});
@@ -47,8 +48,9 @@ mod tests {
 		with_git_directory("fixtures/simple", |path| {
 			let todo_file = Path::new(path).join("does-not-exist").into_os_string();
 			let args = Args::from_os_strings(vec![todo_file]).unwrap();
+			let git_config_parameters = Vec::new();
 			assert_eq!(
-				run(args).get_status(),
+				run(args, git_config_parameters).get_status(),
 				&ExitStatus::FileReadError
 			);
 		});

src/main.rs

@@ -72,24 +72,65 @@ use crate::{
 };
 
 #[must_use]
-fn run(os_args: Vec<OsString>) -> Exit {
+fn run(os_args: Vec<OsString>, git_config_parameters: Vec<(String, String)>) -> Exit {
 	match Args::from_os_strings(os_args) {
 		Err(err) => err,
 		Ok(args) => {
 			match *args.mode() {
 				Mode::Help => help::run(),
 				Mode::Version => version::run(),
 				Mode::License => license::run(),
-				Mode::Editor => editor::run(args),
+				Mode::Editor => editor::run(args, git_config_parameters),
 			}
 		},
 	}
 }
+/// returns a pair of name/value pairs passed as overrides to `git`.
+///
+/// input here is expected to come from `git -c`, and is in the form
+/// of `-c <name>=<value>` pairs, for example `-c interactive-rebase-tool.diffTabWidth=4`.
+/// separated by a single whitespace
+///
+/// notes:
+/// 1. the key/value have both gone through git's shell quoting.
+///    from `gix-quote`: "every single-quote `'` is escaped as `'\''`, 
+///    every exclamation mark `!` is escaped as `'\!'`, and the entire string
+///    is enclosed in single quotes."
+/// 2. if input doesn't contain a '=', a `=` is appended between
+///    `key` and `value`. `value`, will be an empty string.
+/// 3. if input does contain a '=' but `value` is empty, `value`
+///    will also be an empty string.
+/// 4. an empty string will later be interpreted as `true`,
+///    but we don't do this here.
+pub(crate) fn parse_git_config_parameters(env_var: OsString) -> Vec<(String, String)> {
+	// we expect valid UTF-8 from the shell/git, so we don't handle errors here. 
+	let Some(env_var) = env_var.to_str() else {
+		return Vec::new();
+	};
+
+	// naive implementation: assumes correctly-escaped strings, efficiency isn't a priority
+	fn unescape(s: &str) -> String {
+		let s = s.trim_matches('\'');
+		let mut s = s.replace("\\'", "\'");
+		s = s.replace("\\!", "!");
+		s
+	}
+
+	env_var
+		.split_ascii_whitespace()
+		.filter_map(|pair| pair.split_once('='))
+		.map(|(name, value)| (unescape(name), unescape(value)))
+		.collect()
+}
 
 #[expect(clippy::print_stderr, reason = "Required to print error message.")]
 #[cfg(not(tarpaulin_include))]
 fn main() -> impl Termination {
-	let exit = run(env::args_os().skip(1).collect());
+	let args = env::args_os().skip(1).collect();
+	let git_config_parameters = env::var_os("GIT_CONFIG_PARAMETERS")
+		.map(parse_git_config_parameters)
+		.unwrap_or_default();
+	let exit = run(args, git_config_parameters);
 	if let Some(message) = exit.get_message() {
 		eprintln!("{message}");
 	}

src/tests.rs

@@ -7,7 +7,8 @@ use crate::{module::ExitStatus, test_helpers::with_git_directory};
 #[serial_test::serial]
 fn successful_run_help() {
 	let args = ["--help"].into_iter().map(OsString::from).collect();
-	let exit = run(args);
+	let git_config_parameters = Vec::new();
+	let exit = run(args, git_config_parameters);
 	assert!(exit.get_message().unwrap().contains("USAGE:"));
 	assert_eq!(exit.get_status(), &ExitStatus::Good);
 }
@@ -16,7 +17,8 @@ fn successful_run_help() {
 #[serial_test::serial]
 fn successful_run_version() {
 	let args = ["--version"].into_iter().map(OsString::from).collect();
-	let exit = run(args);
+	let git_config_parameters = Vec::new();
+	let exit = run(args, git_config_parameters);
 	assert!(exit.get_message().unwrap().starts_with("interactive-rebase-tool"));
 	assert_eq!(exit.get_status(), &ExitStatus::Good);
 }
@@ -25,7 +27,8 @@ fn successful_run_version() {
 #[serial_test::serial]
 fn successful_run_license() {
 	let args = ["--license"].into_iter().map(OsString::from).collect();
-	let exit = run(args);
+	let git_config_parameters = Vec::new();
+	let exit = run(args, git_config_parameters);
 	assert!(
 		exit.get_message()
 			.unwrap()
@@ -39,8 +42,9 @@ fn successful_run_editor() {
 	with_git_directory("fixtures/simple", |path| {
 		let todo_file = Path::new(path).join("rebase-todo-empty").into_os_string();
 		let args = vec![todo_file];
+		let git_config_parameters = Vec::new();
 		assert_eq!(
-			run(args).get_status(),
+			run(args, git_config_parameters).get_status(),
 			&ExitStatus::Good
 		);
 	});
@@ -52,5 +56,6 @@ fn successful_run_editor() {
 #[expect(unsafe_code)]
 fn error() {
 	let args = unsafe { vec![OsString::from(String::from_utf8_unchecked(vec![0xC3, 0x28]))] };
-	assert_eq!(run(args).get_status(), &ExitStatus::StateError);
+	let git_config_parameters = Vec::new();
+	assert_eq!(run(args, git_config_parameters).get_status(), &ExitStatus::StateError);
 }