Use SourceKind::diff for formatter (#8240)

## Summary

This PR refactors the formatter diff code to reuse the
`SourceKind::diff` logic. This has the benefit that the Notebook diff
now includes the cell numbers which was not present before.

## Test Plan

Update the snapshots and verified the cell numbers.

crates/ruff_cli/src/commands/format.rs

@@ -11,7 +11,6 @@ use itertools::Itertools;
 use log::{error, warn};
 use rayon::iter::Either::{Left, Right};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use similar::TextDiff;
 use thiserror::Error;
 use tracing::debug;
 
@@ -472,11 +471,7 @@ impl<'a> FormatResults<'a> {
             })
             .sorted_unstable_by_key(|(path, _, _)| *path)
         {
-            let text_diff =
-                TextDiff::from_lines(unformatted.source_code(), formatted.source_code());
-            let mut unified_diff = text_diff.unified_diff();
-            unified_diff.header(&fs::relativize_path(path), &fs::relativize_path(path));
-            unified_diff.to_writer(&mut *f)?;
+            unformatted.diff(formatted, Some(path), f)?;
         }
 
         Ok(())
@@ -566,6 +561,7 @@ pub(crate) enum FormatCommandError {
     Read(Option<PathBuf>, SourceError),
     Format(Option<PathBuf>, FormatModuleError),
     Write(Option<PathBuf>, SourceError),
+    Diff(Option<PathBuf>, io::Error),
 }
 
 impl FormatCommandError {
@@ -581,7 +577,8 @@ impl FormatCommandError {
             Self::Panic(path, _)
             | Self::Read(path, _)
             | Self::Format(path, _)
-            | Self::Write(path, _) => path.as_deref(),
+            | Self::Write(path, _)
+            | Self::Diff(path, _) => path.as_deref(),
         }
     }
 }
@@ -649,6 +646,24 @@ impl Display for FormatCommandError {
                     write!(f, "{}{} {err}", "Failed to format".bold(), ":".bold())
                 }
             }
+            Self::Diff(path, err) => {
+                if let Some(path) = path {
+                    write!(
+                        f,
+                        "{}{}{} {err}",
+                        "Failed to generate diff for ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold()
+                    )
+                } else {
+                    write!(
+                        f,
+                        "{}{} {err}",
+                        "Failed to generate diff".bold(),
+                        ":".bold()
+                    )
+                }
+            }
             Self::Panic(path, err) => {
                 let message = r#"This indicates a bug in Ruff. If you could open an issue at:
 

crates/ruff_cli/src/commands/format_stdin.rs

@@ -3,8 +3,6 @@ use std::path::Path;
 
 use anyhow::Result;
 use log::error;
-use ruff_linter::fs;
-use similar::TextDiff;
 
 use ruff_linter::source_kind::SourceKind;
 use ruff_python_ast::{PySourceType, SourceType};
@@ -109,14 +107,9 @@ fn format_source_code(
             }
             FormatMode::Check => {}
             FormatMode::Diff => {
-                let mut writer = stdout().lock();
-                let text_diff =
-                    TextDiff::from_lines(source_kind.source_code(), formatted.source_code());
-                let mut unified_diff = text_diff.unified_diff();
-                if let Some(path) = path {
-                    unified_diff.header(&fs::relativize_path(path), &fs::relativize_path(path));
-                }
-                unified_diff.to_writer(&mut writer).unwrap();
+                source_kind
+                    .diff(formatted, path, &mut stdout().lock())
+                    .map_err(|err| FormatCommandError::Diff(path.map(Path::to_path_buf), err))?;
             }
         },
         FormattedSource::Unchanged => {