6883077488

Committed 15 Nov 2023 09:23PM CUT coverage: 93.248% (-0.4%) from 93.64%

Build # 6883077488

Build Type

Pull #873

github

Committed by

web-flow

Commit Message

Merge 0ab516642 into d7655157f

Pull Request Pull Request #873: When editing in the middle of a rebase, dont clear on quit

Run Details

45 of 72 new or added lines in 14 files covered. (62.5%)

1 existing line in 1 file now uncovered.

4792 of 5139 relevant lines covered (93.25%)

3.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.68

/src/todo_file/src/lib.rs

// LINT-REPLACE-START
// This section is autogenerated, do not modify directly
// nightly sometimes removes/renames lints
#![cfg_attr(allow_unknown_lints, allow(unknown_lints))]
#![cfg_attr(allow_unknown_lints, allow(renamed_and_removed_lints))]
// enable all rustc's built-in lints
#![deny(
        future_incompatible,
        nonstandard_style,
        rust_2018_compatibility,
        rust_2018_idioms,
        rust_2021_compatibility,
        unused,
        warnings
)]
// rustc's additional allowed by default lints
#![deny(
        absolute_paths_not_starting_with_crate,
        deprecated_in_future,
        elided_lifetimes_in_paths,
        explicit_outlives_requirements,
        ffi_unwind_calls,
        keyword_idents,
        let_underscore_drop,
        macro_use_extern_crate,
        meta_variable_misuse,
        missing_abi,
        missing_copy_implementations,
        missing_debug_implementations,
        missing_docs,
        non_ascii_idents,
        noop_method_call,
        pointer_structural_match,
        rust_2021_incompatible_closure_captures,
        rust_2021_incompatible_or_patterns,
        rust_2021_prefixes_incompatible_syntax,
        rust_2021_prelude_collisions,
        single_use_lifetimes,
        trivial_casts,
        trivial_numeric_casts,
        unreachable_pub,
        unsafe_code,
        unsafe_op_in_unsafe_fn,
        unused_crate_dependencies,
        unused_extern_crates,
        unused_import_braces,
        unused_lifetimes,
        unused_macro_rules,
        unused_qualifications,
        unused_results,
        unused_tuple_struct_fields,
        variant_size_differences
)]
// enable all of Clippy's lints
#![deny(clippy::all, clippy::cargo, clippy::pedantic, clippy::restriction)]
#![allow(
        clippy::arithmetic_side_effects,
        clippy::arithmetic_side_effects,
        clippy::blanket_clippy_restriction_lints,
        clippy::bool_to_int_with_if,
        clippy::default_numeric_fallback,
        clippy::else_if_without_else,
        clippy::expect_used,
        clippy::float_arithmetic,
        clippy::implicit_return,
        clippy::indexing_slicing,
        clippy::map_err_ignore,
        clippy::min_ident_chars,
        clippy::missing_docs_in_private_items,
        clippy::missing_trait_methods,
        clippy::mod_module_files,
        clippy::module_name_repetitions,
        clippy::needless_raw_strings,
        clippy::new_without_default,
        clippy::non_ascii_literal,
        clippy::option_if_let_else,
        clippy::pattern_type_mismatch,
        clippy::pub_use,
        clippy::pub_with_shorthand,
        clippy::question_mark_used,
        clippy::redundant_closure_call,
        clippy::redundant_pub_crate,
        clippy::ref_patterns,
        clippy::single_call_fn,
        clippy::std_instead_of_alloc,
        clippy::std_instead_of_core,
        clippy::tabs_in_doc_comments,
        clippy::tests_outside_test_module,
        clippy::too_many_lines,
        clippy::unwrap_used
)]
#![deny(
        rustdoc::bare_urls,
        rustdoc::broken_intra_doc_links,
        rustdoc::invalid_codeblock_attributes,
        rustdoc::invalid_html_tags,
        rustdoc::missing_crate_level_docs,
        rustdoc::private_doc_tests,
        rustdoc::private_intra_doc_links
)]
// allow some things in tests
#![cfg_attr(
        test,
        allow(
                let_underscore_drop,
                clippy::cognitive_complexity,
                clippy::let_underscore_must_use,
                clippy::let_underscore_untyped,
                clippy::needless_pass_by_value,
                clippy::panic,
                clippy::shadow_reuse,
                clippy::shadow_unrelated,
                clippy::undocumented_unsafe_blocks,
                clippy::unimplemented,
                clippy::unreachable
        )
)]
// allowable upcoming nightly lints
#![cfg_attr(include_nightly_lints, allow(clippy::absolute_paths, clippy::arc_with_non_send_sync))]
// LINT-REPLACE-END

