Use new formatter infrastructure in CLI and test (#4767)

* Use dummy verbatim formatter for all nodes

* Use new formatter infrastructure in CLI and test

* Expose the new formatter in the CLI

* Merge import blocks

crates/ruff_python_formatter/src/lib.rs

@@ -16,7 +16,6 @@ use ruff_python_ast::source_code::{CommentRanges, CommentRangesBuilder, Locator}
 
 use crate::comments::Comments;
 use crate::context::PyFormatContext;
-use crate::module::FormatModule;
 
 pub mod cli;
 mod comments;
@@ -130,9 +129,9 @@ pub fn format_node<'a>(
                 line_width: 88.try_into().unwrap(),
             },
             locator.contents(),
-            comments
+            comments,
         ),
-        [FormatModule::new(root)]
+        [root.format()]
     )
 }
 
@@ -165,13 +164,33 @@ mod tests {
     use insta::assert_snapshot;
     use rustpython_parser::lexer::lex;
     use rustpython_parser::{parse_tokens, Mode};
+    use similar::TextDiff;
 
     use ruff_python_ast::source_code::CommentRangesBuilder;
     use ruff_testing_macros::fixture;
-    use similar::TextDiff;
 
     use crate::{format_module, format_node};
 
+    /// Very basic test intentionally kept very similar to the CLI
+    #[test]
+    fn basic() -> Result<()> {
+        let input = r#"
+# preceding
+if    True:
+    print( "hi" )
+# trailing
+"#;
+        let expected = r#"
+# preceding
+if    True:
+    print( "hi" )
+# trailing
+"#;
+        let actual = format_module(input)?.as_code().to_string();
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+
     #[fixture(pattern = "resources/test/fixtures/black/**/*.py")]
     #[test]
     fn black_test(input_path: &Path) -> Result<()> {

crates/ruff_python_formatter/src/main.rs

@@ -6,12 +6,10 @@ use clap::Parser as ClapParser;
 use ruff_python_formatter::cli::Cli;
 use ruff_python_formatter::format_module;
 
+#[allow(clippy::print_stdout)]
 fn main() -> Result<()> {
     let cli = Cli::parse();
     let contents = fs::read_to_string(cli.file)?;
-    #[allow(clippy::print_stdout)]
-    {
-        println!("{}", format_module(&contents)?.as_code());
-    }
+    println!("{}", format_module(&contents)?.as_code());
     Ok(())
 }

crates/ruff_python_formatter/src/module/mod.rs

@@ -1,38 +1,37 @@
+use crate::context::PyFormatContext;
+use crate::{AsFormat, IntoFormat, PyFormatter};
+use ruff_formatter::{Format, FormatOwnedWithRule, FormatRefWithRule, FormatResult, FormatRule};
+use rustpython_parser::ast::Mod;
+
 pub(crate) mod mod_expression;
 pub(crate) mod mod_function_type;
 pub(crate) mod mod_interactive;
 pub(crate) mod mod_module;
 
-use crate::context::PyFormatContext;
-use ruff_formatter::format_element::tag::VerbatimKind;
-use ruff_formatter::prelude::*;
-use ruff_formatter::write;
-use rustpython_parser::ast::{Mod, Ranged};
+#[derive(Default)]
+pub struct FormatMod;
 
-pub(crate) struct FormatModule<'a> {
-    module: &'a Mod,
-}
-
-impl<'a> FormatModule<'a> {
-    pub(crate) fn new(module: &'a Mod) -> Self {
-        Self { module }
+impl FormatRule<Mod, PyFormatContext<'_>> for FormatMod {
+    fn fmt(&self, item: &Mod, f: &mut PyFormatter) -> FormatResult<()> {
+        match item {
+            Mod::Module(x) => x.format().fmt(f),
+            Mod::Interactive(x) => x.format().fmt(f),
+            Mod::Expression(x) => x.format().fmt(f),
+            Mod::FunctionType(x) => x.format().fmt(f),
+        }
     }
 }
 
-impl Format<PyFormatContext<'_>> for FormatModule<'_> {
-    fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
-        let range = self.module.range();
-
-        write!(f, [source_position(range.start())])?;
-
-        f.write_element(FormatElement::Tag(Tag::StartVerbatim(
-            VerbatimKind::Verbatim {
-                length: range.len(),
-            },
-        )))?;
-        write!(f, [source_text_slice(range, ContainsNewlines::Detect)])?;
-        f.write_element(FormatElement::Tag(Tag::EndVerbatim))?;
-
-        write!(f, [source_position(range.end())])
+impl<'ast> AsFormat<PyFormatContext<'ast>> for Mod {
+    type Format<'a> = FormatRefWithRule<'a, Mod, FormatMod, PyFormatContext<'ast>>;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(self, FormatMod::default())
+    }
+}
+
+impl<'ast> IntoFormat<PyFormatContext<'ast>> for Mod {
+    type Format = FormatOwnedWithRule<Mod, FormatMod, PyFormatContext<'ast>>;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(self, FormatMod::default())
     }
 }