Format PatternMatchOr

Closes astral-sh#6643

crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/match.py

@@ -467,3 +467,37 @@ def foo():
         # e
     ):
         pass
+
+
+match pattern_match_or:
+    case ( # leading 1
+          a # trailing 1
+          # own line 1
+          | # trailing 2
+          # own line 2
+          b # trailing 3
+          # own line 3
+          | # trailing 4
+          # own line 4
+          c # trailing 5
+            ):
+        ...
+
+    case (
+        (a)
+        | # trailing
+        ( b )
+    ):
+        ...
+
+    case (a|b|c):
+        ...
+
+    case foo | bar | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaahhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh:
+        ...
+
+    case ( # end of line
+          a | b
+    # own line
+    ):
+        ...

crates/ruff_python_formatter/src/pattern/pattern_match_or.rs

@@ -2,22 +2,46 @@ use ruff_formatter::write;
 use ruff_python_ast::node::AnyNodeRef;
 use ruff_python_ast::PatternMatchOr;
 
-use crate::expression::parentheses::{NeedsParentheses, OptionalParentheses};
-use crate::not_yet_implemented_custom_text;
+use crate::comments::leading_comments;
+use crate::expression::parentheses::{
+    in_parentheses_only_soft_line_break_or_space, NeedsParentheses, OptionalParentheses,
+};
 use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatPatternMatchOr;
 
 impl FormatNodeRule<PatternMatchOr> for FormatPatternMatchOr {
     fn fmt_fields(&self, item: &PatternMatchOr, f: &mut PyFormatter) -> FormatResult<()> {
-        write!(
-            f,
-            [not_yet_implemented_custom_text(
-                "NOT_YET_IMPLEMENTED_PatternMatchOf | (y)",
-                item
-            )]
-        )
+        let PatternMatchOr { range: _, patterns } = item;
+        let inner = format_with(|f: &mut PyFormatter| {
+            let mut patterns = patterns.iter();
+            let comments = f.context().comments().clone();
+
+            let Some(first) = patterns.next() else {
+                return Ok(());
+            };
+
+            first.format().fmt(f)?;
+
+            for pattern in patterns {
+                let leading_value_comments = comments.leading(pattern);
+                // Format the expressions leading comments **before** the operator
+                if leading_value_comments.is_empty() {
+                    write!(f, [in_parentheses_only_soft_line_break_or_space()])?;
+                } else {
+                    write!(
+                        f,
+                        [hard_line_break(), leading_comments(leading_value_comments)]
+                    )?;
+                }
+                write!(f, [text("|"), space(), pattern.format()])?;
+            }
+
+            Ok(())
+        });
+
+        inner.fmt(f)
     }
 }