//! Git Interactive Rebase Tool - Todo File Module
//!
//! # Description
//! This module is used to handle working with the rebase todo file.

mod action;
mod edit_content;
pub mod errors;
mod history;
mod line;
mod line_parser;
mod search;
mod state;
#[cfg(not(tarpaulin_include))]
pub mod testutil;
mod todo_file_options;
mod utils;

use std::{
        fs::{read_to_string, File},
        io::Write,
        path::{Path, PathBuf},
        slice::Iter,
};

use state::detect_state;
pub use version_track::Version;

pub use self::{
        action::Action,
        edit_content::EditContext,
        line::Line,
        search::Search,
        state::State,
        todo_file_options::TodoFileOptions,
};
use self::{
        history::{History, HistoryItem},
        utils::{remove_range, swap_range_down, swap_range_up},
};
use crate::{
        errors::{FileReadErrorCause, IoError},
        history::Operation,
};

/// Represents a rebase file.
#[derive(Debug)]
pub struct TodoFile {
        filepath: PathBuf,
        history: History,
        is_noop: bool,
        lines: Vec<Line>,
        options: TodoFileOptions,
        selected_line_index: usize,
        version: Version,
        state: State,
}

impl TodoFile {
        /// Create a new instance.
        #[must_use]
        #[inline]
        pub fn new<Path: AsRef<std::path::Path>>(path: Path, options: TodoFileOptions) -> Self {
                let history = History::new(options.undo_limit);

                Self {
                        filepath: PathBuf::from(path.as_ref()),
                        history,
                        is_noop: false,
                        lines: vec![],
                        options,
                        selected_line_index: 0,
                        version: Version::new(),
                        state: State::Initial,
                }
        }

        /// Set the rebase lines.
        #[inline]
        pub fn set_lines(&mut self, lines: Vec<Line>) {
                self.is_noop = !lines.is_empty() && lines[0].get_action() == &Action::Noop;
                self.lines = if self.is_noop {
                        vec![]
                }
                else {
                        lines.into_iter().filter(|l| l.get_action() != &Action::Noop).collect()
                };
                if self.selected_line_index >= self.lines.len() {
                        self.selected_line_index = if self.lines.is_empty() { 0 } else { self.lines.len() - 1 };
                }
                self.version.reset();
                self.history.reset();
        }

        /// Set the rebase todo file state.
        #[inline]
        pub fn set_state(&mut self, state: State) {
                self.state = state;
        }

        /// Load the rebase file from disk.
        ///
        /// # Errors
        ///
        /// Returns error if the file cannot be read.
        #[inline]
        pub fn load_file(&mut self) -> Result<(), IoError> {
                let lines: Result<Vec<Line>, IoError> = read_to_string(self.filepath.as_path())
                        .map_err(|err| {
                                IoError::FileRead {
                                        file: self.filepath.clone(),
                                        cause: FileReadErrorCause::from(err),
                                }
                        })?
                        .lines()
                        .filter_map(|l| {
                                if l.starts_with(self.options.comment_prefix.as_str()) || l.is_empty() {
                                        None
                                }
                                else {
                                        Some(Line::parse(l).map_err(|err| {
                                                IoError::FileRead {
                                                        file: self.filepath.clone(),
                                                        cause: FileReadErrorCause::from(err),
                                                }
                                        }))
                                }
                        })
                        .collect();
                self.set_lines(lines?);
                self.set_state(detect_state(&self.filepath)?);
                Ok(())
        }

