Method show_change_diff_computed

atomic-cli/src/commands/diff/helpers.rs:635–770

Show diff by computing from content (legacy fallback). Used when a change doesn't have file_ops (old changes or graph-only changes).

(
        &self,
        repo: &Repository,
        change: &Change,
        hash: &Hash,
        config: &DiffOutputConfig,
    )

    ///
    /// Used when a change doesn't have file_ops (old changes or graph-only changes).
    fn show_change_diff_computed(
        &self,
        repo: &Repository,
        change: &Change,
        hash: &Hash,
        config: &DiffOutputConfig,
    ) -> CliResult<()> {
        use atomic_repository::get_files_in_change;

        // Get all files modified by this change, honoring the positional
        // file filter (`diff --change <hash> <file>`)
        let modified_files: Vec<_> = get_files_in_change(change)
            .into_iter()
            .filter(|path| self.file_matches_filter(path))
            .collect();

        if modified_files.is_empty() {
            self.print_no_changes();
            return Ok(());
        }

        // Parse algorithm for diffing
        let algorithm = self.parse_algorithm()?;

        // Compute diffs for each file using state-based content retrieval
        let mut file_diffs = Vec::new();
        let mut stats = DiffStats::new();

        for file_path in &modified_files {
            // Get content BEFORE the change was applied
            let before_content = match repo.get_file_content_before_change(file_path, hash) {
                Ok(content) => content.unwrap_or_default(),
                Err(_) => Vec::new(),
            };

            // Get content AFTER the change was applied
            let after_content = match repo.get_file_content_after_change(file_path, hash) {
                Ok(content) => content.unwrap_or_default(),
                Err(_) => Vec::new(),
            };

            // Determine the type of change based on before/after content
            let file_diff = match (before_content.is_empty(), after_content.is_empty()) {
                // File was added (no content before, has content after)
                (true, false) => {
                    let mut diff = FileDiff::added(file_path);
                    let lines: Vec<_> = after_content.split(|&b| b == b'\n').collect();
                    let line_count = lines.len();

                    if !after_content.is_empty() {
                        let mut graph_op = DiffHunk::new(0, 0, 1, line_count);
                        for (i, line_bytes) in lines.iter().enumerate() {
                            let line_content = String::from_utf8_lossy(line_bytes).into_owned();
                            graph_op.add_line(HunkLine::added(line_content, i + 1));
                        }
                        diff.add_hunk(graph_op);
                    }