rumdl 0.0.124__tar.gz → 0.0.125__tar.gz

{rumdl-0.0.124 → rumdl-0.0.125}/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.125] - 2025-08-22
+
+### Added
+- **CLI**: Added `--stdin-filename` flag for better stdin processing
+  - Specify filename when reading from stdin for better error messages
+  - Enables MD057 (relative link checking) to work correctly with stdin
+  - Provides proper filename context in all output formats
+  - Improves editor integration capabilities
+
+### Fixed
+- **CLI**: Fixed `rumdl fmt -` to output original content when no issues found
+  - Previously incorrectly output "No issues found in stdin" message
+  - Now correctly outputs the original content unchanged
+- **MD029**: Corrected list continuity detection and fix functionality
+  - Improved handling of sublists and indented content
+  - Better markdownlint compatibility
+
+### Changed
+- **Build**: Added mise version validation to pre-release checks
+  - Prevents CI failures from non-existent mise versions
+
 ## [0.0.124] - 2025-08-22
 
 ### Added
@@ -436,7 +457,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.124...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.125...HEAD
+[0.0.125]: https://github.com/rvben/rumdl/compare/v0.0.124...v0.0.125
 [0.0.124]: https://github.com/rvben/rumdl/compare/v0.0.123...v0.0.124
 [0.0.123]: https://github.com/rvben/rumdl/compare/v0.0.122...v0.0.123
 [0.0.122]: https://github.com/rvben/rumdl/compare/v0.0.121...v0.0.122

{rumdl-0.0.124 → rumdl-0.0.125}/Cargo.lock

@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.124"
+version = "0.0.125"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.124 → rumdl-0.0.125}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.124"
+version = "0.0.125"
 edition = "2024"
 rust-version = "1.89.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"