        /// Write the rebase file to disk.
        /// # Errors
        ///
        /// Returns error if the file cannot be written.
        #[inline]
        pub fn write_file(&self) -> Result<(), IoError> {
                let mut file = File::create(&self.filepath).map_err(|err| {
                        IoError::FileRead {
                                file: self.filepath.clone(),
                                cause: FileReadErrorCause::from(err),
                        }
                })?;
                let file_contents = if self.is_noop {
                        String::from("noop")
                }
                else {
                        self.lines
                                .iter()
                                .flat_map(|l| {
                                        let mut lines = vec![Line::to_text(l)];
                                        if let Some(command) = self.options.line_changed_command.as_deref() {
                                                if l.is_modified() {
                                                        let action = l.get_action();

                                                        match *action {
                                                                Action::Break | Action::Noop => {},
                                                                Action::Cut
                                                                | Action::Drop
                                                                | Action::Fixup
                                                                | Action::Edit
                                                                | Action::Index
                                                                | Action::Pick
                                                                | Action::Reword
                                                                | Action::Squash => {
                                                                        lines.push(format!("exec {command} \"{}\" \"{}\"", action, l.get_hash()));
                                                                },
                                                                Action::Exec | Action::Label | Action::Reset | Action::Merge | Action::UpdateRef => {
                                                                        let original_label =
                                                                                l.original().map_or_else(|| l.get_content(), Line::get_content);
                                                                        lines.push(format!(
                                                                                "exec {command} \"{}\" \"{}\" \"{}\"",
                                                                                action,
                                                                                original_label,
                                                                                l.get_content()
                                                                        ));
                                                                },
                                                        }
                                                }
                                        }
                                        lines
                                })
                                .collect::<Vec<String>>()
                                .join("\n")
                };
                writeln!(file, "{file_contents}").map_err(|err| {
                        IoError::FileRead {
                                file: self.filepath.clone(),
                                cause: FileReadErrorCause::from(err),
                        }
                })?;
                Ok(())
        }

        /// Set the selected line index returning the new index based after ensuring within range.
        #[inline]
        pub fn set_selected_line_index(&mut self, selected_line_index: usize) -> usize {
                self.selected_line_index = if self.lines.is_empty() {
                        0
                }
                else if selected_line_index >= self.lines.len() {
                        self.lines.len() - 1
                }
                else {
                        selected_line_index
                };
                self.selected_line_index
        }

        /// Swap a range of lines up.
        #[inline]
        pub fn swap_range_up(&mut self, start_index: usize, end_index: usize) -> bool {
                if end_index == 0 || start_index == 0 || self.lines.is_empty() {
                        return false;
                }

                let max_index = self.lines.len() - 1;
                let end = if end_index > max_index { max_index } else { end_index };
                let start = if start_index > max_index {
                        max_index
                }
                else {
                        start_index
                };

                swap_range_up(&mut self.lines, start, end);
                self.version.increment();
                self.history.record(HistoryItem::new_swap_up(start, end));
                true
        }

        /// Swap a range of lines down.
        #[inline]
        pub fn swap_range_down(&mut self, start_index: usize, end_index: usize) -> bool {
                let len = self.lines.len();
                let max_index = if len == 0 { 0 } else { len - 1 };

                if end_index == max_index || start_index == max_index {
                        return false;
                }

                swap_range_down(&mut self.lines, start_index, end_index);
                self.version.increment();
                self.history.record(HistoryItem::new_swap_down(start_index, end_index));
                true
        }

        /// Add a new line.
        #[inline]
        pub fn add_line(&mut self, index: usize, line: Line) {
                let i = if index > self.lines.len() {
                        self.lines.len()
                }
                else {
                        index
                };
                self.lines.insert(i, line);
                self.version.increment();
                self.history.record(HistoryItem::new_add(i, i));
        }

        /// Remove a range of lines.
        #[inline]
        pub fn remove_lines(&mut self, start_index: usize, end_index: usize) {
                if self.lines.is_empty() {
                        return;
                }

                let max_index = self.lines.len() - 1;
                let end = if end_index > max_index { max_index } else { end_index };
                let start = if start_index > max_index {
                        max_index
                }
                else {
                        start_index
                };

                let removed_lines = remove_range(&mut self.lines, start, end);
                self.version.increment();
                self.history.record(HistoryItem::new_remove(start, end, removed_lines));
        }

        /// Update a range of lines.
        #[inline]
        pub fn update_range(&mut self, start_index: usize, end_index: usize, edit_context: &EditContext) {
                if self.lines.is_empty() {
                        return;
                }

                let max_index = self.lines.len() - 1;
                let end = if end_index > max_index { max_index } else { end_index };
                let start = if start_index > max_index {
                        max_index
                }
                else {
                        start_index
                };

                let range = if end <= start { end..=start } else { start..=end };

                let mut lines = vec![];
                for index in range {
                        let line = &mut self.lines[index];
                        lines.push(line.clone());
                        if let Some(action) = edit_context.get_action() {
                                line.set_action(action);
                        }

                        if let Some(content) = edit_context.get_content() {
                                line.edit_content(content);
                        }

                        if let Some(option) = edit_context.get_option() {
                                line.toggle_option(option);
                        }
                }
                self.version.increment();
                self.history.record(HistoryItem::new_modify(start, end, lines));
        }

