ffmt 0.4.2__tar.gz → 0.4.4__tar.gz

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

@@ -63,12 +63,12 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.12.1"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+checksum = "5cee35f73844aa3014bb606320a6c1f010249dbdf43342fe54b5a4f6a8ed4b79"
 dependencies = [
  "memchr",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -119,9 +119,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -129,18 +129,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
+version = "0.9.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
 
 [[package]]
 name = "either"
@@ -156,7 +156,7 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "ffmt"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "clap",
  "ignore",
@@ -194,9 +194,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "ignore"
-version = "0.4.26"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b915661dd01db3f05050265b2477bcc6527b3792388e2749b41623cc592be67d"
+checksum = "2adf14691c72bcfc1058740436a35bdd3ae9c07d1a941ef00b749e9ea16aefa7"
 dependencies = [
  "crossbeam-deque",
  "globset",
@@ -232,15 +232,15 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "log"
-version = "0.4.32"
+version = "0.4.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
 
 [[package]]
 name = "memchr"
-version = "2.8.2"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "once_cell_polyfill"
@@ -259,9 +259,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.45"
+version = "1.0.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
 dependencies = [
  "proc-macro2",
 ]
@@ -288,9 +288,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.12.4"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba"
+checksum = "2a0e75113e14dc5acb068cd0786884f214f1312650a3d36d269f5c4f3cdee8a2"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -300,9 +300,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.14"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+checksum = "1f388202e4b80542a0921078cc23b6333bcf1409c1e3f86404cae4766a6131db"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -384,9 +384,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.117"
+version = "2.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -491,6 +491,6 @@ dependencies = [
 
 [[package]]
 name = "zmij"
-version = "1.0.21"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmt
-Version: 0.4.2
+Version: 0.4.4
 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.4}/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.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ffmt"
-version = "0.4.2"
+version = "0.4.4"
 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.4}/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.4}/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;
@@ -441,6 +480,66 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     LineKind::FortranStatement
 }
 
+/// Split a Fortran line into its top-level statements at semicolons, ignoring
+/// semicolons inside string literals and stopping at an inline comment.
+/// Returns the trimmed pieces (empty pieces are kept so callers can skip them).
+fn split_top_level_statements(line: &str) -> Vec<&str> {
+    let bytes = line.as_bytes();
+    let mut pieces = Vec::new();
+    let mut start = 0;
+    let mut in_string = false;
+    let mut quote = b' ';
+    let mut i = 0;
+    while i < bytes.len() {
+        let b = bytes[i];
+        if in_string {
+            if b == quote {
+                // Doubled quote is an escape — stay inside the string.
+                if i + 1 < bytes.len() && bytes[i + 1] == quote {
+                    i += 2;
+                    continue;
+                }
+                in_string = false;
+            }
+            i += 1;
+            continue;
+        }
+        match b {
+            b'\'' | b'"' => {
+                in_string = true;
+                quote = b;
+            }
+            b'!' => break, // inline comment — nothing after it is a statement
+            b';' => {
+                pieces.push(line[start..i].trim());
+                start = i + 1;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    pieces.push(line[start..].trim());
+    pieces
+}
+
+/// Net indentation effect of a line's top-level statements: +1 per block
+/// opener, -1 per block closer, 0 for everything else (continuations,
+/// statements). A self-contained single-line construct nets to 0.
+fn net_block_delta(pieces: &[&str]) -> i32 {
+    let mut delta = 0;
+    for &piece in pieces {
+        if piece.is_empty() {
+            continue;
+        }
+        match classify_fortran(piece) {
+            LineKind::FortranBlockOpen => delta += 1,
+            LineKind::FortranBlockClose => delta -= 1,
+            _ => {}
+        }
+    }
+    delta
+}
+
 /// Classify a logical line.
 pub fn classify(line: &str) -> LineKind {
     let trimmed = line.trim();
@@ -479,7 +578,23 @@ pub fn classify(line: &str) -> LineKind {
     }
 
     // 6. Fortran
-    classify_fortran(trimmed)
+    let kind = classify_fortran(trimmed);
+
+    // A construct that opens AND closes on the same line (e.g.
+    // `do d = 1, n; s = s + d; end do`) has a net-zero indent effect. The
+    // leading keyword makes `classify_fortran` report a block opener, which
+    // would leak an indent level onto every following line. When the opener's
+    // matching closer is on the same line (net delta 0), treat the whole line
+    // as a plain statement instead — a block opener and a statement both sit at
+    // the current depth, so the line's own indentation is unchanged.
+    if kind == LineKind::FortranBlockOpen {
+        let pieces = split_top_level_statements(trimmed);
+        if pieces.len() > 1 && net_block_delta(&pieces) == 0 {
+            return LineKind::FortranStatement;
+        }
+    }
+
+    kind
 }
 
 /// Extract the scope name from a Fortran block-opening line.
@@ -493,7 +608,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 +626,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());