{rumdl-0.0.124 → rumdl-0.0.125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.124
+Version: 0.0.125
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -264,6 +264,9 @@ echo "# Title   " | rumdl fmt -
 
 # Format clipboard content (macOS example)
 pbpaste | rumdl fmt - | pbcopy
+
+# Provide filename context for better error messages (useful for editor integrations)
+cat README.md | rumdl check - --stdin-filename README.md
 ```
 
 ### Editor Integration

{rumdl-0.0.124 → rumdl-0.0.125}/README.md

@@ -235,6 +235,9 @@ echo "# Title   " | rumdl fmt -
 
 # Format clipboard content (macOS example)
 pbpaste | rumdl fmt - | pbcopy
+
+# Provide filename context for better error messages (useful for editor integrations)
+cat README.md | rumdl check - --stdin-filename README.md
 ```
 
 ### Editor Integration

{rumdl-0.0.124 → rumdl-0.0.125}/scripts/pre-release.sh

@@ -134,6 +134,26 @@ fi
 echo "12. Testing cargo publish (dry run)..."
 run_check "Cargo publish dry-run" "cargo publish --dry-run --locked"
 
+# 13. Check mise version in GitHub Actions workflow
+echo "13. Checking mise version in CI workflow..."
+MISE_VERSION=$(grep -A2 "mise-action@v2" .github/workflows/release.yml | grep "version:" | sed 's/.*version: *//' | tr -d ' ')
+if [ -n "$MISE_VERSION" ]; then
+    echo -n "Verifying mise version $MISE_VERSION exists... "
+    # Check if the release exists on GitHub
+    if curl -s -f "https://api.github.com/repos/jdx/mise/releases/tags/v${MISE_VERSION}" > /dev/null 2>&1; then
+        echo -e "${GREEN}✓${NC} mise version $MISE_VERSION exists"
+    else
+        echo -e "${RED}✗${NC}"
+        echo -e "${RED}mise version $MISE_VERSION does not exist on GitHub!${NC}"
+        echo "Check available versions at: https://github.com/jdx/mise/releases"
+        LATEST_MISE=$(curl -s https://api.github.com/repos/jdx/mise/releases/latest | grep '"tag_name"' | cut -d'"' -f4 | sed 's/^v//')
+        echo "Latest available version: $LATEST_MISE"
+        FAILED=1
+    fi
+else
+    echo -e "${YELLOW}⚠${NC} No explicit mise version found in workflow (will use latest)"
+fi
+
 echo ""
 echo "====================================="
 if [ $FAILED -eq 0 ]; then

{rumdl-0.0.124 → rumdl-0.0.125}/src/lint_context.rs

@@ -2300,7 +2300,7 @@ fn has_meaningful_content_between(current: &ListBlock, next: &ListBlock, lines:
 
                 // Check if this code block is properly indented as list continuation
                 let min_continuation_indent = if current.is_ordered {
-                    current.nesting_level + current.max_marker_width
+                    current.nesting_level + current.max_marker_width + 1 // +1 for space after marker
                 } else {
                     current.nesting_level + 2
                 };

{rumdl-0.0.124 → rumdl-0.0.125}/src/main.rs

@@ -279,6 +279,10 @@ struct CheckArgs {
     #[arg(long, help = "Read from stdin instead of files")]
     stdin: bool,
 
+    /// Filename to use for stdin input (for context and error messages)
+    #[arg(long, help = "Filename to use when reading from stdin (e.g., README.md)")]
+    stdin_filename: Option<String>,
+
     /// Output linting results to stderr instead of stdout
     #[arg(long, help = "Output diagnostics to stderr instead of stdout")]
     stderr: bool,
@@ -1824,6 +1828,17 @@ fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs, config: &rumdl_confi
         exit::violations_found();
     }
 
+    // Determine the filename to use for display and context
+    let display_filename = args.stdin_filename.as_deref().unwrap_or("<stdin>");
+
+    // Set RUMDL_FILE_PATH if stdin-filename is provided
+    // This allows rules like MD057 to know the file location for relative path checking
+    if let Some(ref filename) = args.stdin_filename {
+        unsafe {
+            std::env::set_var("RUMDL_FILE_PATH", filename);
+        }
+    }
+
     // Create a lint context for the stdin content
     let ctx = LintContext::new(&content);
     let mut all_warnings = Vec::new();
@@ -1854,37 +1869,49 @@ fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs, config: &rumdl_confi
     let has_issues = !all_warnings.is_empty();
 
     // Apply fixes if requested
-    if args._fix && has_issues {
-        let mut fixed_content = content.clone();
-        let warnings_fixed = apply_fixes_stdin(rules, &all_warnings, &mut fixed_content, quiet, config);
-
-        // Output the fixed content to stdout
-        print!("{fixed_content}");
-
-        // Re-check the fixed content to see if any issues remain
-        let fixed_ctx = LintContext::new(&fixed_content);
-        let mut remaining_warnings = Vec::new();
-        for rule in rules {
-            if let Ok(warnings) = rule.check(&fixed_ctx) {
-                remaining_warnings.extend(warnings);
+    if args._fix {
+        if has_issues {
+            let mut fixed_content = content.clone();
+            let warnings_fixed = apply_fixes_stdin(rules, &all_warnings, &mut fixed_content, quiet, config);
+
+            // Output the fixed content to stdout
+            print!("{fixed_content}");
+
+            // Re-check the fixed content to see if any issues remain
+            let fixed_ctx = LintContext::new(&fixed_content);
+            let mut remaining_warnings = Vec::new();
+            for rule in rules {
+                if let Ok(warnings) = rule.check(&fixed_ctx) {
+                    remaining_warnings.extend(warnings);
+                }
             }
-        }
 
-        // Only show diagnostics to stderr if not in quiet mode
-        if !quiet && !remaining_warnings.is_empty() {
-            let formatter = output_format.create_formatter();
-            let formatted = formatter.format_warnings(&remaining_warnings, "<stdin>");
-            eprintln!("{formatted}");
-            eprintln!(
-                "\n{} issue(s) fixed, {} issue(s) remaining",
-                warnings_fixed,
-                remaining_warnings.len()
-            );
+            // Only show diagnostics to stderr if not in quiet mode
+            if !quiet && !remaining_warnings.is_empty() {
+                let formatter = output_format.create_formatter();
+                let formatted = formatter.format_warnings(&remaining_warnings, display_filename);
+                eprintln!("{formatted}");
+                eprintln!(
+                    "\n{} issue(s) fixed, {} issue(s) remaining",
+                    warnings_fixed,
+                    remaining_warnings.len()
+                );
+            }
+
+            // Exit with success if all issues were fixed, error if issues remain
+            if !remaining_warnings.is_empty() {
+                exit::violations_found();
+            }
+        } else {
+            // No issues found, output the original content unchanged
+            print!("{content}");
         }
 
-        // Exit with success if all issues were fixed, error if issues remain
-        if !remaining_warnings.is_empty() {
-            exit::violations_found();
+        // Clean up environment variable
+        if args.stdin_filename.is_some() {
+            unsafe {
+                std::env::remove_var("RUMDL_FILE_PATH");
+            }
         }
         return;
     }
@@ -1895,7 +1922,7 @@ fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs, config: &rumdl_confi
         output_format,
         OutputFormat::Json | OutputFormat::GitLab | OutputFormat::Sarif | OutputFormat::Junit
     ) {
-        let file_warnings = vec![("<stdin>".to_string(), all_warnings)];
+        let file_warnings = vec![(display_filename.to_string(), all_warnings)];
         let output = match output_format {
             OutputFormat::Json => rumdl::output::formatters::json::format_all_warnings_as_json(&file_warnings),
             OutputFormat::GitLab => rumdl::output::formatters::gitlab::format_gitlab_report(&file_warnings),
@@ -1911,7 +1938,7 @@ fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs, config: &rumdl_confi
         // Use formatter for line-by-line output
         let formatter = output_format.create_formatter();
         if !all_warnings.is_empty() {
-            let formatted = formatter.format_warnings(&all_warnings, "<stdin>");
+            let formatted = formatter.format_warnings(&all_warnings, display_filename);
             output_writer.writeln(&formatted).unwrap_or_else(|e| {
                 eprintln!("Error writing output: {e}");
             });
@@ -1921,14 +1948,27 @@ fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs, config: &rumdl_confi
         if !quiet {
             if has_issues {
                 output_writer
-                    .writeln(&format!("\nFound {} issue(s) in stdin", all_warnings.len()))
+                    .writeln(&format!(
+                        "\nFound {} issue(s) in {}",
+                        all_warnings.len(),
+                        display_filename
+                    ))
                     .ok();
             } else {
-                output_writer.writeln("No issues found in stdin").ok();
+                output_writer
+                    .writeln(&format!("No issues found in {display_filename}"))
+                    .ok();
             }
         }
     }
 
+    // Clean up environment variable
+    if args.stdin_filename.is_some() {
+        unsafe {
+            std::env::remove_var("RUMDL_FILE_PATH");
+        }
+    }
+
     // Exit with error code if issues found
     if has_issues {
         exit::violations_found();

{rumdl-0.0.124 → rumdl-0.0.125}/src/rules/md029_ordered_list_prefix.rs

@@ -5,17 +5,11 @@ use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, S
 use crate::rule_config_serde::RuleConfig;
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use crate::utils::regex_cache::ORDERED_LIST_MARKER_REGEX;
-use lazy_static::lazy_static;
-use regex::Regex;
 use toml;
 
 mod md029_config;
 pub use md029_config::{ListStyle, MD029Config};
 
-lazy_static! {
-    static ref FIX_LINE_REGEX: Regex = Regex::new(r"^(\s*)\d+(\.\s.*)$").unwrap();
-}
-
 #[derive(Debug, Clone, Default)]
 pub struct MD029OrderedListPrefix {
     config: MD029Config,
@@ -32,13 +26,6 @@ impl MD029OrderedListPrefix {
         Self { config }
     }
 
-    #[inline]
-    fn get_list_number(line: &str) -> Option<usize> {
-        ORDERED_LIST_MARKER_REGEX
-            .captures(line)
-            .and_then(|cap| cap[2].parse::<usize>().ok())
-    }
-
     #[inline]
     fn parse_marker_number(marker: &str) -> Option<usize> {
         // Handle marker format like "1." or "1"
@@ -59,13 +46,6 @@ impl MD029OrderedListPrefix {
             ListStyle::Ordered0 => index,
         }
     }
-
-    #[inline]
-    fn fix_line(&self, line: &str, expected_num: usize) -> String {
-        FIX_LINE_REGEX
-            .replace(line, format!("${{1}}{}{}", expected_num, "$2"))
-            .to_string()
-    }
 }
 
 impl Rule for MD029OrderedListPrefix {
@@ -158,121 +138,53 @@ impl Rule for MD029OrderedListPrefix {
     }
 
     fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
-        let content = ctx.content;
-        let mut result = String::new();
-        let mut indent_stack: Vec<(usize, usize)> = Vec::new(); // (indent, index)
-        let lines: Vec<&str> = content.lines().collect();
-        let mut in_code_fence = false;
-
-        for line in lines.iter() {
-            let trimmed = line.trim();
-
-            // Track code fences
-            if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
-                in_code_fence = !in_code_fence;
-                result.push_str(line);
-                result.push('\n');
-                continue;
-            }
+        // Use the same logic as check() - just apply the fixes from warnings
+        let warnings = self.check(ctx)?;
+
+        if warnings.is_empty() {
+            // No changes needed
+            return Ok(ctx.content.to_string());
+        }
 
-            // Skip if in code fence
-            if in_code_fence {
-                result.push_str(line);
-                result.push('\n');
+        // Collect fixes and sort by position
+        // Only apply MD029 fixes (numbering), not MD029-style fixes (indentation)
+        let mut fixes: Vec<&Fix> = Vec::new();
+        for warning in &warnings {
+            // Skip MD029-style warnings (lazy continuation indentation)
+            if warning.rule_name == Some("MD029-style") {
                 continue;
             }
-            if let Some(_current_num) = Self::get_list_number(line) {
-                let indent = line.chars().take_while(|c| c.is_whitespace()).count();
-                // Pop stack if current indent is less than stack top
-                while let Some(&(top_indent, _)) = indent_stack.last() {
-                    if indent < top_indent {
-                        indent_stack.pop();
-                    } else {
-                        break;
-                    }
-                }
-                // If indent matches stack top, increment index
-                if let Some(&mut (top_indent, ref mut idx)) = indent_stack.last_mut()
-                    && indent == top_indent
-                {
-                    let expected_num = self.get_expected_number(*idx);
-                    let fixed_line = self.fix_line(line, expected_num);
-                    result.push_str(&fixed_line);
-                    result.push('\n');
-                    *idx += 1;
-                    continue;
-                }
-                // New deeper indent or first item
-                indent_stack.push((indent, 0));
-                let expected_num = self.get_expected_number(0);
-                let fixed_line = self.fix_line(line, expected_num);
-                result.push_str(&fixed_line);
-                result.push('\n');
-                // Increment the new top
-                if let Some(&mut (_, ref mut idx)) = indent_stack.last_mut() {
-                    *idx += 1;
-                }
-            } else if !line.trim().is_empty() {
-                // Check if the line is indented enough to be part of a list item
-                let line_indent = line.chars().take_while(|c| c.is_whitespace()).count();
-                let is_continuation = indent_stack
-                    .last()
-                    .map(|&(list_indent, _)| {
-                        // Allow lazy continuation (0-2 spaces) or proper continuation (3+ spaces)
-                        line_indent <= 2 || line_indent >= list_indent + 3
-                    })
-                    .unwrap_or(false);
-
-                if is_continuation {
-                    if line_indent <= 2 && !indent_stack.is_empty() {
-                        // Check if this line is itself a list item or heading
-                        let trimmed = line.trim();
-                        let is_list_item = trimmed.starts_with("* ")
-                            || trimmed.starts_with("- ")
-                            || trimmed.starts_with("+ ")
-                            || (trimmed.len() > 2
-                                && trimmed.chars().next().unwrap().is_ascii_digit()
-                                && trimmed.contains(". "));
-
-                        // Check if this is a heading (ATX style)
-                        let is_heading = trimmed.starts_with('#')
-                            && trimmed.len() > 1
-                            && (trimmed.chars().nth(1) == Some(' ') || trimmed.chars().nth(1) == Some('#'));
-
-                        if !is_list_item && !is_heading {
-                            // This is a lazy continuation - fix it by adding proper indentation
-                            let (list_indent, _) = indent_stack.last().unwrap();
-                            let proper_indent = " ".repeat(list_indent + 3);
-                            result.push_str(&proper_indent);
-                            result.push_str(line.trim_start());
-                            result.push('\n');
-                        } else {
-                            // This is a list item or heading, not a continuation - it breaks the list
-                            indent_stack.clear();
-                            result.push_str(line);
-                            result.push('\n');
-                        }
-                    } else {
-                        // This line is properly indented
-                        result.push_str(line);
-                        result.push('\n');
-                    }
-                } else {
-                    // Non-list, non-blank line breaks the list
-                    indent_stack.clear();
-                    result.push_str(line);
-                    result.push('\n');
-                }
-            } else {
-                // Blank line - don't clear the stack, as lists can have blank lines within them
-                result.push_str(line);
-                result.push('\n');
+            if let Some(ref fix) = warning.fix {
+                fixes.push(fix);
+            }
+        }
+        fixes.sort_by_key(|f| f.range.start);
+
+        let mut result = String::new();
+        let mut last_pos = 0;
+        let content_bytes = ctx.content.as_bytes();
+
+        for fix in fixes {
+            // Add content before the fix
+            if last_pos < fix.range.start {
+                let chunk = &content_bytes[last_pos..fix.range.start];
+                result.push_str(
+                    std::str::from_utf8(chunk).map_err(|_| LintError::InvalidInput("Invalid UTF-8".to_string()))?,
+                );
             }
+            // Add the replacement
+            result.push_str(&fix.replacement);
+            last_pos = fix.range.end;
         }
-        // Remove trailing newline if the original content didn't have one
-        if !content.ends_with('\n') && result.ends_with('\n') {
-            result.pop();
+
+        // Add remaining content
+        if last_pos < content_bytes.len() {
+            let chunk = &content_bytes[last_pos..];
+            result.push_str(
+                std::str::from_utf8(chunk).map_err(|_| LintError::InvalidInput("Invalid UTF-8".to_string()))?,
+            );
         }
+
         Ok(result)
     }
 
@@ -671,7 +583,14 @@ impl MD029OrderedListPrefix {
                     if actual_num != expected_num {
                         // Calculate byte position for the fix
                         let marker_start = line_info.byte_offset + list_item.marker_column;
-                        let number_len = actual_num.to_string().len();
+                        // Use the actual marker length (e.g., "05" is 2 chars, not 1)
+                        let number_len = if let Some(dot_pos) = list_item.marker.find('.') {
+                            dot_pos // Length up to the dot
+                        } else if let Some(paren_pos) = list_item.marker.find(')') {
+                            paren_pos // Length up to the paren
+                        } else {
+                            list_item.marker.len() // Fallback to full marker length
+                        };
 
                         warnings.push(LintWarning {
                             rule_name: Some(self.name()),

{rumdl-0.0.124 → rumdl-0.0.125}/tests/cli_integration_tests.rs

@@ -1255,6 +1255,38 @@ fn test_stdin_check_without_fix() {
     assert!(!output.status.success());
 }
 
+#[test]
+fn test_stdin_formatting_no_issues() {
+    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");
+
+    // Test that formatting mode outputs the original content when there are no issues
+    // This was a bug where it would output "No issues found in stdin" instead
+    let input = "# Clean Markdown\n\nThis markdown has no issues.\n";
+    let mut cmd = Command::new(rumdl_exe);
+    cmd.arg("fmt").arg("-").arg("--quiet");
+    cmd.stdin(std::process::Stdio::piped());
+    cmd.stdout(std::process::Stdio::piped());
+    cmd.stderr(std::process::Stdio::piped());
+
+    let mut child = cmd.spawn().expect("Failed to spawn command");
+
+    // Write input to stdin
+    use std::io::Write;
+    let mut stdin = child.stdin.take().expect("Failed to open stdin");
+    stdin.write_all(input.as_bytes()).expect("Failed to write to stdin");
+    drop(stdin);
+
+    let output = child.wait_with_output().expect("Failed to wait for command");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // Should output the original content unchanged
+    assert_eq!(stdout, input, "fmt should output original content when no issues found");
+    // No errors should be on stderr in quiet mode
+    assert_eq!(stderr, "");
+    assert!(output.status.success());
+}
+
 #[test]
 fn test_stdin_dash_syntax() {
     let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");
@@ -1287,6 +1319,81 @@ fn test_stdin_dash_syntax() {
     assert!(stderr.contains("Found 3 issue(s)"));
 }
 
+#[test]
+fn test_stdin_filename_flag() {
+    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");
+
+    // Test that --stdin-filename changes the displayed filename in error messages
+    let input = "# Test   \n\nTest paragraph   ";
+    let mut cmd = Command::new(rumdl_exe);
+    cmd.arg("check").arg("-").arg("--stdin-filename").arg("test-file.md");
+    cmd.stdin(std::process::Stdio::piped());
+    cmd.stdout(std::process::Stdio::piped());
+    cmd.stderr(std::process::Stdio::piped());
+
+    let mut child = cmd.spawn().expect("Failed to spawn command");
+
+    // Write input to stdin
+    use std::io::Write;
+    let mut stdin = child.stdin.take().expect("Failed to open stdin");
+    stdin.write_all(input.as_bytes()).expect("Failed to write to stdin");
+    drop(stdin);
+
+    let output = child.wait_with_output().expect("Failed to wait for command");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // Should not output content to stdout in check mode
+    assert_eq!(stdout, "");
+    // Should show the custom filename in error messages
+    assert!(
+        stderr.contains("test-file.md:1:"),
+        "Error message should contain custom filename"
+    );
+    assert!(
+        stderr.contains("test-file.md:3:"),
+        "Error message should contain custom filename for line 3"
+    );
+    assert!(stderr.contains("in test-file.md"), "Summary should use custom filename");
+    // Should still detect the issues
+    assert!(stderr.contains("MD009"));
+}
+
+#[test]
+fn test_stdin_filename_in_fmt_mode() {
+    let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");
+
+    // Test that --stdin-filename also works in fmt mode
+    let input = "# Clean Markdown\n\nNo issues here.\n";
+    let mut cmd = Command::new(rumdl_exe);
+    cmd.arg("fmt")
+        .arg("-")
+        .arg("--stdin-filename")
+        .arg("custom-file.md")
+        .arg("--quiet");
+    cmd.stdin(std::process::Stdio::piped());
+    cmd.stdout(std::process::Stdio::piped());
+    cmd.stderr(std::process::Stdio::piped());
+
+    let mut child = cmd.spawn().expect("Failed to spawn command");
+
+    // Write input to stdin
+    use std::io::Write;
+    let mut stdin = child.stdin.take().expect("Failed to open stdin");
+    stdin.write_all(input.as_bytes()).expect("Failed to write to stdin");
+    drop(stdin);
+
+    let output = child.wait_with_output().expect("Failed to wait for command");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // In fmt mode with no issues, should output the original content
+    assert_eq!(stdout, input, "Should output original content");
+    // No errors should be on stderr in quiet mode
+    assert_eq!(stderr, "");
+    assert!(output.status.success());
+}
+
 #[test]
 fn test_fmt_dash_syntax() {
     let rumdl_exe = env!("CARGO_BIN_EXE_rumdl");