ffmt 0.4.1__tar.gz → 0.4.2__tar.gz

{ffmt-0.4.1 → ffmt-0.4.2}/Cargo.lock

@@ -156,7 +156,7 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "ffmt"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "clap",
  "ignore",
@@ -194,9 +194,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "ignore"
-version = "0.4.25"
+version = "0.4.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3d782a365a015e0f5c04902246139249abf769125006fbe7649e2ee88169b4a"
+checksum = "b915661dd01db3f05050265b2477bcc6527b3792388e2749b41623cc592be67d"
 dependencies = [
  "crossbeam-deque",
  "globset",
@@ -232,15 +232,15 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "log"
-version = "0.4.30"
+version = "0.4.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5"
+checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a"
 
 [[package]]
 name = "memchr"
-version = "2.8.1"
+version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8"
+checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
 [[package]]
 name = "once_cell_polyfill"
@@ -288,9 +288,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.12.3"
+version = "1.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -311,9 +311,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.10"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "same-file"

{ffmt-0.4.1 → ffmt-0.4.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ffmt"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 description = "A fast, configurable Fortran formatter with Fypp, Doxygen, and OpenACC/OpenMP support"
 license = "MIT"

{ffmt-0.4.1 → ffmt-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmt
-Version: 0.4.1
+Version: 0.4.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -88,7 +88,7 @@ multdiv = false
 # pre-commit
 repos:
   - repo: https://github.com/sbryngelson/ffmt
-    rev: v0.4.0
+    rev: v0.4.2
     hooks:
       - id: ffmt
 ```

{ffmt-0.4.1 → ffmt-0.4.2}/README.md

@@ -71,7 +71,7 @@ multdiv = false
 # pre-commit
 repos:
   - repo: https://github.com/sbryngelson/ffmt
-    rev: v0.4.0
+    rev: v0.4.2
     hooks:
       - id: ffmt
 ```

{ffmt-0.4.1 → ffmt-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ffmt"
-version = "0.4.1"
+version = "0.4.2"
 description = "A fast, configurable Fortran formatter with Fypp, Doxygen, and OpenACC/OpenMP support"
 license = { text = "MIT" }
 requires-python = ">=3.8"

{ffmt-0.4.1 → ffmt-0.4.2}/src/classifier.rs

@@ -100,11 +100,31 @@ fn strip_trailing_comment(s: &str) -> String {
 
 /// Find the matching closing paren for the paren at position `start`.
 /// Returns the index of the closing paren, or None if not found.
+/// Parens inside string literals are ignored (e.g., `if (ch == '(') then`).
 fn find_matching_paren(s: &str, start: usize) -> Option<usize> {
     let bytes = s.as_bytes();
     let mut depth = 0i32;
-    for (i, &byte) in bytes.iter().enumerate().skip(start) {
+    let mut in_string = false;
+    let mut quote = b' ';
+    let mut i = start;
+    while i < bytes.len() {
+        let byte = bytes[i];
+        if in_string {
+            if byte == quote {
+                if i + 1 < bytes.len() && bytes[i + 1] == quote {
+                    i += 2; // escaped quote — stay in string
+                    continue;
+                }
+                in_string = false;
+            }
+            i += 1;
+            continue;
+        }
         match byte {
+            b'\'' | b'"' => {
+                in_string = true;
+                quote = byte;
+            }
             b'(' => depth += 1,
             b')' => {
                 depth -= 1;
@@ -114,6 +134,7 @@ fn find_matching_paren(s: &str, start: usize) -> Option<usize> {
             }
             _ => {}
         }
+        i += 1;
     }
     None
 }
@@ -178,6 +199,12 @@ fn classify_fortran(trimmed: &str) -> LineKind {
         }
     };
 
+    // Strip any trailing comment so checks like `lower == "contains"` and the
+    // "what follows the closing paren" tests are not confused by comment text
+    // (e.g., `contains ! public api`, `where (mask > 0) ! note`).
+    let stripped = strip_trailing_comment(line);
+    let line = stripped.as_str();
+
     let lower = line.to_ascii_lowercase();
 
     // --- Block closers (check first since "end" prefix is distinctive) ---

{ffmt-0.4.1 → ffmt-0.4.2}/src/cli.rs

@@ -6,7 +6,6 @@ use std::fs;
 use std::io::{self, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process;
-use std::sync::atomic::{AtomicBool, Ordering};
 
 /// Default cache directory (relative to cwd).
 const CACHE_DIR: &str = ".ffmt_cache";
@@ -201,7 +200,6 @@ pub fn run() {
     };
 
     let range = parse_range(&args.range);
-    let any_changed = AtomicBool::new(false);
 
     let opts = ProcessOptions {
         check: args.check,
@@ -212,25 +210,37 @@ pub fn run() {
         verbose,
     };
 
-    files_to_process.par_iter().for_each(|path| {
-        let changed = process_file(path, &opts, &config);
-        if changed {
-            any_changed.store(true, Ordering::Relaxed);
-        }
-    });
-
-    // Update cache for all files (including ones we skipped — they're still valid)
+    let outcomes: Vec<(&PathBuf, Outcome)> = files_to_process
+        .par_iter()
+        .map(|path| (*path, process_file(path, &opts, &config)))
+        .collect();
+    let any_changed = outcomes.iter().any(|(_, o)| *o == Outcome::Changed);
+    let any_failed = outcomes.iter().any(|(_, o)| *o == Outcome::Failed);
+    let failed: std::collections::HashSet<&PathBuf> = outcomes
+        .iter()
+        .filter(|(_, o)| *o == Outcome::Failed)
+        .map(|(p, _)| *p)
+        .collect();
+
+    // Update cache for successfully processed files (including ones we skipped
+    // via the cache — they're still valid). Files that failed must NOT be
+    // cached, or the failure would be silently skipped on the next run.
     if let Some(ref mut cache) = cache {
         // Only update cache when formatting (not in check/diff mode)
         if !args.check && !args.diff {
             for f in &files {
-                cache.update(f);
+                if !failed.contains(f) {
+                    cache.update(f);
+                }
             }
             cache.save(cache_dir);
         }
     }
 
-    if args.check && any_changed.load(Ordering::Relaxed) {
+    if any_failed {
+        process::exit(2);
+    }
+    if args.check && any_changed {
         process::exit(1);
     }
 }
@@ -276,7 +286,10 @@ fn run_stdin(args: &Args, color: bool, quiet: bool, config: &crate::config::Conf
             if args.diff {
                 print_diff(Path::new(filepath), &source, &formatted, color);
             }
-            process::exit(1);
+            // --diff alone is informational; only --check signals failure
+            if args.check {
+                process::exit(1);
+            }
         }
     } else {
         io::stdout()
@@ -332,7 +345,7 @@ fn discover_files_with_config(
 
         for entry in builder.build().flatten() {
             let entry_path = entry.path();
-            if entry_path.is_file() && is_fortran_file(entry_path) {
+            if entry_path.is_file() && is_fortran_file_ext(entry_path, extensions) {
                 files.push(entry_path.to_path_buf());
             }
         }
@@ -343,10 +356,6 @@ fn discover_files_with_config(
     files
 }
 
-fn is_fortran_file(path: &Path) -> bool {
-    is_fortran_file_ext(path, &crate::config::FilesConfig::default().extensions)
-}
-
 fn is_fortran_file_ext(path: &Path, extensions: &[String]) -> bool {
     path.extension()
         .and_then(|e| e.to_str())
@@ -362,16 +371,24 @@ struct ProcessOptions {
     verbose: bool,
 }
 
-fn process_file(path: &Path, opts: &ProcessOptions, config: &crate::config::Config) -> bool {
+/// Result of processing one file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Outcome {
+    Unchanged,
+    Changed,
+    Failed,
+}
+
+fn process_file(path: &Path, opts: &ProcessOptions, config: &crate::config::Config) -> Outcome {
     let source = match fs::read_to_string(path) {
         Ok(s) => s,
         Err(e) if e.kind() == io::ErrorKind::InvalidData => {
             // Binary or invalid UTF-8: not a text Fortran file, skip silently
-            return false;
+            return Outcome::Unchanged;
         }
         Err(e) => {
             eprintln!("ffmt: cannot read {}: {e}", path.display());
-            return false;
+            return Outcome::Failed;
         }
     };
 
@@ -382,7 +399,7 @@ fn process_file(path: &Path, opts: &ProcessOptions, config: &crate::config::Conf
     let formatted = crate::formatter::format_with_config(&source, config, opts.range);
 
     if formatted == source {
-        return false;
+        return Outcome::Unchanged;
     }
 
     if opts.check || opts.diff {
@@ -392,14 +409,15 @@ fn process_file(path: &Path, opts: &ProcessOptions, config: &crate::config::Conf
         if opts.diff {
             print_diff(path, &source, &formatted, opts.color);
         }
-        return true;
+        return Outcome::Changed;
     }
 
     if let Err(e) = fs::write(path, &formatted) {
         eprintln!("ffmt: cannot write {}: {e}", path.display());
+        return Outcome::Failed;
     }
 
-    true
+    Outcome::Changed
 }
 
 fn print_diff(path: &Path, original: &str, formatted: &str, color: bool) {

{ffmt-0.4.1 → ffmt-0.4.2}/src/formatter.rs

@@ -73,6 +73,9 @@ pub fn format_with_range(source: &str, range: Option<(usize, usize)>) -> String
 
 /// Format with full config and optional range.
 pub fn format_with_config(source: &str, config: &Config, range: Option<(usize, usize)>) -> String {
+    // Remember the original line-ending style for EndOfLine::Preserve
+    // (the source is normalized to \n for parsing below).
+    let source_had_crlf = source.contains("\r\n");
     // Normalize line endings before parsing (ensures reader sees consistent \n)
     let normalized_source;
     let src = if source.contains('\r') {
@@ -361,6 +364,12 @@ pub fn format_with_config(source: &str, config: &Config, range: Option<(usize, u
                         // normalizer can't parse correctly.
                         // For multi-line, use the joined line (reader normalizes spacing).
                         let source = if ll.raw_lines.len() > 1 {
+                            emit_hoisted_comments(
+                                &ll.hoisted_comments,
+                                depth,
+                                config,
+                                &mut output_lines,
+                            );
                             &ll.joined
                         } else {
                             trimmed
@@ -458,6 +467,17 @@ pub fn format_with_config(source: &str, config: &Config, range: Option<(usize, u
                             break;
                         }
 
+                        // Comments found inside the continuation are hoisted
+                        // above the statement: re-emitting from the joined
+                        // text would lose them, and leaving them between
+                        // continuation lines is rejected by some compilers.
+                        emit_hoisted_comments(
+                            &ll.hoisted_comments,
+                            depth,
+                            config,
+                            &mut output_lines,
+                        );
+
                         // Normal multi-line: unravel joined line, normalize, rewrap
                         let processed = process_line(&ll.joined, config);
                         let formatted = apply_indent(processed.trim(), depth, config.indent_width);
@@ -634,7 +654,14 @@ pub fn format_with_config(source: &str, config: &Config, range: Option<(usize, u
             result = result.replace("\r\n", "\n").replace('\r', "\n");
             result = result.replace('\n', "\r\n");
         }
-        EndOfLine::Preserve => {}
+        EndOfLine::Preserve => {
+            // The source was normalized to LF for parsing; restore the
+            // original ending style.
+            if source_had_crlf {
+                result = result.replace("\r\n", "\n").replace('\r', "\n");
+                result = result.replace('\n', "\r\n");
+            }
+        }
     }
 
     result
@@ -642,6 +669,29 @@ pub fn format_with_config(source: &str, config: &Config, range: Option<(usize, u
 
 /// Check if a line is a `! ffmt off` or `! ffmt on` marker.
 /// Returns Some(true) for off, Some(false) for on, None otherwise.
+/// Emit comments hoisted out of a `&` continuation as full-line comments
+/// above the statement, at the statement's indent.
+fn emit_hoisted_comments(
+    comments: &[String],
+    depth: usize,
+    config: &Config,
+    output_lines: &mut Vec<String>,
+) {
+    for comment in comments {
+        let c = if config.unicode_to_ascii {
+            crate::unicode::replace_unicode(comment)
+        } else {
+            comment.clone()
+        };
+        let c = if config.space_after_comment.is_enabled() {
+            normalize_comment_space(&c)
+        } else {
+            c
+        };
+        output_lines.push(apply_indent(&c, depth, config.indent_width));
+    }
+}
+
 fn is_ffmt_marker(line: &str) -> Option<bool> {
     let t = line.trim().to_ascii_lowercase();
     if t == "! ffmt off" || t == "! ffmt: off" {
@@ -1505,19 +1555,23 @@ fn is_declaration_line(line: &str) -> bool {
     let bytes = trimmed.as_bytes();
     let mut in_string = false;
     let mut quote_char = b' ';
-    for i in 0..bytes.len() {
+    let mut i = 0;
+    while i < bytes.len() {
         if in_string {
             if bytes[i] == quote_char {
                 if i + 1 < bytes.len() && bytes[i + 1] == quote_char {
+                    i += 2; // escaped quote — stay in string
                     continue;
                 }
                 in_string = false;
             }
+            i += 1;
             continue;
         }
         if bytes[i] == b'\'' || bytes[i] == b'"' {
             in_string = true;
             quote_char = bytes[i];
+            i += 1;
             continue;
         }
         if bytes[i] == b'!' {
@@ -1526,6 +1580,7 @@ fn is_declaration_line(line: &str) -> bool {
         if bytes[i] == b':' && i + 1 < bytes.len() && bytes[i + 1] == b':' {
             return true;
         }
+        i += 1;
     }
     false
 }
@@ -1552,12 +1607,14 @@ fn ensure_two_spaces_before_inline_comment(lines: &[String]) -> Vec<String> {
             let bytes = line.as_bytes();
             let mut in_string = false;
             let mut delim = b' ';
-            for i in 0..bytes.len() {
+            let mut i = 0;
+            while i < bytes.len() {
                 if in_string {
                     if bytes[i] == delim {
                         // Check for doubled quote escape
                         if i + 1 < bytes.len() && bytes[i + 1] == delim {
-                            continue; // skip
+                            i += 2; // escaped quote — stay in string
+                            continue;
                         }
                         in_string = false;
                     }
@@ -1592,6 +1649,7 @@ fn ensure_two_spaces_before_inline_comment(lines: &[String]) -> Vec<String> {
                     let comment_part = &line[i..];
                     return format!("{}  {}", code_part, comment_part);
                 }
+                i += 1;
             }
             line.clone()
         })
@@ -1620,10 +1678,12 @@ fn strip_trailing_semicolons(lines: &[String]) -> Vec<String> {
             let mut in_string = false;
             let mut delim = b' ';
             let mut comment_start = bytes.len();
-            for i in 0..bytes.len() {
+            let mut i = 0;
+            while i < bytes.len() {
                 if in_string {
                     if bytes[i] == delim {
                         if i + 1 < bytes.len() && bytes[i + 1] == delim {
+                            i += 2; // escaped quote — stay in string
                             continue;
                         }
                         in_string = false;
@@ -1635,6 +1695,7 @@ fn strip_trailing_semicolons(lines: &[String]) -> Vec<String> {
                     comment_start = i;
                     break;
                 }
+                i += 1;
             }
             let code = &line[..comment_start];
             let comment = &line[comment_start..];
@@ -2271,36 +2332,37 @@ fn normalize_fypp_lists(line: &str) -> String {
     let bytes = line.as_bytes();
     let len = bytes.len();
     let mut i = 0;
+    // Start of the pending region to copy verbatim (always on a char boundary,
+    // since we only advance past ASCII delimiters).
+    let mut plain_start = 0;
 
     while i < len {
         // Look for '[
         if i + 1 < len && bytes[i] == b'\'' && bytes[i + 1] == b'[' {
             // Find the matching ]'
-            let start = i;
-            i += 2; // skip '[
-            let mut content = String::new();
-            while i < len {
-                if bytes[i] == b']' && i + 1 < len && bytes[i + 1] == b'\'' {
-                    // Found ]' -- normalize commas in content
-                    let normalized_content = normalize_comma_spacing(&content);
-                    result.push_str("'[");
-                    result.push_str(&normalized_content);
-                    result.push_str("]'");
-                    i += 2; // skip ]'
+            let mut j = i + 2;
+            let mut close = None;
+            while j + 1 < len {
+                if bytes[j] == b']' && bytes[j + 1] == b'\'' {
+                    close = Some(j);
                     break;
                 }
-                content.push(bytes[i] as char);
-                i += 1;
+                j += 1;
             }
-            // If we didn't find ]', emit original
-            if i >= len && !result.ends_with("]'") {
-                result.push_str(&line[start..]);
+            if let Some(close) = close {
+                // Found ]' -- normalize commas in content
+                result.push_str(&line[plain_start..i]);
+                result.push_str("'[");
+                result.push_str(&normalize_comma_spacing(&line[i + 2..close]));
+                result.push_str("]'");
+                i = close + 2;
+                plain_start = i;
+                continue;
             }
-        } else {
-            result.push(bytes[i] as char);
-            i += 1;
         }
+        i += 1;
     }
+    result.push_str(&line[plain_start..]);
 
     result
 }
@@ -2339,19 +2401,19 @@ fn modernize_relational_operators(lines: &[String]) -> Vec<String> {
             let mut i = 0;
             let mut in_string = false;
             let mut quote_char = b' ';
+            // Start of the pending region to copy verbatim (always on a char
+            // boundary, since we only cut at ASCII operator positions).
+            let mut plain_start = 0;
 
             while i < len {
                 if in_string {
                     if bytes[i] == quote_char {
                         if i + 1 < len && bytes[i + 1] == quote_char {
-                            result.push(bytes[i] as char);
-                            result.push(bytes[i + 1] as char);
-                            i += 2;
+                            i += 2; // escaped quote — stay in string
                             continue;
                         }
                         in_string = false;
                     }
-                    result.push(bytes[i] as char);
                     i += 1;
                     continue;
                 }
@@ -2359,43 +2421,39 @@ fn modernize_relational_operators(lines: &[String]) -> Vec<String> {
                 if bytes[i] == b'\'' || bytes[i] == b'"' {
                     in_string = true;
                     quote_char = bytes[i];
-                    result.push(bytes[i] as char);
                     i += 1;
                     continue;
                 }
 
-                // Comment start — copy rest verbatim
+                // Comment start — rest is copied verbatim below
                 if bytes[i] == b'!' {
-                    result.push_str(&line[i..]);
-                    return result;
+                    break;
                 }
 
                 // Check for legacy operator
                 if bytes[i] == b'.' {
-                    let mut matched = false;
+                    let mut matched = None;
                     for &(legacy, modern) in operators {
                         let legacy_len = legacy.len();
-                        if i + legacy_len <= len {
-                            let candidate: String = bytes[i..i + legacy_len]
-                                .iter()
-                                .map(|&b| (b as char).to_ascii_lowercase())
-                                .collect();
-                            if candidate == legacy {
-                                result.push_str(modern);
-                                i += legacy_len;
-                                matched = true;
-                                break;
-                            }
+                        if i + legacy_len <= len
+                            && bytes[i..i + legacy_len].eq_ignore_ascii_case(legacy.as_bytes())
+                        {
+                            matched = Some((legacy_len, modern));
+                            break;
                         }
                     }
-                    if matched {
+                    if let Some((legacy_len, modern)) = matched {
+                        result.push_str(&line[plain_start..i]);
+                        result.push_str(modern);
+                        i += legacy_len;
+                        plain_start = i;
                         continue;
                     }
                 }
 
-                result.push(bytes[i] as char);
                 i += 1;
             }
+            result.push_str(&line[plain_start..]);
 
             result
         })
@@ -2535,19 +2593,23 @@ fn split_multi_statements(lines: &[String]) -> Vec<String> {
         let mut quote_char = b' ';
         let mut semicolons: Vec<usize> = Vec::new();
 
-        for i in 0..len {
+        let mut i = 0;
+        while i < len {
             if in_string {
                 if bytes[i] == quote_char {
                     if i + 1 < len && bytes[i + 1] == quote_char {
+                        i += 2; // escaped quote — stay in string
                         continue;
                     }
                     in_string = false;
                 }
+                i += 1;
                 continue;
             }
             if bytes[i] == b'\'' || bytes[i] == b'"' {
                 in_string = true;
                 quote_char = bytes[i];
+                i += 1;
                 continue;
             }
             if bytes[i] == b'!' {
@@ -2556,6 +2618,7 @@ fn split_multi_statements(lines: &[String]) -> Vec<String> {
             if bytes[i] == b';' {
                 semicolons.push(i);
             }
+            i += 1;
         }
 
         if semicolons.is_empty() {
@@ -2868,21 +2931,25 @@ fn normalize_comma_spacing(s: &str) -> String {
     let bytes = s.as_bytes();
     let len = bytes.len();
     let mut i = 0;
+    // Start of the pending region to copy verbatim (always on a char boundary,
+    // since we only cut at ASCII commas/spaces).
+    let mut plain_start = 0;
 
     while i < len {
         if bytes[i] == b',' {
-            result.push(',');
-            result.push(' ');
+            result.push_str(&s[plain_start..i]);
+            result.push_str(", ");
             // Skip any whitespace after the comma
             i += 1;
             while i < len && bytes[i] == b' ' {
                 i += 1;
             }
+            plain_start = i;
         } else {
-            result.push(bytes[i] as char);
             i += 1;
         }
     }
+    result.push_str(&s[plain_start..]);
 
     result
 }