        /// Undo the last modification.
        #[inline]
        pub fn undo(&mut self) -> Option<(usize, usize)> {
                self.version.increment();
                if let Some((operation, start, end)) = self.history.undo(&mut self.lines) {
                        return if operation == Operation::Load {
                                None
                        }
                        else {
                                Some((start, end))
                        };
                }
                None
        }

        /// Redo the last undone modification.
        #[inline]
        pub fn redo(&mut self) -> Option<(usize, usize)> {
                self.version.increment();
                self.history.redo(&mut self.lines).map(|(_, start, end)| (start, end))
        }

        /// Get the current version
        #[must_use]
        #[inline]
        pub const fn version(&self) -> &Version {
                &self.version
        }

        /// Get the current state
        #[must_use]
        #[inline]
        pub const fn state(&self) -> &State {
                &self.state
        }

        /// Get the selected line.
        #[must_use]
        #[inline]
        pub fn get_selected_line(&self) -> Option<&Line> {
                self.lines.get(self.selected_line_index)
        }

        /// Get the index of the last line that can be selected.
        #[must_use]
        #[inline]
        pub fn get_max_selected_line_index(&self) -> usize {
                let len = self.lines.len();
                if len == 0 { 0 } else { len - 1 }
        }

        /// Get the selected line index
        #[must_use]
        #[inline]
        pub const fn get_selected_line_index(&self) -> usize {
                self.selected_line_index
        }

        /// Get the file path to the rebase file.
        #[must_use]
        #[inline]
        pub fn get_filepath(&self) -> &Path {
                self.filepath.as_path()
        }

        /// Get a line by index.
        #[must_use]
        #[inline]
        pub fn get_line(&self, index: usize) -> Option<&Line> {
                self.lines.get(index)
        }

        /// Get an owned copy of the lines.
        #[must_use]
        #[inline]
        pub fn get_lines_owned(&self) -> Vec<Line> {
                self.lines.clone()
        }

        /// Is the rebase file a noop.
        #[must_use]
        #[inline]
        pub const fn is_noop(&self) -> bool {
                self.is_noop
        }

        /// Get an iterator over the lines.
        #[inline]
        pub fn lines_iter(&self) -> Iter<'_, Line> {
                self.lines.iter()
        }

        /// Does the rebase file contain no lines.
        #[must_use]
        #[inline]
        pub fn is_empty(&self) -> bool {
                self.lines.is_empty()
        }
}

#[cfg(test)]
mod tests {
        use claims::{assert_none, assert_some_eq};
        use tempfile::{Builder, NamedTempFile};
        use testutils::{assert_empty, assert_not_empty};

        use super::*;

        fn create_line(line: &str) -> Line {
                Line::parse(line).unwrap()
        }

        fn create_and_load_todo_file_with_options(
                file_contents: &[&str],
                todo_file_options: TodoFileOptions,
        ) -> (TodoFile, NamedTempFile) {
                let todo_file_path = Builder::new()
                        .prefix("git-rebase-todo-scratch")
                        .suffix("")
                        .tempfile()
                        .unwrap();
                write!(todo_file_path.as_file(), "{}", file_contents.join("\n")).unwrap();
                let mut todo_file = TodoFile::new(todo_file_path.path().to_str().unwrap(), todo_file_options);
                todo_file.load_file().unwrap();
                (todo_file, todo_file_path)
        }

        fn create_and_load_todo_file(file_contents: &[&str]) -> (TodoFile, NamedTempFile) {
                create_and_load_todo_file_with_options(file_contents, TodoFileOptions::new(1, "#"))
        }

        macro_rules! assert_read_todo_file {
                ($todo_file_path:expr, $($arg:expr),*) => {
                        let expected = [$( $arg, )*];
                        let content = read_to_string(Path::new($todo_file_path)).unwrap();
                        pretty_assertions::assert_str_eq!(content, format!("{}\n", expected.join("\n")));
                };
        }

        macro_rules! assert_todo_lines {
                ($todo_file_path:expr, $($arg:expr),*) => {
                        let actual_lines = $todo_file_path.get_lines_owned();

                        let expected = vec![$( create_line($arg), )*];
                        pretty_assertions::assert_str_eq!(
                                actual_lines.iter().map(Line::to_text).collect::<Vec<String>>().join("\n"),
                                expected.iter().map(Line::to_text).collect::<Vec<String>>().join("\n")
                        );
                };
        }

        #[test]
        fn load_file() {
                let (todo_file, _) = create_and_load_todo_file(&["pick aaa foobar"]);
                assert_todo_lines!(todo_file, "pick aaa foobar");
                assert_ne!(todo_file.version(), &Version::new());
        }

