Move remaining code form application to process

13 files changed, 237 insertions, 255 deletions

diff --git a/src/application.rs b/src/application.rs
deleted file mode 100644
index e58eb6e..0000000
--- a/src/application.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-use crate::config::Config;
-use crate::confirm_abort::ConfirmAbort;
-use crate::confirm_rebase::ConfirmRebase;
-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::InputHandler;
-use crate::list::List;
-use crate::process::{HandleInputResult, ProcessModule, ProcessResult, State};
-use crate::show_commit::ShowCommit;
-use crate::view::View;
-use crate::window_size_error::WindowSizeError;
-
-pub struct Application<'a> {
-	confirm_abort: ConfirmAbort,
-	confirm_rebase: ConfirmRebase,
-	edit: Edit,
-	error: Error,
-	exiting: Exiting,
-	external_editor: ExternalEditor<'a>,
-	git_interactive: GitInteractive,
-	help: Help,
-	input_handler: &'a InputHandler<'a>,
-	list: List<'a>,
-	show_commit: ShowCommit,
-	view: View<'a>,
-	window_size_error: WindowSizeError,
-}
-
-impl<'a> Application<'a> {
-	pub fn new(
-		git_interactive: GitInteractive,
-		view: View<'a>,
-		input_handler: &'a InputHandler<'a>,
-		config: &'a Config,
-	) -> Self
-	{
-		Self {
-			confirm_abort: ConfirmAbort::new(),
-			confirm_rebase: ConfirmRebase::new(),
-			edit: Edit::new(),
-			error: Error::new(),
-			exiting: Exiting::new(),
-			external_editor: ExternalEditor::new(config),
-			git_interactive,
-			help: Help::new(),
-			input_handler,
-			list: List::new(config),
-			show_commit: ShowCommit::new(),
-			view,
-			window_size_error: WindowSizeError::new(),
-		}
-	}
-
-	pub fn activate(&mut self, state: 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),
-		}
-	}
-
-	pub fn deactivate(&mut self, state: State) {
-		match 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(),
-		}
-	}
-
-	pub fn process(&mut self, state: State) -> ProcessResult {
-		match state {
-			State::ConfirmAbort => self.confirm_abort.process(&mut self.git_interactive),
-			State::ConfirmRebase => self.confirm_rebase.process(&mut self.git_interactive),
-			State::Edit => self.edit.process(&mut self.git_interactive),
-			State::Error { .. } => self.error.process(&mut self.git_interactive),
-			State::Exiting => self.exiting.process(&mut self.git_interactive),
-			State::ExternalEditor => self.external_editor.process(&mut self.git_interactive),
-			State::Help(_) => self.help.process(&mut self.git_interactive),
-			State::List(_) => self.list.process_with_view(&mut self.git_interactive, &self.view),
-			State::ShowCommit => self.show_commit.process(&mut self.git_interactive),
-			State::WindowSizeError(_) => self.window_size_error.process(&mut self.git_interactive),
-		}
-	}
-
-	pub fn check_window_size(&self) -> bool {
-		self.view.check_window_size()
-	}
-
-	pub fn render(&self, state: State) {
-		self.view.clear();
-		match 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()
-	}
-
-	pub fn handle_input(&mut self, state: State) -> HandleInputResult {
-		match state {
-			State::ConfirmAbort => {
-				self.confirm_abort
-					.handle_input(self.input_handler, &mut self.git_interactive)
-			},
-			State::ConfirmRebase => {
-				self.confirm_rebase
-					.handle_input(self.input_handler, &mut self.git_interactive)
-			},
-			State::Edit => self.edit.handle_input(&self.input_handler, &mut self.git_interactive),
-			State::Error { .. } => self.error.handle_input(&self.input_handler, &mut self.git_interactive),
-			State::Exiting => {
-				self.exiting
-					.handle_input(&self.input_handler, &mut self.git_interactive)
-			},
-			State::ExternalEditor => {
-				self.external_editor
-					.handle_input(&self.input_handler, &mut self.git_interactive)
-			},
-			State::Help(_) => {
-				self.help
-					.handle_input_with_view(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::List(_) => self.list.handle_input(&self.input_handler, &mut self.git_interactive),
-			State::ShowCommit => {
-				self.show_commit
-					.handle_input_with_view(&self.input_handler, &mut self.git_interactive, &self.view)
-			},
-			State::WindowSizeError(_) => {
-				self.window_size_error
-					.handle_input(&self.input_handler, &mut self.git_interactive)
-			},
-		}
-	}
-
-	pub fn write_file(&self) -> Result<(), String> {
-		self.git_interactive.write_file()
-	}
-}
diff --git a/src/confirm_abort/confirm_abort.rs b/src/confirm_abort/confirm_abort.rs
index 9fe3464..7352b27 100644
--- a/src/confirm_abort/confirm_abort.rs
+++ b/src/confirm_abort/confirm_abort.rs
@@ -10,6 +10,7 @@ impl ProcessModule for ConfirmAbort {
 		&mut self,
 		input_handler: &InputHandler,
 		git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		let input = input_handler.get_confirm();
diff --git a/src/confirm_rebase/confirm_rebase.rs b/src/confirm_rebase/confirm_rebase.rs
index f341429..d362125 100644
--- a/src/confirm_rebase/confirm_rebase.rs
+++ b/src/confirm_rebase/confirm_rebase.rs
@@ -10,6 +10,7 @@ impl ProcessModule for ConfirmRebase {
 		&mut self,
 		input_handler: &InputHandler,
 		_git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		let input = input_handler.get_confirm();
diff --git a/src/edit/edit.rs b/src/edit/edit.rs
index d1dfd6f..b991bca 100644
--- a/src/edit/edit.rs
+++ b/src/edit/edit.rs
@@ -29,7 +29,7 @@ impl ProcessModule for Edit {
 		self.cursor_position = 0;
 	}
 
-	fn process(&mut self, git_interactive: &mut GitInteractive) -> ProcessResult {
+	fn process(&mut self, git_interactive: &mut GitInteractive, _view: &View) -> ProcessResult {
 		let mut result = ProcessResultBuilder::new();
 		match self.state {
 			EditState::Active => {},
@@ -45,6 +45,7 @@ impl ProcessModule for Edit {
 		&mut self,
 		input_handler: &InputHandler,
 		_git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		if self.state == EditState::Finish {
diff --git a/src/error/error.rs b/src/error/error.rs
index 84c4eca..4e631ad 100644
--- a/src/error/error.rs
+++ b/src/error/error.rs
@@ -27,6 +27,7 @@ impl ProcessModule for Error {
 		&mut self,
 		input_handler: &InputHandler,
 		_git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		let input = input_handler.get_input();
diff --git a/src/external_editor/external_editor.rs b/src/external_editor/external_editor.rs
index fe793e8..43befeb 100644
--- a/src/external_editor/external_editor.rs
+++ b/src/external_editor/external_editor.rs
@@ -31,7 +31,7 @@ impl<'e> ProcessModule for ExternalEditor<'e> {
 		self.state = ExternalEditorState::Active;
 	}
 
-	fn process(&mut self, git_interactive: &mut GitInteractive) -> ProcessResult {
+	fn process(&mut self, git_interactive: &mut GitInteractive, _view: &View) -> ProcessResult {
 		match self.state {
 			ExternalEditorState::Active => self.process_active(git_interactive),
 			ExternalEditorState::Error => self.process_error(git_interactive),
@@ -43,6 +43,7 @@ impl<'e> ProcessModule for ExternalEditor<'e> {
 		&mut self,
 		input_handler: &InputHandler,
 		_git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		match self.state {
diff --git a/src/help/help.rs b/src/help/help.rs
index 3eda151..34af153 100644
--- a/src/help/help.rs
+++ b/src/help/help.rs
@@ -36,6 +36,35 @@ impl ProcessModule for Help {
 		}
 	}
 
+	fn handle_input(
+		&mut self,
+		input_handler: &InputHandler,
+		_git_interactive: &mut GitInteractive,
+		view: &View,
+	) -> HandleInputResult
+	{
+		let (_, window_height) = view.get_view_size();
+		let input = input_handler.get_input();
+		let mut result = HandleInputResultBuilder::new(input);
+		match input {
+			Input::MoveCursorDown => {
+				self.scroll_position
+					.scroll_down(window_height, get_help_lines(&self.return_state).len());
+			},
+			Input::MoveCursorUp => {
+				self.scroll_position
+					.scroll_up(window_height, get_help_lines(&self.return_state).len());
+			},
+			Input::Resize => {
+				self.scroll_position.reset();
+			},
+			_ => {
+				result = result.state(self.return_state.clone());
+			},
+		}
+		result.build()
+	}
+
 	fn render(&self, view: &View, _git_interactive: &GitInteractive) {
 		let (view_width, view_height) = view.get_view_size();
 
@@ -72,34 +101,4 @@ impl Help {
 			scroll_position: ScrollPosition::new(3, 6, 3),
 		}
 	}
-
-	// TODO refactor to remove need for view
-	pub fn handle_input_with_view(
-		&mut self,
-		input_handler: &InputHandler,
-		_git_interactive: &mut GitInteractive,
-		view: &View,
-	) -> HandleInputResult
-	{
-		let (_, window_height) = view.get_view_size();
-		let input = input_handler.get_input();
-		let mut result = HandleInputResultBuilder::new(input);
-		match input {
-			Input::MoveCursorDown => {
-				self.scroll_position
-					.scroll_down(window_height, get_help_lines(&self.return_state).len());
-			},
-			Input::MoveCursorUp => {
-				self.scroll_position
-					.scroll_up(window_height, get_help_lines(&self.return_state).len());
-			},
-			Input::Resize => {
-				self.scroll_position.reset();
-			},
-			_ => {
-				result = result.state(self.return_state.clone());
-			},
-		}
-		result.build()
-	}
 }
diff --git a/src/list/list.rs b/src/list/list.rs
index 7676837..f604d92 100644
--- a/src/list/list.rs
+++ b/src/list/list.rs
@@ -34,10 +34,20 @@ pub struct List<'l> {
 }
 
 impl<'l> ProcessModule for List<'l> {
+	fn process(&mut self, git_interactive: &mut GitInteractive, view: &View) -> ProcessResult {
+		let (_, view_height) = view.get_view_size();
+		let lines = git_interactive.get_lines();
+		let selected_index = *git_interactive.get_selected_line_index() - 1;
+		self.scroll_position
+			.ensure_cursor_visible(selected_index, view_height, lines.len());
+		ProcessResult::new()
+	}
+
 	fn handle_input(
 		&mut self,
 		input_handler: &InputHandler,
 		git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		match self.state {
@@ -114,15 +124,6 @@ impl<'l> List<'l> {
 		}
 	}
 
-	pub fn process_with_view(&mut self, git_interactive: &mut GitInteractive, view: &View) -> ProcessResult {
-		let (_, view_height) = view.get_view_size();
-		let lines = git_interactive.get_lines();
-		let selected_index = *git_interactive.get_selected_line_index() - 1;
-		self.scroll_position
-			.ensure_cursor_visible(selected_index, view_height, lines.len());
-		ProcessResult::new()
-	}
-
 	fn handle_normal_mode_input(
 		&mut self,
 		input_handler: &InputHandler,
diff --git a/src/main.rs b/src/main.rs
index 17fd2d4..38bdc42 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,7 +2,6 @@
 #![cfg_attr(feature = "clippy", plugin(clippy))]
 
 mod action;
-mod application;
 mod cli;
 mod color;
 mod commit;
@@ -26,7 +25,6 @@ mod view;
 mod window;
 mod window_size_error;
 
-use crate::application::Application;
 use crate::config::Config;
 use crate::git_interactive::GitInteractive;
 use crate::input::InputHandler;
@@ -85,9 +83,10 @@ fn try_main() -> Result<ExitStatus, Exit> {
 
 	let input_handler = InputHandler::new(&window);
 
-	let mut application = Application::new(git_interactive, View::new(&window), &input_handler, &config);
+	let view = View::new(&window);
+
+	let mut process = Process::new(git_interactive, &view, &input_handler, &config);
 
-	let mut process = Process::new(&mut application);
 	let result = process.run();
 	window.end();
 
diff --git a/src/process/process.rs b/src/process/process.rs
index cf91d0d..d316162 100644
--- a/src/process/process.rs
+++ b/src/process/process.rs
@@ -1,20 +1,63 @@
-use crate::application::Application;
-use crate::input::Input;
+use crate::config::Config;
+use crate::confirm_abort::ConfirmAbort;
+use crate::confirm_rebase::ConfirmRebase;
+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> {
-	application: &'r mut Application<'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,
+	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(application: &'r mut Application<'r>) -> Self {
+	pub fn new(
+		git_interactive: GitInteractive,
+		view: &'r View<'r>,
+		input_handler: &'r InputHandler<'r>,
+		config: &'r Config,
+	) -> Self
+	{
 		Self {
-			application,
+			confirm_abort: ConfirmAbort::new(),
+			confirm_rebase: ConfirmRebase::new(),
+			edit: Edit::new(),
+			error: Error::new(),
 			exit_status: None,
+			exiting: Exiting::new(),
+			external_editor: ExternalEditor::new(config),
+			git_interactive,
+			help: Help::new(),
+			input_handler,
+			list: List::new(config),
+			show_commit: ShowCommit::new(),
 			state: RefCell::new(State::List(false)),
+			view,
+			window_size_error: WindowSizeError::new(),
 		}
 	}
 
@@ -29,8 +72,50 @@ impl<'r> Process<'r> {
 		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 = self.application.process(self.get_state());
+		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);
@@ -38,19 +123,73 @@ impl<'r> Process<'r> {
 
 		if let Some(new_state) = result.state {
 			if new_state != self.get_state() {
-				self.application.deactivate(self.get_state());
+				self.deactivate();
 				self.set_state(new_state);
-				self.application.activate(self.get_state());
+				self.activate();
 			}
 		}
 	}
 
 	fn render(&self) {
-		self.application.render(self.get_state());
+		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 = self.application.handle_input(self.get_state());
+		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);
@@ -58,9 +197,9 @@ impl<'r> Process<'r> {
 
 		if let Some(new_state) = result.state {
 			if new_state != self.get_state() {
-				self.application.deactivate(self.get_state());
+				self.deactivate();
 				self.set_state(new_state);
-				self.application.activate(self.get_state());
+				self.activate();
 			}
 		}
 
@@ -70,7 +209,7 @@ impl<'r> Process<'r> {
 	}
 
 	fn check_window_size(&self) {
-		let check = self.application.check_window_size();
+		let check = self.view.check_window_size();
 		let state = self.get_state();
 		if let State::WindowSizeError(return_state) = state {
 			if check {
@@ -91,7 +230,7 @@ impl<'r> Process<'r> {
 	}
 
 	fn exit_end(&mut self) -> Result<(), String> {
-		match self.application.write_file() {
+		match self.git_interactive.write_file() {
 			Ok(_) => {},
 			Err(msg) => {
 				self.exit_status = Some(ExitStatus::FileWriteError);
diff --git a/src/process/process_module.rs b/src/process/process_module.rs
index f3027d8..bf98a79 100644
--- a/src/process/process_module.rs
+++ b/src/process/process_module.rs
@@ -8,7 +8,7 @@ pub trait ProcessModule {
 
 	fn deactivate(&mut self) {}
 
-	fn process(&mut self, _git_interactive: &mut GitInteractive) -> ProcessResult {
+	fn process(&mut self, _git_interactive: &mut GitInteractive, _view: &View) -> ProcessResult {
 		ProcessResult::new()
 	}
 
@@ -16,6 +16,7 @@ pub trait ProcessModule {
 		&mut self,
 		_input_handler: &InputHandler,
 		_git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		HandleInputResult::new(Input::Other)
diff --git a/src/show_commit/show_commit.rs b/src/show_commit/show_commit.rs
index 1d50ffa..f61a0d4 100644
--- a/src/show_commit/show_commit.rs
+++ b/src/show_commit/show_commit.rs
@@ -24,7 +24,7 @@ impl ProcessModule for ShowCommit {
 		self.scroll_position.reset();
 	}
 
-	fn process(&mut self, git_interactive: &mut GitInteractive) -> ProcessResult {
+	fn process(&mut self, git_interactive: &mut GitInteractive, _view: &View) -> ProcessResult {
 		let mut result = ProcessResultBuilder::new();
 		if let Err(e) = git_interactive.load_commit_stats() {
 			result = result.error(e.as_str(), State::List(false));
@@ -32,6 +32,37 @@ impl ProcessModule for ShowCommit {
 		result.build()
 	}
 
+	fn handle_input(
+		&mut self,
+		input_handler: &InputHandler,
+		git_interactive: &mut GitInteractive,
+		view: &View,
+	) -> HandleInputResult
+	{
+		let (_, window_height) = view.get_view_size();
+
+		let input = input_handler.get_input();
+		let mut result = HandleInputResultBuilder::new(input);
+		match input {
+			Input::MoveCursorDown => {
+				self.scroll_position
+					.scroll_down(window_height, git_interactive.get_commit_stats_length())
+			},
+			Input::MoveCursorUp => {
+				self.scroll_position
+					.scroll_up(window_height, git_interactive.get_commit_stats_length())
+			},
+			Input::Resize => {
+				self.scroll_position
+					.scroll_up(window_height as usize, git_interactive.get_commit_stats_length());
+			},
+			_ => {
+				result = result.state(State::List(false));
+			},
+		}
+		result.build()
+	}
+
 	fn render(&self, view: &View, git_interactive: &GitInteractive) {
 		let commit_data = git_interactive.get_commit_stats();
 		let (window_width, window_height) = view.get_view_size();
@@ -142,35 +173,4 @@ impl ShowCommit {
 			scroll_position: ScrollPosition::new(3, 6, 3),
 		}
 	}
-
-	pub fn handle_input_with_view(
-		&mut self,
-		input_handler: &InputHandler,
-		git_interactive: &mut GitInteractive,
-		view: &View,
-	) -> HandleInputResult
-	{
-		let (_, window_height) = view.get_view_size();
-
-		let input = input_handler.get_input();
-		let mut result = HandleInputResultBuilder::new(input);
-		match input {
-			Input::MoveCursorDown => {
-				self.scroll_position
-					.scroll_down(window_height, git_interactive.get_commit_stats_length())
-			},
-			Input::MoveCursorUp => {
-				self.scroll_position
-					.scroll_up(window_height, git_interactive.get_commit_stats_length())
-			},
-			Input::Resize => {
-				self.scroll_position
-					.scroll_up(window_height as usize, git_interactive.get_commit_stats_length());
-			},
-			_ => {
-				result = result.state(State::List(false));
-			},
-		}
-		result.build()
-	}
 }
diff --git a/src/window_size_error/window_size_error.rs b/src/window_size_error/window_size_error.rs
index 6a7c17c..b86529c 100644
--- a/src/window_size_error/window_size_error.rs
+++ b/src/window_size_error/window_size_error.rs
@@ -19,6 +19,7 @@ impl ProcessModule for WindowSizeError {
 		&mut self,
 		input_handler: &InputHandler,
 		_git_interactive: &mut GitInteractive,
+		_view: &View,
 	) -> HandleInputResult
 	{
 		HandleInputResult::new(input_handler.get_input())