Update visibility to be required minimum

This change updates the usages of `pub` to be the minimum level of
visibility needed. This also required cleaning up some of the use
statements to use a simpler set of imports.

7 files changed, 287 insertions, 290 deletions

diff --git a/src/process/exit_status.rs b/src/process/exit_status.rs
index be4382e..8e4231a 100644
--- a/src/process/exit_status.rs
+++ b/src/process/exit_status.rs
@@ -1,5 +1,5 @@
 #[derive(Clone, Copy, Debug)]
-pub enum ExitStatus {
+pub(crate) enum ExitStatus {
 	ConfigError,
 	FileReadError,
 	FileWriteError,
@@ -8,7 +8,7 @@ pub enum ExitStatus {
 }
 
 impl ExitStatus {
-	pub fn to_code(self) -> i32 {
+	pub(crate) fn to_code(self) -> i32 {
 		match self {
 			ExitStatus::ConfigError => 1,
 			ExitStatus::FileReadError => 2,
diff --git a/src/process/handle_input_result.rs b/src/process/handle_input_result.rs
index be5e436..6927548 100644
--- a/src/process/handle_input_result.rs
+++ b/src/process/handle_input_result.rs
@@ -1,14 +1,15 @@
 use crate::input::Input;
-use crate::process::{ExitStatus, State};
+use crate::process::exit_status::ExitStatus;
+use crate::process::state::State;
 
-pub struct HandleInputResult {
-	pub exit_status: Option<ExitStatus>,
-	pub input: Input,
-	pub state: Option<State>,
+pub(crate) struct HandleInputResult {
+	pub(super) exit_status: Option<ExitStatus>,
+	pub(super) input: Input,
+	pub(super) state: Option<State>,
 }
 
 impl HandleInputResult {
-	pub fn new(input: Input) -> Self {
+	pub(crate) fn new(input: Input) -> Self {
 		Self {
 			exit_status: None,
 			input,
@@ -17,12 +18,12 @@ impl HandleInputResult {
 	}
 }
 
-pub struct HandleInputResultBuilder {
-	pub handle_input: HandleInputResult,
+pub(crate) struct HandleInputResultBuilder {
+	handle_input: HandleInputResult,
 }
 
 impl HandleInputResultBuilder {
-	pub fn new(input: Input) -> Self {
+	pub(crate) fn new(input: Input) -> Self {
 		Self {
 			handle_input: HandleInputResult {
 				exit_status: None,
@@ -32,22 +33,22 @@ impl HandleInputResultBuilder {
 		}
 	}
 
-	pub fn exit_status(mut self, status: ExitStatus) -> Self {
+	pub(crate) fn exit_status(mut self, status: ExitStatus) -> Self {
 		self.handle_input.exit_status = Some(status);
 		self
 	}
 
-	pub fn help(mut self, target_state: State) -> Self {
+	pub(crate) fn help(mut self, target_state: State) -> Self {
 		self.handle_input.state = Some(State::Help(Box::new(target_state)));
 		self
 	}
 
-	pub fn state(mut self, new_state: State) -> Self {
+	pub(crate) fn state(mut self, new_state: State) -> Self {
 		self.handle_input.state = Some(new_state);
 		self
 	}
 
-	pub fn build(self) -> HandleInputResult {
+	pub(crate) fn build(self) -> HandleInputResult {
 		self.handle_input
 	}
 }
diff --git a/src/process/mod.rs b/src/process/mod.rs
index cff53c3..941a231 100644
--- a/src/process/mod.rs
+++ b/src/process/mod.rs
@@ -1,16 +1,252 @@
-mod exit_status;
-mod handle_input_result;
-#[allow(clippy::module_inception)]
-mod process;
-mod process_module;
-mod process_result;
-mod state;
-
-pub use self::exit_status::ExitStatus;
-pub use self::handle_input_result::HandleInputResult;
-pub use self::handle_input_result::HandleInputResultBuilder;
-pub use self::process::Process;
-pub use self::process_module::ProcessModule;
-pub use self::process_result::ProcessResult;
-pub use self::process_result::ProcessResultBuilder;
-pub use self::state::State;
+pub(crate) mod exit_status;
+pub(crate) mod handle_input_result;
+pub(crate) mod process_module;
+pub(crate) mod process_result;
+pub(crate) mod state;
+
+use crate::config::Config;
+use crate::confirm_abort::ConfirmAbort;
+use crate::confirm_rebase::ConfirmRebase;
+use crate::display::Display;
+use crate::edit::Edit;
+use crate::error::Error;
+use crate::exiting::Exiting;
+use crate::external_editor::ExternalEditor;
+use crate::git_interactive::GitInteractive;
+use crate::help::Help;
+use crate::input::input_handler::InputHandler;
+use crate::input::Input;
+use crate::list::List;
+use crate::process::exit_status::ExitStatus;
+use crate::process::process_module::ProcessModule;
+use crate::process::state::State;
+use crate::show_commit::ShowCommit;
+use crate::view::View;
+use crate::window_size_error::WindowSizeError;
+use std::cell::RefCell;
+
+pub(crate) struct Process<'r> {
+	confirm_abort: ConfirmAbort,
+	confirm_rebase: ConfirmRebase,
+	edit: Edit,
+	error: Error,
+	exit_status: Option<ExitStatus>,
+	exiting: Exiting,
+	external_editor: ExternalEditor<'r>,
+	git_interactive: GitInteractive,
+	help: Help<'r>,
+	input_handler: &'r InputHandler<'r>,
+	list: List<'r>,
+	show_commit: ShowCommit,
+	state: RefCell<State>,
+	view: &'r View<'r>,
+	window_size_error: WindowSizeError,
+}
+
+impl<'r> Process<'r> {
+	pub(crate) fn new(
+		git_interactive: GitInteractive,
+		view: &'r View<'r>,
+		display: &'r Display<'r>,
+		input_handler: &'r InputHandler<'r>,
+		config: &'r Config,
+	) -> Self
+	{
+		Self {
+			confirm_abort: ConfirmAbort::new(),
+			confirm_rebase: ConfirmRebase::new(),
+			edit: Edit::new(),
+			error: Error::new(),
+			exit_status: None,
+			exiting: Exiting::new(),
+			external_editor: ExternalEditor::new(display, config),
+			git_interactive,
+			help: Help::new(config),
+			input_handler,
+			list: List::new(config),
+			show_commit: ShowCommit::new(),
+			state: RefCell::new(State::List(false)),
+			view,
+			window_size_error: WindowSizeError::new(),
+		}
+	}
+
+	pub(crate) fn run(&mut self) -> Result<Option<ExitStatus>, String> {
+		self.check_window_size();
+		while self.exit_status.is_none() {
+			self.process();
+			self.render();
+			self.handle_input();
+		}
+		self.exit_end()?;
+		Ok(self.exit_status)
+	}
+
+	fn activate(&mut self) {
+		let state = self.get_state();
+		match state {
+			State::ConfirmAbort => self.confirm_abort.activate(state, &self.git_interactive),
+			State::ConfirmRebase => self.confirm_rebase.activate(state, &self.git_interactive),
+			State::Edit => self.edit.activate(state, &self.git_interactive),
+			State::Error { .. } => self.error.activate(state, &self.git_interactive),
+			State::Exiting => self.exiting.activate(state, &self.git_interactive),
+			State::ExternalEditor => self.external_editor.activate(state, &self.git_interactive),
+			State::Help(_) => self.help.activate(state, &self.git_interactive),
+			State::List(_) => self.list.activate(state, &self.git_interactive),
+			State::ShowCommit => self.show_commit.activate(state, &self.git_interactive),
+			State::WindowSizeError(_) => self.window_size_error.activate(state, &self.git_interactive),
+		}
+	}
+
+	fn deactivate(&mut self) {
+		match self.get_state() {
+			State::ConfirmAbort => self.confirm_abort.deactivate(),
+			State::ConfirmRebase => self.confirm_rebase.deactivate(),
+			State::Edit => self.edit.deactivate(),
+			State::Error { .. } => self.error.deactivate(),
+			State::Exiting => self.exiting.deactivate(),
+			State::ExternalEditor => self.external_editor.deactivate(),
+			State::Help(_) => self.help.deactivate(),
+			State::List(_) => self.list.deactivate(),
+			State::ShowCommit => self.show_commit.deactivate(),
+			State::WindowSizeError(_) => self.window_size_error.deactivate(),
+		}
+	}
+
+	fn process(&mut self) {
+		let result = match self.get_state() {
+			State::ConfirmAbort => self.confirm_abort.process(&mut self.git_interactive, &self.view),
+			State::ConfirmRebase => self.confirm_rebase.process(&mut self.git_interactive, &self.view),
+			State::Edit => self.edit.process(&mut self.git_interactive, &self.view),
+			State::Error { .. } => self.error.process(&mut self.git_interactive, &self.view),
+			State::Exiting => self.exiting.process(&mut self.git_interactive, &self.view),
+			State::ExternalEditor => self.external_editor.process(&mut self.git_interactive, &self.view),
+			State::Help(_) => self.help.process(&mut self.git_interactive, &self.view),
+			State::List(_) => self.list.process(&mut self.git_interactive, &self.view),
+			State::ShowCommit => self.show_commit.process(&mut self.git_interactive, &self.view),
+			State::WindowSizeError(_) => self.window_size_error.process(&mut self.git_interactive, &self.view),
+		};
+
+		if let Some(exit_status) = result.exit_status {
+			self.exit_status = Some(exit_status);
+		}
+
+		if let Some(new_state) = result.state {
+			if new_state != self.get_state() {
+				self.deactivate();
+				self.set_state(new_state);
+				self.activate();
+			}
+		}
+	}
+
+	fn render(&self) {
+		self.view.clear();
+		match self.get_state() {
+			State::ConfirmAbort => self.confirm_abort.render(&self.view, &self.git_interactive),
+			State::ConfirmRebase => self.confirm_rebase.render(&self.view, &self.git_interactive),
+			State::Edit => self.edit.render(&self.view, &self.git_interactive),
+			State::Error { .. } => self.error.render(&self.view, &self.git_interactive),
+			State::Exiting => self.exiting.render(&self.view, &self.git_interactive),
+			State::ExternalEditor => self.external_editor.render(&self.view, &self.git_interactive),
+			State::Help(_) => self.help.render(&self.view, &self.git_interactive),
+			State::List(_) => self.list.render(&self.view, &self.git_interactive),
+			State::ShowCommit => self.show_commit.render(&self.view, &self.git_interactive),
+			State::WindowSizeError(_) => self.window_size_error.render(&self.view, &self.git_interactive),
+		};
+		self.view.refresh()
+	}
+
+	fn handle_input(&mut self) {
+		let result = match self.get_state() {
+			State::ConfirmAbort => {
+				self.confirm_abort
+					.handle_input(self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::ConfirmRebase => {
+				self.confirm_rebase
+					.handle_input(self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::Edit => {
+				self.edit
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::Error { .. } => {
+				self.error
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::Exiting => {
+				self.exiting
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::ExternalEditor => {
+				self.external_editor
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::Help(_) => {
+				self.help
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::List(_) => {
+				self.list
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::ShowCommit => {
+				self.show_commit
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+			State::WindowSizeError(_) => {
+				self.window_size_error
+					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
+			},
+		};
+
+		if let Some(exit_status) = result.exit_status {
+			self.exit_status = Some(exit_status);
+		}
+
+		if let Some(new_state) = result.state {
+			if new_state != self.get_state() {
+				self.deactivate();
+				self.set_state(new_state);
+				self.activate();
+			}
+		}
+
+		if let Input::Resize = result.input {
+			self.check_window_size();
+		}
+	}
+
+	fn check_window_size(&self) {
+		let check = self.view.check_window_size();
+		let state = self.get_state();
+		if let State::WindowSizeError(return_state) = state {
+			if check {
+				self.set_state(*return_state);
+			}
+		}
+		else if !check {
+			self.set_state(State::WindowSizeError(Box::new(self.get_state())));
+		}
+	}
+
+	fn set_state(&self, new_state: State) {
+		self.state.replace(new_state);
+	}
+
+	fn get_state(&self) -> State {
+		self.state.borrow().clone()
+	}
+
+	fn exit_end(&mut self) -> Result<(), String> {
+		match self.git_interactive.write_file() {
+			Ok(_) => {},
+			Err(msg) => {
+				self.exit_status = Some(ExitStatus::FileWriteError);
+				return Err(msg);
+			},
+		}
+		Ok(())
+	}
+}
diff --git a/src/process/process.rs b/src/process/process.rs
deleted file mode 100644
index 1181310..0000000
--- a/src/process/process.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-use crate::config::Config;
-use crate::confirm_abort::ConfirmAbort;
-use crate::confirm_rebase::ConfirmRebase;
-use crate::display::Display;
-use crate::edit::Edit;
-use crate::error::Error;
-use crate::exiting::Exiting;
-use crate::external_editor::ExternalEditor;
-use crate::git_interactive::GitInteractive;
-use crate::help::Help;
-use crate::input::{Input, InputHandler};
-use crate::list::List;
-use crate::process::process_module::ProcessModule;
-use crate::process::{ExitStatus, State};
-use crate::show_commit::ShowCommit;
-use crate::view::View;
-use crate::window_size_error::WindowSizeError;
-use std::cell::RefCell;
-
-pub struct Process<'r> {
-	confirm_abort: ConfirmAbort,
-	confirm_rebase: ConfirmRebase,
-	edit: Edit,
-	error: Error,
-	exit_status: Option<ExitStatus>,
-	exiting: Exiting,
-	external_editor: ExternalEditor<'r>,
-	git_interactive: GitInteractive,
-	help: Help<'r>,
-	input_handler: &'r InputHandler<'r>,
-	list: List<'r>,
-	show_commit: ShowCommit,
-	state: RefCell<State>,
-	view: &'r View<'r>,
-	window_size_error: WindowSizeError,
-}
-
-impl<'r> Process<'r> {
-	pub fn new(
-		git_interactive: GitInteractive,
-		view: &'r View<'r>,
-		display: &'r Display<'r>,
-		input_handler: &'r InputHandler<'r>,
-		config: &'r Config,
-	) -> Self
-	{
-		Self {
-			confirm_abort: ConfirmAbort::new(),
-			confirm_rebase: ConfirmRebase::new(),
-			edit: Edit::new(),
-			error: Error::new(),
-			exit_status: None,
-			exiting: Exiting::new(),
-			external_editor: ExternalEditor::new(display, config),
-			git_interactive,
-			help: Help::new(config),
-			input_handler,
-			list: List::new(config),
-			show_commit: ShowCommit::new(),
-			state: RefCell::new(State::List(false)),
-			view,
-			window_size_error: WindowSizeError::new(),
-		}
-	}
-
-	pub fn run(&mut self) -> Result<Option<ExitStatus>, String> {
-		self.check_window_size();
-		while self.exit_status.is_none() {
-			self.process();
-			self.render();
-			self.handle_input();
-		}
-		self.exit_end()?;
-		Ok(self.exit_status)
-	}
-
-	fn activate(&mut self) {
-		let state = self.get_state();
-		match state {
-			State::ConfirmAbort => self.confirm_abort.activate(state, &self.git_interactive),
-			State::ConfirmRebase => self.confirm_rebase.activate(state, &self.git_interactive),
-			State::Edit => self.edit.activate(state, &self.git_interactive),
-			State::Error { .. } => self.error.activate(state, &self.git_interactive),
-			State::Exiting => self.exiting.activate(state, &self.git_interactive),
-			State::ExternalEditor => self.external_editor.activate(state, &self.git_interactive),
-			State::Help(_) => self.help.activate(state, &self.git_interactive),
-			State::List(_) => self.list.activate(state, &self.git_interactive),
-			State::ShowCommit => self.show_commit.activate(state, &self.git_interactive),
-			State::WindowSizeError(_) => self.window_size_error.activate(state, &self.git_interactive),
-		}
-	}
-
-	fn deactivate(&mut self) {
-		match self.get_state() {
-			State::ConfirmAbort => self.confirm_abort.deactivate(),
-			State::ConfirmRebase => self.confirm_rebase.deactivate(),
-			State::Edit => self.edit.deactivate(),
-			State::Error { .. } => self.error.deactivate(),
-			State::Exiting => self.exiting.deactivate(),
-			State::ExternalEditor => self.external_editor.deactivate(),
-			State::Help(_) => self.help.deactivate(),
-			State::List(_) => self.list.deactivate(),
-			State::ShowCommit => self.show_commit.deactivate(),
-			State::WindowSizeError(_) => self.window_size_error.deactivate(),
-		}
-	}
-
-	fn process(&mut self) {
-		let result = match self.get_state() {
-			State::ConfirmAbort => self.confirm_abort.process(&mut self.git_interactive, &self.view),
-			State::ConfirmRebase => self.confirm_rebase.process(&mut self.git_interactive, &self.view),
-			State::Edit => self.edit.process(&mut self.git_interactive, &self.view),
-			State::Error { .. } => self.error.process(&mut self.git_interactive, &self.view),
-			State::Exiting => self.exiting.process(&mut self.git_interactive, &self.view),
-			State::ExternalEditor => self.external_editor.process(&mut self.git_interactive, &self.view),
-			State::Help(_) => self.help.process(&mut self.git_interactive, &self.view),
-			State::List(_) => self.list.process(&mut self.git_interactive, &self.view),
-			State::ShowCommit => self.show_commit.process(&mut self.git_interactive, &self.view),
-			State::WindowSizeError(_) => self.window_size_error.process(&mut self.git_interactive, &self.view),
-		};
-
-		if let Some(exit_status) = result.exit_status {
-			self.exit_status = Some(exit_status);
-		}
-
-		if let Some(new_state) = result.state {
-			if new_state != self.get_state() {
-				self.deactivate();
-				self.set_state(new_state);
-				self.activate();
-			}
-		}
-	}
-
-	fn render(&self) {
-		self.view.clear();
-		match self.get_state() {
-			State::ConfirmAbort => self.confirm_abort.render(&self.view, &self.git_interactive),
-			State::ConfirmRebase => self.confirm_rebase.render(&self.view, &self.git_interactive),
-			State::Edit => self.edit.render(&self.view, &self.git_interactive),
-			State::Error { .. } => self.error.render(&self.view, &self.git_interactive),
-			State::Exiting => self.exiting.render(&self.view, &self.git_interactive),
-			State::ExternalEditor => self.external_editor.render(&self.view, &self.git_interactive),
-			State::Help(_) => self.help.render(&self.view, &self.git_interactive),
-			State::List(_) => self.list.render(&self.view, &self.git_interactive),
-			State::ShowCommit => self.show_commit.render(&self.view, &self.git_interactive),
-			State::WindowSizeError(_) => self.window_size_error.render(&self.view, &self.git_interactive),
-		};
-		self.view.refresh()
-	}
-
-	fn handle_input(&mut self) {
-		let result = match self.get_state() {
-			State::ConfirmAbort => {
-				self.confirm_abort
-					.handle_input(self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::ConfirmRebase => {
-				self.confirm_rebase
-					.handle_input(self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::Edit => {
-				self.edit
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::Error { .. } => {
-				self.error
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::Exiting => {
-				self.exiting
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::ExternalEditor => {
-				self.external_editor
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::Help(_) => {
-				self.help
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::List(_) => {
-				self.list
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::ShowCommit => {
-				self.show_commit
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::WindowSizeError(_) => {
-				self.window_size_error
-					.handle_input(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-		};
-
-		if let Some(exit_status) = result.exit_status {
-			self.exit_status = Some(exit_status);
-		}
-
-		if let Some(new_state) = result.state {
-			if new_state != self.get_state() {
-				self.deactivate();
-				self.set_state(new_state);
-				self.activate();
-			}
-		}
-
-		if let Input::Resize = result.input {
-			self.check_window_size();
-		}
-	}
-
-	fn check_window_size(&self) {
-		let check = self.view.check_window_size();
-		let state = self.get_state();
-		if let State::WindowSizeError(return_state) = state {
-			if check {
-				self.set_state(*return_state);
-			}
-		}
-		else if !check {
-			self.set_state(State::WindowSizeError(Box::new(self.get_state())));
-		}
-	}
-
-	fn set_state(&self, new_state: State) {
-		self.state.replace(new_state);
-	}
-
-	pub fn get_state(&self) -> State {
-		self.state.borrow().clone()
-	}
-
-	fn exit_end(&mut self) -> Result<(), String> {
-		match self.git_interactive.write_file() {
-			Ok(_) => {},
-			Err(msg) => {
-				self.exit_status = Some(ExitStatus::FileWriteError);
-				return Err(msg);
-			},
-		}
-		Ok(())
-	}
-}
diff --git a/src/process/process_module.rs b/src/process/process_module.rs
index bf98a79..7c16ff0 100644
--- a/src/process/process_module.rs
+++ b/src/process/process_module.rs
@@ -1,9 +1,12 @@
 use crate::git_interactive::GitInteractive;
-use crate::input::{Input, InputHandler};
-use crate::process::{HandleInputResult, ProcessResult, State};
+use crate::input::input_handler::InputHandler;
+use crate::input::Input;
+use crate::process::handle_input_result::HandleInputResult;
+use crate::process::process_result::ProcessResult;
+use crate::process::state::State;
 use crate::view::View;
 
-pub trait ProcessModule {
+pub(crate) trait ProcessModule {
 	fn activate(&mut self, _state: State, _git_interactive: &GitInteractive) {}
 
 	fn deactivate(&mut self) {}
diff --git a/src/process/process_result.rs b/src/process/process_result.rs
index acc4f03..d62d6ce 100644
--- a/src/process/process_result.rs
+++ b/src/process/process_result.rs
@@ -1,13 +1,14 @@
-use crate::process::{ExitStatus, State};
+use crate::process::exit_status::ExitStatus;
+use crate::process::state::State;
 
 #[derive(Debug)]
-pub struct ProcessResult {
-	pub exit_status: Option<ExitStatus>,
-	pub state: Option<State>,
+pub(crate) struct ProcessResult {
+	pub(super) exit_status: Option<ExitStatus>,
+	pub(super) state: Option<State>,
 }
 
 impl ProcessResult {
-	pub fn new() -> Self {
+	pub(crate) fn new() -> Self {
 		Self {
 			exit_status: None,
 			state: None,
@@ -15,12 +16,12 @@ impl ProcessResult {
 	}
 }
 
-pub struct ProcessResultBuilder {
+pub(crate) struct ProcessResultBuilder {
 	process_result: ProcessResult,
 }
 
 impl ProcessResultBuilder {
-	pub fn new() -> Self {
+	pub(crate) fn new() -> Self {
 		Self {
 			process_result: ProcessResult {
 				exit_status: None,
@@ -29,7 +30,7 @@ impl ProcessResultBuilder {
 		}
 	}
 
-	pub fn error(mut self, message: &str, return_state: State) -> Self {
+	pub(crate) fn error(mut self, message: &str, return_state: State) -> Self {
 		self.process_result.state = Some(State::Error {
 			return_state: Box::new(return_state),
 			message: String::from(message),
@@ -37,17 +38,17 @@ impl ProcessResultBuilder {
 		self
 	}
 
-	pub fn exit_status(mut self, status: ExitStatus) -> Self {
+	pub(crate) fn exit_status(mut self, status: ExitStatus) -> Self {
 		self.process_result.exit_status = Some(status);
 		self
 	}
 
-	pub fn state(mut self, new_state: State) -> Self {
+	pub(crate) fn state(mut self, new_state: State) -> Self {
 		self.process_result.state = Some(new_state);
 		self
 	}
 
-	pub fn build(self) -> ProcessResult {
+	pub(crate) fn build(self) -> ProcessResult {
 		self.process_result
 	}
 }
diff --git a/src/process/state.rs b/src/process/state.rs
index 0162441..cfc75bf 100644
--- a/src/process/state.rs
+++ b/src/process/state.rs
@@ -1,5 +1,5 @@
 #[derive(Clone, Debug, PartialEq)]
-pub enum State {
+pub(crate) enum State {
 	ConfirmAbort,
 	ConfirmRebase,
 	Edit,