        #[test]
        fn load_noop_file() {
                let (todo_file, _) = create_and_load_todo_file(&["noop"]);
                assert_empty!(todo_file);
                assert!(todo_file.is_noop());
        }

        #[test]
        fn load_ignore_comments() {
                let (todo_file, _) = create_and_load_todo_file(&["# pick aaa comment", "pick aaa foo", "# pick aaa comment"]);
                assert_todo_lines!(todo_file, "pick aaa foo");
        }

        #[test]
        fn load_ignore_newlines() {
                let (todo_file, _) = create_and_load_todo_file(&["", "pick aaa foobar", ""]);
                assert_todo_lines!(todo_file, "pick aaa foobar");
        }

        #[test]
        fn set_lines() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                let old_version = todo_file.version;
                todo_file.set_lines(vec![create_line("pick bbb comment")]);
                assert_todo_lines!(todo_file, "pick bbb comment");
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn set_lines_reset_history() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                todo_file.history.record(HistoryItem::new_add(1, 1));
                todo_file.set_lines(vec![create_line("pick bbb comment")]);
                assert_none!(todo_file.undo());
        }

        #[test]
        fn set_lines_reset_selected_index() {
                let (mut todo_file, _) = create_and_load_todo_file(&["pick a a", "pick b b", "pick c c"]);
                todo_file.selected_line_index = 2;
                todo_file.set_lines(vec![create_line("pick a a"), create_line("pick b b")]);
                assert_eq!(todo_file.selected_line_index, 1);
        }

        #[test]
        fn set_lines_reset_selected_index_empty_lis() {
                let (mut todo_file, _) = create_and_load_todo_file(&["pick a a", "pick b b", "pick c c"]);
                todo_file.selected_line_index = 2;
                todo_file.set_lines(vec![]);
                assert_eq!(todo_file.selected_line_index, 0);
        }

        #[test]
        fn write_file() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                todo_file.set_lines(vec![create_line("pick bbb comment")]);
                todo_file.write_file().unwrap();
                assert_todo_lines!(todo_file, "pick bbb comment");
        }

        #[test]
        fn write_file_with_exec_command_modified_line_with_reference() {
                fn create_modified_line(action: &str) -> Line {
                        let mut parsed = create_line(format!("{action} label").as_str());
                        parsed.edit_content("new-label");
                        parsed
                }
                let mut options = TodoFileOptions::new(10, "#");
                options.line_changed_command("command");
                let (mut todo_file, _) = create_and_load_todo_file_with_options(&[], options);
                todo_file.set_lines(vec![
                        create_modified_line("label"),
                        create_modified_line("reset"),
                        create_modified_line("merge"),
                        create_modified_line("update-ref"),
                ]);
                todo_file.write_file().unwrap();
                assert_read_todo_file!(
                        todo_file.get_filepath(),
                        "label new-label",
                        "exec command \"label\" \"label\" \"new-label\"",
                        "reset new-label",
                        "exec command \"reset\" \"label\" \"new-label\"",
                        "merge new-label",
                        "exec command \"merge\" \"label\" \"new-label\"",
                        "update-ref new-label",
                        "exec command \"update-ref\" \"label\" \"new-label\""
                );
        }

        #[test]
        fn write_file_with_exec_command_modified_line_with_hash() {
                fn create_modified_line(action: &str) -> Line {
                        let mut parsed = create_line(format!("{action} bbb comment").as_str());
                        parsed.set_action(
                                if parsed.get_action() == &Action::Fixup {
                                        Action::Pick
                                }
                                else {
                                        Action::Fixup
                                },
                        );
                        parsed
                }
                let mut options = TodoFileOptions::new(10, "#");
                options.line_changed_command("command");
                let (mut todo_file, _) = create_and_load_todo_file_with_options(&[], options);
                let mut line = create_line("pick bbb comment");
                line.set_action(Action::Fixup);
                todo_file.set_lines(vec![
                        create_modified_line("drop"),
                        create_modified_line("fixup"),
                        create_modified_line("edit"),
                        create_modified_line("pick"),
                        create_modified_line("reword"),
                        create_modified_line("squash"),
                ]);
                todo_file.write_file().unwrap();
                assert_read_todo_file!(
                        todo_file.get_filepath(),
                        "fixup bbb comment",
                        "exec command \"fixup\" \"bbb\"",
                        "pick bbb comment",
                        "exec command \"pick\" \"bbb\"",
                        "fixup bbb comment",
                        "exec command \"fixup\" \"bbb\"",
                        "fixup bbb comment",
                        "exec command \"fixup\" \"bbb\"",
                        "fixup bbb comment",
                        "exec command \"fixup\" \"bbb\"",
                        "fixup bbb comment",
                        "exec command \"fixup\" \"bbb\""
                );
        }

        #[test]
        fn write_file_with_exec_command_modified_line_with_exec() {
                let mut options = TodoFileOptions::new(10, "#");
                options.line_changed_command("command");
                let (mut todo_file, _) = create_and_load_todo_file_with_options(&[], options);
                let mut line = create_line("exec command");
                line.edit_content("new-command");
                todo_file.set_lines(vec![line]);
                todo_file.write_file().unwrap();
                assert_read_todo_file!(
                        todo_file.get_filepath(),
                        "exec new-command",
                        "exec command \"exec\" \"command\" \"new-command\""
                );
        }

        #[test]
        fn write_file_with_exec_command_modified_line_with_break() {
                let mut options = TodoFileOptions::new(10, "#");
                options.line_changed_command("command");
                let (mut todo_file, _) = create_and_load_todo_file_with_options(&[], options);
                todo_file.set_lines(vec![create_line("break")]);
                todo_file.write_file().unwrap();
                assert_read_todo_file!(todo_file.get_filepath(), "break");
        }

        #[test]
        fn write_file_noop() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                todo_file.set_lines(vec![create_line("noop")]);
                todo_file.write_file().unwrap();
                assert_read_todo_file!(todo_file.get_filepath(), "noop");
        }

        #[test]
        fn add_line_index_miss() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.add_line(100, create_line("fixup ddd comment"));
                assert_todo_lines!(
                        todo_file,
                        "pick aaa comment",
                        "drop bbb comment",
                        "edit ccc comment",
                        "fixup ddd comment"
                );
        }

        #[test]
        fn add_line() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                let old_version = *todo_file.version();
                todo_file.add_line(1, create_line("fixup ddd comment"));
                assert_todo_lines!(
                        todo_file,
                        "pick aaa comment",
                        "fixup ddd comment",
                        "drop bbb comment",
                        "edit ccc comment"
                );
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn add_line_record_history() {
                let (mut todo_file, _) = create_and_load_todo_file(&["pick aaa comment"]);
                todo_file.add_line(1, create_line("fixup ddd comment"));
                let _undo_result = todo_file.undo();
                assert_todo_lines!(todo_file, "pick aaa comment");
        }

        #[test]
        fn remove_lines_index_miss_start() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.remove_lines(100, 1);
                assert_todo_lines!(todo_file, "pick aaa comment");
        }

        #[test]
        fn remove_lines_index_miss_end() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.remove_lines(1, 100);
                assert_todo_lines!(todo_file, "pick aaa comment");
        }

        #[test]
        fn remove_lines_index_miss_start_and_end() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.remove_lines(100, 100);
                assert_todo_lines!(todo_file, "pick aaa comment", "drop bbb comment");
        }

        #[test]
        fn remove_lines() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                let old_version = *todo_file.version();
                todo_file.remove_lines(1, 1);
                assert_todo_lines!(todo_file, "pick aaa comment", "edit ccc comment");
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn remove_lines_empty_list() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                todo_file.remove_lines(1, 1);
        }

        #[test]
        fn remove_lines_record_history() {
                let (mut todo_file, _) = create_and_load_todo_file(&["pick aaa comment", "edit ccc comment"]);
                todo_file.remove_lines(1, 1);
                let _undo_result = todo_file.undo();
                assert_todo_lines!(todo_file, "pick aaa comment", "edit ccc comment");
        }

        #[test]
        fn update_range_full_set_action() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                let old_version = *todo_file.version();
                todo_file.update_range(0, 2, &EditContext::new().action(Action::Reword));
                assert_todo_lines!(
                        todo_file,
                        "reword aaa comment",
                        "reword bbb comment",
                        "reword ccc comment"
                );
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn update_range_full_set_content() {
                let (mut todo_file, _) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                todo_file.update_range(0, 2, &EditContext::new().content("echo"));
                assert_todo_lines!(todo_file, "exec echo", "exec echo", "exec echo");
        }

        #[test]
        fn update_range_set_option() {
                let (mut todo_file, _) = create_and_load_todo_file(&["fixup aaa comment"]);
                let old_version = *todo_file.version();
                todo_file.update_range(0, 2, &EditContext::new().option("-c"));
                assert_todo_lines!(todo_file, "fixup -c aaa comment");
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn update_range_reverse_indexes() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.update_range(2, 0, &EditContext::new().action(Action::Reword));
                assert_todo_lines!(
                        todo_file,
                        "reword aaa comment",
                        "reword bbb comment",
                        "reword ccc comment"
                );
        }

        #[test]
        fn update_range_record_history() {
                let (mut todo_file, _) = create_and_load_todo_file(&["pick aaa comment"]);
                todo_file.update_range(0, 0, &EditContext::new().action(Action::Reword));
                let _undo_result = todo_file.undo();
                assert_todo_lines!(todo_file, "pick aaa comment");
        }

        #[test]
        fn update_range_empty_list() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                todo_file.update_range(0, 0, &EditContext::new().action(Action::Reword));
        }

        #[test]
        fn update_range_start_index_overflow() {
                let (mut todo_file, _) = create_and_load_todo_file(&["pick aaa comment", "pick bbb comment"]);
                todo_file.update_range(2, 0, &EditContext::new().action(Action::Reword));
                assert_todo_lines!(todo_file, "reword aaa comment", "reword bbb comment");
        }

        #[test]
        fn update_range_end_index_overflow() {
                let (mut todo_file, _) = create_and_load_todo_file(&["pick aaa comment", "pick bbb comment"]);
                todo_file.update_range(0, 2, &EditContext::new().action(Action::Reword));
                assert_todo_lines!(todo_file, "reword aaa comment", "reword bbb comment");
        }

        #[test]
        fn undo_load_operation() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                assert_none!(todo_file.undo());
        }

        #[test]
        fn undo_empty_history() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                // set short history, to remove load entry
                todo_file.history = History::new(1);
                todo_file.update_range(0, 0, &EditContext::new().action(Action::Drop));
                _ = todo_file.undo(); // remove Drop operation
                assert_none!(todo_file.undo());
        }

        #[test]
        fn undo_operation() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.update_range(0, 1, &EditContext::new().action(Action::Drop));
                assert_some_eq!(todo_file.undo(), (0, 1));
        }

        #[test]
        fn history_undo_redo() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.update_range(0, 0, &EditContext::new().action(Action::Drop));
                let old_version = *todo_file.version();
                let _undo_result = todo_file.undo();
                assert_todo_lines!(todo_file, "pick aaa comment", "drop bbb comment", "edit ccc comment");
                assert_ne!(todo_file.version(), &old_version);
                let old_version = *todo_file.version();
                _ = todo_file.redo();
                assert_todo_lines!(todo_file, "drop aaa comment", "drop bbb comment", "edit ccc comment");
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn redo_empty_history() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                assert_none!(todo_file.redo());
        }

        #[test]
        fn redo_operation() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "drop bbb comment", "edit ccc comment"]);
                todo_file.update_range(0, 1, &EditContext::new().action(Action::Drop));
                _ = todo_file.undo();
                assert_some_eq!(todo_file.redo(), (0, 1));
        }

        #[test]
        fn swap_up() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                let old_version = *todo_file.version();
                assert!(todo_file.swap_range_up(1, 2));
                assert_todo_lines!(todo_file, "pick bbb comment", "pick ccc comment", "pick aaa comment");
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn swap_up_records_history() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                _ = todo_file.swap_range_up(1, 2);
                let _undo_result = todo_file.undo();
                assert_todo_lines!(todo_file, "pick aaa comment", "pick bbb comment", "pick ccc comment");
        }

        #[test]
        fn swap_up_reverse_index() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(todo_file.swap_range_up(2, 1));
                assert_todo_lines!(todo_file, "pick bbb comment", "pick ccc comment", "pick aaa comment");
        }

        #[test]
        fn swap_up_single_line() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(todo_file.swap_range_up(1, 1));
                assert_todo_lines!(todo_file, "pick bbb comment", "pick aaa comment", "pick ccc comment");
        }

        #[test]
        fn swap_up_at_top_start_index() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(!todo_file.swap_range_up(0, 1));
                assert_todo_lines!(todo_file, "pick aaa comment", "pick bbb comment", "pick ccc comment");
        }

        #[test]
        fn swap_up_at_top_end_index() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(!todo_file.swap_range_up(1, 0));
                assert_todo_lines!(todo_file, "pick aaa comment", "pick bbb comment", "pick ccc comment");
        }

        #[test]
        fn swap_up_start_index_overflow() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(todo_file.swap_range_up(3, 1));
                assert_todo_lines!(todo_file, "pick bbb comment", "pick ccc comment", "pick aaa comment");
        }

        #[test]
        fn swap_up_end_index_overflow() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(todo_file.swap_range_up(3, 1));
                assert_todo_lines!(todo_file, "pick bbb comment", "pick ccc comment", "pick aaa comment");
        }

        #[test]
        fn swap_up_empty_list_index_out_of_bounds() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                assert!(!todo_file.swap_range_up(1, 1));
        }

        #[test]
        fn swap_down() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                let old_version = *todo_file.version();
                assert!(todo_file.swap_range_down(0, 1));
                assert_todo_lines!(todo_file, "pick ccc comment", "pick aaa comment", "pick bbb comment");
                assert_ne!(todo_file.version(), &old_version);
        }

        #[test]
        fn swap_down_records_history() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                let _swap_result = todo_file.swap_range_down(0, 1);
                let _undo_result = todo_file.undo();
                assert_todo_lines!(todo_file, "pick aaa comment", "pick bbb comment", "pick ccc comment");
        }

        #[test]
        fn swap_down_reverse_index() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(todo_file.swap_range_down(1, 0));
                assert_todo_lines!(todo_file, "pick ccc comment", "pick aaa comment", "pick bbb comment");
        }

        #[test]
        fn swap_down_single_line() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(todo_file.swap_range_down(0, 0));
                assert_todo_lines!(todo_file, "pick bbb comment", "pick aaa comment", "pick ccc comment");
        }

        #[test]
        fn swap_down_at_bottom_end_index() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(!todo_file.swap_range_down(1, 2));
                assert_todo_lines!(todo_file, "pick aaa comment", "pick bbb comment", "pick ccc comment");
        }

        #[test]
        fn swap_down_at_bottom_start_index() {
                let (mut todo_file, _) =
                        create_and_load_todo_file(&["pick aaa comment", "pick bbb comment", "pick ccc comment"]);
                assert!(!todo_file.swap_range_down(2, 1));
                assert_todo_lines!(todo_file, "pick aaa comment", "pick bbb comment", "pick ccc comment");
        }

        #[test]
        fn selected_line_index() {
                let (mut todo_file, _) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                let selected_line_index = todo_file.set_selected_line_index(1);
                assert_eq!(selected_line_index, 1);
                assert_eq!(todo_file.get_selected_line_index(), 1);
        }

        #[test]
        fn selected_line_index_overflow() {
                let (mut todo_file, _) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                let selected_line_index = todo_file.set_selected_line_index(3);
                assert_eq!(selected_line_index, 2);
                assert_eq!(todo_file.get_selected_line_index(), 2);
        }

        #[test]
        fn selected_line() {
                let (mut todo_file, _) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                _ = todo_file.set_selected_line_index(0);
                assert_some_eq!(todo_file.get_selected_line(), &create_line("exec foo"));
        }

        #[test]
        fn selected_line_empty_list() {
                let (mut todo_file, _) = create_and_load_todo_file(&[]);
                _ = todo_file.set_selected_line_index(0);
                assert_none!(todo_file.get_selected_line());
        }

        #[test]
        fn get_max_selected_line() {
                let (todo_file, _) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                assert_eq!(todo_file.get_max_selected_line_index(), 2);
        }

        #[test]
        fn get_max_selected_line_empty_list() {
                let (todo_file, _) = create_and_load_todo_file(&[]);
                assert_eq!(todo_file.get_max_selected_line_index(), 0);
        }

        #[test]
        fn get_line_miss_high() {
                let (todo_file, _) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                assert_none!(todo_file.get_line(4));
        }

        #[test]
        fn get_line_hit() {
                let (todo_file, _) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                assert_some_eq!(todo_file.get_line(1), &create_line("exec bar"));
        }

        #[test]
        fn get_file_path() {
                let (todo_file, filepath) = create_and_load_todo_file(&["exec foo", "exec bar", "exec foobar"]);
                assert_eq!(todo_file.get_filepath(), filepath.path());
        }

        #[test]
        fn iter() {
                let (todo_file, _) = create_and_load_todo_file(&["pick aaa comment"]);
                assert_some_eq!(todo_file.lines_iter().next(), &create_line("pick aaa comment"));
        }

        #[test]
        fn is_empty_true() {
                let (todo_file, _) = create_and_load_todo_file(&[]);
                assert_empty!(todo_file);
        }

        #[test]
        fn is_empty_false() {
                let (todo_file, _) = create_and_load_todo_file(&["pick aaa comment"]);
                assert_not_empty!(todo_file);
        }
}

MitMaro / git-interactive-rebase-tool / 6883077488

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous