ffmt 0.4.2__tar.gz → 0.4.3__tar.gz

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

@@ -156,7 +156,7 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "ffmt"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "clap",
  "ignore",

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmt
-Version: 0.4.2
+Version: 0.4.3
 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.2
+    rev: v0.4.3
     hooks:
       - id: ffmt
 ```

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

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

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

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

{ffmt-0.4.2 → ffmt-0.4.3}/src/case_norm.rs

@@ -8,6 +8,15 @@
 ///   lowercased in non-opaque regions.
 /// - All other text (identifiers, numbers, punctuation) is preserved.
 pub fn normalize_case(line: &str) -> String {
+    normalize_case_with(line, false)
+}
+
+/// Normalize case of Fortran keywords to UPPERCASE (keyword-case = "upper").
+pub fn normalize_case_upper(line: &str) -> String {
+    normalize_case_with(line, true)
+}
+
+fn normalize_case_with(line: &str, upper: bool) -> String {
     let trimmed = line.trim_start();
 
     // If the line is a Fypp directive, return unchanged.
@@ -107,9 +116,13 @@ pub fn normalize_case(line: &str) -> String {
         // --- Dot operators: .TRUE., .AND., etc. ---
         if ch == b'.' && i + 2 < len {
             if let Some((dot_end, _)) = crate::match_dot_token(bytes, i) {
-                // Lowercase the entire dot keyword/operator token
+                // Normalize the entire dot keyword/operator token
                 let op_str = &line[i..dot_end];
-                out.push_str(&op_str.to_ascii_lowercase());
+                if upper {
+                    out.push_str(&op_str.to_ascii_uppercase());
+                } else {
+                    out.push_str(&op_str.to_ascii_lowercase());
+                }
                 i = dot_end;
                 continue;
             }
@@ -123,14 +136,29 @@ pub fn normalize_case(line: &str) -> String {
             }
             let word = &line[start..i];
             if is_keyword(word) {
-                out.push_str(&word.to_ascii_lowercase());
+                if upper {
+                    out.push_str(&word.to_ascii_uppercase());
+                } else {
+                    out.push_str(&word.to_ascii_lowercase());
+                }
             } else {
                 out.push_str(word);
             }
             continue;
         }
 
-        // --- Everything else: pass through unchanged ---
+        // --- Non-ASCII: copy the whole UTF-8 character unchanged ---
+        // (`ch as char` would reinterpret each byte as Latin-1, mojibaking
+        // multi-byte sequences.)
+        if ch >= 0x80 {
+            if let Some(c) = line[i..].chars().next() {
+                out.push(c);
+                i += c.len_utf8();
+                continue;
+            }
+        }
+
+        // --- Everything else (ASCII): pass through unchanged ---
         out.push(ch as char);
         i += 1;
     }

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

@@ -141,6 +141,18 @@ fn find_matching_paren(s: &str, start: usize) -> Option<usize> {
 
 /// Classify a Fortran line.
 fn classify_fortran(trimmed: &str) -> LineKind {
+    // Strip an optional numeric statement label (e.g. "10 continue", "100 end if")
+    // so the underlying statement is classified. The label is kept in the output;
+    // stripping happens for classification only.
+    let (trimmed, had_numeric_label) = {
+        let re_num_label = re!(NUM_LABEL, r"^\d+\s+");
+        if let Some(m) = re_num_label.find(trimmed) {
+            (trimmed[m.end()..].trim_start(), true)
+        } else {
+            (trimmed, false)
+        }
+    };
+
     // Strip optional label prefix like "outer: "
     let line = {
         let re_label = re!(LABEL, r"(?i)^\w+\s*:\s*");
@@ -212,8 +224,20 @@ fn classify_fortran(trimmed: &str) -> LineKind {
         END_BLOCK,
         r"(?i)^end\s*(if|do|select|subroutine|function|module|submodule|program|interface|type|block|associate|where|forall|enum|critical|team)\b"
     );
-    if re_end_block.is_match(line) {
-        return LineKind::FortranBlockClose;
+    if let Some(m) = re_end_block.find(line) {
+        // Fortran has no reserved words: "endif = 5" is an assignment to a
+        // variable named "endif", not a block close.
+        let rest = line[m.end()..].trim_start();
+        if !rest.starts_with('=') {
+            // A numeric-labeled "end do" may terminate a non-block labeled DO
+            // ("do 10 ... 10 end do"); since "do <label>" does not push an
+            // indentation scope, don't pop one here.
+            let re_end_do = re!(END_DO_LABELED, r"(?i)^end\s*do\b");
+            if had_numeric_label && re_end_do.is_match(line) {
+                return LineKind::FortranStatement;
+            }
+            return LineKind::FortranBlockClose;
+        }
     }
     // Bare "end" (possibly followed by comment)
     let re_bare_end = re!(BARE_END, r"(?i)^end\s*(!.*)?$");
@@ -227,8 +251,8 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     if re_else_if.is_match(line) {
         return LineKind::FortranContinuation;
     }
-    // bare else (possibly followed by comment)
-    let re_bare_else = re!(BARE_ELSE, r"(?i)^else\s*(!.*)?$");
+    // bare else or named "else <construct-name>" (possibly followed by comment)
+    let re_bare_else = re!(BARE_ELSE, r"(?i)^else\b(\s+\w+)?\s*(!.*)?$");
     if re_bare_else.is_match(line) {
         return LineKind::FortranContinuation;
     }
@@ -291,6 +315,14 @@ fn classify_fortran(trimmed: &str) -> LineKind {
         }
     }
 
+    // Non-block labeled DO ("do 10 i = 1, n") is terminated by the labeled
+    // statement ("10 continue"), which is classified as a plain statement, so
+    // it must NOT open an indentation scope.
+    let re_do_label = re!(DO_LABEL, r"(?i)^do\s+\d+\b");
+    if re_do_label.is_match(line) {
+        return LineKind::FortranStatement;
+    }
+
     // do / do concurrent
     let re_do = re!(DO_OPEN, r"(?i)^do\b");
     if re_do.is_match(line) {
@@ -314,10 +346,11 @@ fn classify_fortran(trimmed: &str) -> LineKind {
         return LineKind::FortranBlockOpen;
     }
 
-    // function (with optional prefixes)
+    // function (with optional prefixes; type-spec prefixes may carry a paren
+    // group with one level of nesting, e.g. type(point(8)), integer(kind=8))
     let re_func = re!(
         FUNC,
-        r"(?i)^(((pure|elemental|impure|recursive|integer|real|double\s+precision|complex|character|logical|type\s*\([^)]*\))\s+)*)function\b"
+        r"(?i)^((((pure|elemental|impure|recursive|module)|(integer|real|double\s+precision|complex|character|logical|type|class)(\s*\(([^()]|\([^()]*\))*\))?)\s+)*)function\b"
     );
     if re_func.is_match(line) {
         return LineKind::FortranBlockOpen;
@@ -361,8 +394,8 @@ fn classify_fortran(trimmed: &str) -> LineKind {
             return LineKind::FortranStatement;
         }
         // type is (...) was already handled in continuations above
-        // type :: name  or  type, attrs :: name  -> definition (block open)
-        let re_type_def = re!(TYPE_DEF, r"(?i)^type\b[\s,]");
+        // type :: name, type::name, or type, attrs :: name -> definition (block open)
+        let re_type_def = re!(TYPE_DEF, r"(?i)^type\s*(::|,|\s)");
         if re_type_def.is_match(line) {
             return LineKind::FortranBlockOpen;
         }
@@ -406,6 +439,12 @@ fn classify_fortran(trimmed: &str) -> LineKind {
         }
     }
 
+    // block data [name] (legacy program unit; "end block data" is a closer)
+    let re_block_data = re!(BLOCK_DATA, r"(?i)^block\s*data(\s+\w+)?\s*$");
+    if re_block_data.is_match(line) {
+        return LineKind::FortranBlockOpen;
+    }
+
     // block (bare keyword)
     if lower == "block" {
         return LineKind::FortranBlockOpen;
@@ -493,7 +532,10 @@ pub fn classify(line: &str) -> LineKind {
 /// - `type :: my_type` -> Some("my_type")
 /// - `type, extends(base) :: child` -> Some("child")
 pub fn extract_scope_name(line: &str) -> Option<String> {
-    let trimmed = line.trim();
+    // Strip any trailing comment (string-aware) so names are never read from
+    // comment text (e.g. `program main ! function test`).
+    let stripped = strip_trailing_comment(line.trim());
+    let trimmed = stripped.as_str();
     let lower = trimmed.to_ascii_lowercase();
 
     // subroutine name(...) or subroutine name
@@ -508,7 +550,7 @@ pub fn extract_scope_name(line: &str) -> Option<String> {
     // function name(...) or function name
     let re_func = re!(
         SCOPE_FUNC,
-        r"(?i)(?:(?:pure|elemental|impure|recursive|integer|real|double\s+precision|complex|character|logical|type\s*\([^)]*\))\s+)*function\s+(\w+)"
+        r"(?i)(?:(?:pure|elemental|impure|recursive|module|(?:integer|real|double\s+precision|complex|character|logical|type|class)(?:\s*\((?:[^()]|\([^()]*\))*\))?)\s+)*function\s+(\w+)"
     );
     if let Some(caps) = re_func.captures(trimmed) {
         return Some(caps[1].to_string());

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

@@ -6,6 +6,7 @@ use std::fs;
 use std::io::{self, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process;
+use std::sync::{Arc, Mutex};
 
 /// Default cache directory (relative to cwd).
 const CACHE_DIR: &str = ".ffmt_cache";
@@ -135,7 +136,9 @@ pub fn run() {
 
     let color = use_color(&args.color);
 
-    // Load config from ffmt.toml or pyproject.toml
+    // Load the root config from ffmt.toml or pyproject.toml (used for
+    // --dump-config, stdin mode, and file discovery). Each discovered file is
+    // later formatted with the config nearest to it (see ConfigCache).
     let config = {
         let search_dir = if !args.paths.is_empty() && args.paths[0] != "-" {
             let p = PathBuf::from(&args.paths[0]);
@@ -147,7 +150,10 @@ pub fn run() {
         } else {
             std::env::current_dir().unwrap_or_default()
         };
-        crate::config::Config::find_and_load(&search_dir)
+        crate::config::Config::try_find_and_load(&search_dir).unwrap_or_else(|e| {
+            eprintln!("ffmt: {e}");
+            process::exit(2);
+        })
     };
 
     // Dump config mode
@@ -184,12 +190,17 @@ pub fn run() {
         .build_global()
         .ok();
 
-    // Load cache
+    // Load cache. The salt ties entries to this ffmt version and the root
+    // config: a cache written by a different version (or after a config
+    // change) is discarded wholesale — stale entries would silently freeze
+    // files in their old formatting.
+    let cache_salt = hash_bytes(env!("CARGO_PKG_VERSION").as_bytes())
+        ^ hash_bytes(format!("{:?}", config).as_bytes());
     let cache_dir = args.cache_dir.as_deref().unwrap_or(CACHE_DIR);
     let mut cache = if args.no_cache || args.check {
         None
     } else {
-        Some(FileCache::load(cache_dir))
+        Some(FileCache::load(cache_dir, cache_salt))
     };
 
     // Filter files that haven't changed since last format
@@ -210,9 +221,13 @@ pub fn run() {
         verbose,
     };
 
+    // Config is documented as "searched upward from the formatted file's
+    // directory", so resolve it per file (cached per directory; the cache is
+    // shared across rayon workers).
+    let config_cache = ConfigCache::default();
     let outcomes: Vec<(&PathBuf, Outcome)> = files_to_process
         .par_iter()
-        .map(|path| (*path, process_file(path, &opts, &config)))
+        .map(|path| (*path, process_file(path, &opts, &config_cache)))
         .collect();
     let any_changed = outcomes.iter().any(|(_, o)| *o == Outcome::Changed);
     let any_failed = outcomes.iter().any(|(_, o)| *o == Outcome::Failed);
@@ -371,6 +386,35 @@ struct ProcessOptions {
     verbose: bool,
 }
 
+/// Per-directory cache of resolved configs, shared across rayon workers.
+///
+/// Config discovery is documented as "searched upward from the formatted
+/// file's directory", so each file gets the config nearest to it. Errors
+/// (e.g. an unknown key in ffmt.toml) are cached too, so they are reported
+/// once per directory instead of once per file.
+#[derive(Default)]
+struct ConfigCache {
+    entries: Mutex<HashMap<PathBuf, Result<Arc<crate::config::Config>, String>>>,
+}
+
+impl ConfigCache {
+    fn for_file(&self, path: &Path) -> Result<Arc<crate::config::Config>, String> {
+        let dir = path
+            .parent()
+            .filter(|p| !p.as_os_str().is_empty())
+            .map(|p| p.to_path_buf())
+            .unwrap_or_else(|| PathBuf::from("."));
+        // Canonicalize so the upward search works for relative paths and the
+        // cache keys are stable.
+        let dir = dir.canonicalize().unwrap_or(dir);
+        let mut entries = self.entries.lock().unwrap();
+        entries
+            .entry(dir.clone())
+            .or_insert_with(|| crate::config::Config::try_find_and_load(&dir).map(Arc::new))
+            .clone()
+    }
+}
+
 /// Result of processing one file.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Outcome {
@@ -379,7 +423,15 @@ enum Outcome {
     Failed,
 }
 
-fn process_file(path: &Path, opts: &ProcessOptions, config: &crate::config::Config) -> Outcome {
+fn process_file(path: &Path, opts: &ProcessOptions, config_cache: &ConfigCache) -> Outcome {
+    let config = match config_cache.for_file(path) {
+        Ok(config) => config,
+        Err(e) => {
+            eprintln!("ffmt: {e}");
+            return Outcome::Failed;
+        }
+    };
+
     let source = match fs::read_to_string(path) {
         Ok(s) => s,
         Err(e) if e.kind() == io::ErrorKind::InvalidData => {
@@ -396,7 +448,7 @@ fn process_file(path: &Path, opts: &ProcessOptions, config: &crate::config::Conf
         eprintln!("ffmt: formatting {}", path.display());
     }
 
-    let formatted = crate::formatter::format_with_config(&source, config, opts.range);
+    let formatted = crate::formatter::format_with_config(&source, &config, opts.range);
 
     if formatted == source {
         return Outcome::Unchanged;
@@ -420,6 +472,17 @@ fn process_file(path: &Path, opts: &ProcessOptions, config: &crate::config::Conf
     Outcome::Changed
 }
 
+/// Split into lines on `\n` only, keeping any `\r` as part of the line so
+/// CRLF -> LF normalization shows up in the diff. A trailing newline does not
+/// produce a final empty line.
+fn split_diff_lines(s: &str) -> Vec<&str> {
+    let mut lines: Vec<&str> = s.split('\n').collect();
+    if lines.last() == Some(&"") {
+        lines.pop();
+    }
+    lines
+}
+
 fn print_diff(path: &Path, original: &str, formatted: &str, color: bool) {
     let (red, green, cyan, reset) = if color {
         ("\x1b[31m", "\x1b[32m", "\x1b[36m", "\x1b[0m")
@@ -430,47 +493,76 @@ fn print_diff(path: &Path, original: &str, formatted: &str, color: bool) {
     println!("{red}--- {}{reset}", path.display());
     println!("{green}+++ {}{reset}", path.display());
 
-    let orig_lines: Vec<&str> = original.lines().collect();
-    let fmt_lines: Vec<&str> = formatted.lines().collect();
+    let orig_lines = split_diff_lines(original);
+    let fmt_lines = split_diff_lines(formatted);
+    let orig_missing_nl = !original.is_empty() && !original.ends_with('\n');
+    let fmt_missing_nl = !formatted.is_empty() && !formatted.ends_with('\n');
     let max = orig_lines.len().max(fmt_lines.len());
 
+    let print_hunk = |hunk_start: usize, hunk_end: usize| {
+        let old_count = hunk_end.min(orig_lines.len()).saturating_sub(hunk_start);
+        let new_count = hunk_end.min(fmt_lines.len()).saturating_sub(hunk_start);
+        // Unified diff format: a zero-length range names the line *before*
+        // the hunk, so its 1-based start is hunk_start (not hunk_start + 1).
+        let old_start = if old_count == 0 {
+            hunk_start
+        } else {
+            hunk_start + 1
+        };
+        let new_start = if new_count == 0 {
+            hunk_start
+        } else {
+            hunk_start + 1
+        };
+        println!("{cyan}@@ -{old_start},{old_count} +{new_start},{new_count} @@{reset}");
+        for (j, line) in orig_lines
+            .iter()
+            .enumerate()
+            .take(hunk_start + old_count)
+            .skip(hunk_start)
+        {
+            println!("{red}-{line}{reset}");
+            if j + 1 == orig_lines.len() && orig_missing_nl {
+                println!("\");
+            }
+        }
+        for (j, line) in fmt_lines
+            .iter()
+            .enumerate()
+            .take(hunk_start + new_count)
+            .skip(hunk_start)
+        {
+            println!("{green}+{line}{reset}");
+            if j + 1 == fmt_lines.len() && fmt_missing_nl {
+                println!("\");
+            }
+        }
+    };
+
+    let mut printed_any = false;
     let mut i = 0;
     while i < max {
-        let orig = orig_lines.get(i).copied().unwrap_or("");
-        let fmt = fmt_lines.get(i).copied().unwrap_or("");
+        let orig = orig_lines.get(i);
+        let fmt = fmt_lines.get(i);
         if orig != fmt {
             let hunk_start = i;
-            let mut hunk_end = i;
-            while hunk_end < max {
-                let o = orig_lines.get(hunk_end).copied().unwrap_or("");
-                let f = fmt_lines.get(hunk_end).copied().unwrap_or("");
-                if o == f && hunk_end > i {
-                    break;
-                }
+            let mut hunk_end = i + 1;
+            while hunk_end < max && orig_lines.get(hunk_end) != fmt_lines.get(hunk_end) {
                 hunk_end += 1;
             }
-            println!(
-                "{cyan}@@ -{},{} +{},{} @@{reset}",
-                hunk_start + 1,
-                hunk_end - hunk_start,
-                hunk_start + 1,
-                hunk_end - hunk_start
-            );
-            for j in hunk_start..hunk_end {
-                if j < orig_lines.len() {
-                    println!("{red}-{}{reset}", orig_lines[j]);
-                }
-            }
-            for j in hunk_start..hunk_end {
-                if j < fmt_lines.len() {
-                    println!("{green}+{}{reset}", fmt_lines[j]);
-                }
-            }
+            print_hunk(hunk_start, hunk_end);
+            printed_any = true;
             i = hunk_end;
         } else {
             i += 1;
         }
     }
+
+    // All lines compare equal but the contents differ: only the presence of
+    // the trailing newline changed. Emit a hunk replacing the last line.
+    if !printed_any && original != formatted && !orig_lines.is_empty() {
+        print_hunk(orig_lines.len() - 1, orig_lines.len());
+    }
 }
 
 // --- File hash cache ---
@@ -480,15 +572,28 @@ fn print_diff(path: &Path, original: &str, formatted: &str, color: bool) {
 
 struct FileCache {
     entries: HashMap<PathBuf, u64>,
+    salt: u64,
 }
 
 impl FileCache {
-    fn load(cache_dir: &str) -> Self {
+    fn load(cache_dir: &str, salt: u64) -> Self {
         let cache_file = Path::new(cache_dir).join("hashes");
         let mut entries = HashMap::new();
 
         if let Ok(content) = fs::read_to_string(&cache_file) {
-            for line in content.lines() {
+            let mut lines = content.lines();
+            // Header: "# <salt>". A missing or mismatched header means the
+            // cache was written by another ffmt version or under a different
+            // config — discard it.
+            let valid = lines
+                .next()
+                .and_then(|h| h.strip_prefix("# "))
+                .and_then(|v| v.parse::<u64>().ok())
+                == Some(salt);
+            if !valid {
+                return FileCache { entries, salt };
+            }
+            for line in lines {
                 let mut parts = line.splitn(2, ' ');
                 if let (Some(hash_str), Some(path_str)) = (parts.next(), parts.next()) {
                     if let Ok(hash) = hash_str.parse::<u64>() {
@@ -498,7 +603,7 @@ impl FileCache {
             }
         }
 
-        FileCache { entries }
+        FileCache { entries, salt }
     }
 
     fn is_cached(&self, path: &Path) -> bool {
@@ -531,7 +636,7 @@ impl FileCache {
             .collect();
         lines.sort();
 
-        let content = lines.join("\n") + "\n";
+        let content = format!("# {}\n{}\n", self.salt, lines.join("\n"));
         let _ = fs::write(cache_file, content);
     }
 }

{ffmt-0.4.2 → ffmt-0.4.3}/src/config.rs

@@ -284,19 +284,25 @@ struct PyprojectTool {
 
 impl Config {
     /// Search upward from `start_dir` for `ffmt.toml` or `pyproject.toml`
-    /// with `[tool.ffmt]`. Returns default config if nothing found.
+    /// with `[tool.ffmt]`. Returns the default config if nothing is found,
+    /// and an error if a config file exists but cannot be read or parsed
+    /// (including unknown keys). Used by the CLI, where silently formatting
+    /// with defaults instead of the project config would be dangerous.
+    pub fn try_find_and_load(start_dir: &Path) -> Result<Self, String> {
+        match find_config_file(start_dir) {
+            Some(path) => load_config_file(&path),
+            None => Ok(Config::default()),
+        }
+    }
+
+    /// Lenient variant of [`Config::try_find_and_load`]: on error, log a
+    /// warning to stderr and fall back to the default config. Used by the
+    /// LSP server, which must keep serving requests.
     pub fn find_and_load(start_dir: &Path) -> Self {
-        if let Some(path) = find_config_file(start_dir) {
-            match load_config_file(&path) {
-                Ok(cfg) => cfg,
-                Err(e) => {
-                    eprintln!("ffmt: warning: error reading {}: {e}", path.display());
-                    Config::default()
-                }
-            }
-        } else {
+        Self::try_find_and_load(start_dir).unwrap_or_else(|e| {
+            eprintln!("ffmt: warning: {e}; using default config");
             Config::default()
-        }
+        })
     }
 
     /// Load from a specific config file path.