ffmt 0.2.6__tar.gz → 0.2.8__tar.gz

{ffmt-0.2.6 → ffmt-0.2.8}/Cargo.lock

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

{ffmt-0.2.6 → ffmt-0.2.8}/Cargo.toml

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

{ffmt-0.2.6 → ffmt-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmt
-Version: 0.2.6
+Version: 0.2.8
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{ffmt-0.2.6 → ffmt-0.2.8}/pyproject.toml

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

{ffmt-0.2.6 → ffmt-0.2.8}/src/align.rs

@@ -167,7 +167,7 @@ fn align_inline_comments(lines: &mut [String], line_length: usize) {
         if let Some(pos) = find_inline_doxygen(line) {
             if !has_doxygen_text(line, pos) { continue; }
             let comment = &line[pos..];
-            let aligned_len = max_code_len + 1 + comment.len();
+            let aligned_len = max_code_len + 2 + comment.len();
             if aligned_len > line_length {
                 would_overflow = true;
                 break;
@@ -176,14 +176,14 @@ fn align_inline_comments(lines: &mut [String], line_length: usize) {
     }
 
     if would_overflow {
-        // Fall back to minimal spacing: just ensure 1 space before !<
+        // Fall back to minimal spacing: ensure 2 spaces before !<
         for line in lines.iter_mut() {
             if let Some(pos) = find_inline_doxygen(line) {
                 if !has_doxygen_text(line, pos) { continue; }
                 let before = &line[..pos];
                 let comment = &line[pos..];
                 let trimmed_before = before.trim_end();
-                *line = format!("{} {}", trimmed_before, comment);
+                *line = format!("{}  {}", trimmed_before, comment);
             }
         }
         return;
@@ -196,8 +196,8 @@ fn align_inline_comments(lines: &mut [String], line_length: usize) {
             let before = &line[..pos];
             let comment = &line[pos..];
             let trimmed_before = before.trim_end();
-            let padding = max_code_len - trimmed_before.len();
-            *line = format!("{}{} {}", trimmed_before, " ".repeat(padding), comment);
+            let padding = max_code_len + 2 - trimmed_before.len();
+            *line = format!("{}{}{}", trimmed_before, " ".repeat(padding), comment);
         }
     }
 }

{ffmt-0.2.6 → ffmt-0.2.8}/src/formatter.rs

@@ -435,7 +435,8 @@ pub fn format_with_config(
     if config.rewrap_code {
         let mut final_lines: Vec<String> = Vec::new();
         for line in &output_lines {
-            if line.len() > config.line_length && find_inline_doxygen_in_line(line).is_none() {
+            if line.len() > config.line_length && find_inline_doxygen_in_line(line).is_none()
+                && !line.trim_end().ends_with('&') {
                 final_lines.extend(rewrap_line(line, config.line_length, config.indent_width));
             } else {
                 final_lines.push(line.clone());
@@ -447,6 +448,13 @@ pub fn format_with_config(
     // Align :: in consecutive declaration lines
     if config.align_declarations { output_lines = crate::align::align_declarations(&output_lines, config.compact_declarations, config.align_comments, config.line_length); }
 
+    // Ensure at least 2 spaces before inline comments (Fortitude S102)
+    // Runs after alignment so !< comments are already positioned
+    output_lines = ensure_two_spaces_before_inline_comment(&output_lines);
+
+    // Strip trailing semicolons (Fortitude S081)
+    output_lines = strip_trailing_semicolons(&output_lines);
+
     let mut result = output_lines.join("\n");
     if !result.is_empty() && !result.ends_with('\n') {
         result.push('\n');
@@ -1200,6 +1208,108 @@ fn is_declaration_line(line: &str) -> bool {
     false
 }
 
+/// Ensure at least 2 spaces before inline `!` comments on code lines.
+/// This satisfies Fortitude rule S102. Only applies to lines that have both
+/// code and a trailing comment (not standalone comment lines, not `!$` directives,
+/// not `!>` or `!<` Doxygen, not Fypp lines).
+fn ensure_two_spaces_before_inline_comment(lines: &[String]) -> Vec<String> {
+    lines.iter().map(|line| {
+        let trimmed = line.trim_start();
+        // Skip blank lines, standalone comments, preprocessor, Fypp
+        if trimmed.is_empty() || trimmed.starts_with('!') || trimmed.starts_with('#')
+            || trimmed.starts_with("$:") || trimmed.starts_with("@:") {
+            return line.clone();
+        }
+        // Find the inline comment position (! outside strings)
+        let bytes = line.as_bytes();
+        let mut in_string = false;
+        let mut delim = b' ';
+        for i in 0..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
+                    }
+                    in_string = false;
+                }
+            } else if bytes[i] == b'\'' || bytes[i] == b'"' {
+                in_string = true;
+                delim = bytes[i];
+            } else if bytes[i] == b'!' {
+                // Found inline comment. Check spacing before it.
+                if i == 0 { return line.clone(); } // standalone comment
+                // Skip directives (!$acc, !$omp), standalone Doxygen (!>), and !! continuations
+                let rest = &line[i..];
+                if rest.starts_with("!$") || rest.starts_with("!>") || rest.starts_with("!!") {
+                    return line.clone();
+                }
+                // Count spaces before the `!`
+                let mut spaces = 0;
+                let mut j = i;
+                while j > 0 && bytes[j - 1] == b' ' {
+                    spaces += 1;
+                    j -= 1;
+                }
+                if j == 0 { return line.clone(); } // all spaces before ! = standalone
+                if spaces >= 2 { return line.clone(); } // already ok
+                // Add spaces to reach 2, but only if it won't exceed line_length
+                let code_part = &line[..i].trim_end();
+                let comment_part = &line[i..];
+                return format!("{}  {}", code_part, comment_part);
+            }
+        }
+        line.clone()
+    }).collect()
+}
+
+/// Strip trailing semicolons from lines (Fortitude S081).
+/// Removes `;` at the end of a line (before any trailing comment), but only if
+/// it's truly trailing — not between statements on the same line.
+fn strip_trailing_semicolons(lines: &[String]) -> Vec<String> {
+    lines.iter().map(|line| {
+        let trimmed = line.trim_start();
+        // Skip blank, comment-only, preprocessor, Fypp lines
+        if trimmed.is_empty() || trimmed.starts_with('!') || trimmed.starts_with('#')
+            || trimmed.starts_with("$:") || trimmed.starts_with("@:") {
+            return line.clone();
+        }
+        // Find the code portion (before any inline comment)
+        let bytes = line.as_bytes();
+        let mut in_string = false;
+        let mut delim = b' ';
+        let mut comment_start = bytes.len();
+        for i in 0..bytes.len() {
+            if in_string {
+                if bytes[i] == delim {
+                    if i + 1 < bytes.len() && bytes[i + 1] == delim {
+                        continue;
+                    }
+                    in_string = false;
+                }
+            } else if bytes[i] == b'\'' || bytes[i] == b'"' {
+                in_string = true;
+                delim = bytes[i];
+            } else if bytes[i] == b'!' {
+                comment_start = i;
+                break;
+            }
+        }
+        let code = &line[..comment_start];
+        let comment = &line[comment_start..];
+        let code_trimmed = code.trim_end();
+        if code_trimmed.ends_with(';') {
+            let stripped = code_trimmed.strip_suffix(';').unwrap().trim_end();
+            if comment.is_empty() {
+                return format!("{}{}", &line[..line.len() - line.trim_start().len()], stripped.trim_start());
+            } else {
+                return format!("{}  {}", stripped, comment.trim_start());
+            }
+        }
+        line.clone()
+    }).collect()
+}
+
 /// Ensure a blank line between the last declaration and the first executable statement
 /// within procedure bodies. Only acts when there is no blank line already.
 fn separate_declarations_from_code(lines: &[String]) -> Vec<String> {
@@ -1442,10 +1552,27 @@ fn rewrap_line(line: &str, max_length: usize, indent_width: usize) -> Vec<String
         return vec![line.to_string()];
     }
 
-    // Align continuation lines with opening paren if present,
-    // otherwise use flat indent (one indent_width deeper).
-    let paren_col = content.find('(').map(|p| indent + p + 1);
-    let cont_indent = paren_col.unwrap_or(indent + indent_width);
+    // Align continuation with opening paren (string-aware), capped to avoid extreme indentation
+    let flat_indent = indent + indent_width;
+    let paren_col = {
+        let mut in_str = false;
+        let mut qch = b' ';
+        let mut found = None;
+        let cb = content.as_bytes();
+        for i in 0..cb.len() {
+            if in_str {
+                if cb[i] == qch { if i + 1 < cb.len() && cb[i + 1] == qch { continue; } in_str = false; }
+                continue;
+            }
+            if cb[i] == b'\'' || cb[i] == b'"' { in_str = true; qch = cb[i]; continue; }
+            if cb[i] == b'(' { found = Some(indent + i + 1); break; }
+        }
+        found
+    };
+    let cont_indent = match paren_col {
+        Some(col) if col <= indent + 40 => col,
+        _ => flat_indent,
+    };
     let cont_prefix = " ".repeat(cont_indent);
 
     // Available width: max_length minus indent minus " &" suffix
@@ -1498,13 +1625,26 @@ fn rewrap_line(line: &str, max_length: usize, indent_width: usize) -> Vec<String
         } else if last_other > 0 {
             last_other
         } else {
-            // No break point found — emit as-is (over-length)
-            if is_first {
-                result.push(format!("{}{}", " ".repeat(indent), remaining));
+            // No break within limit — find first comma AFTER limit (long string literal)
+            let mut first_comma_after = 0usize;
+            for &(bp, kind) in &breaks {
+                if bp <= pos { continue; }
+                if matches!(kind, BreakKind::Comma) {
+                    first_comma_after = bp - pos;
+                    break;
+                }
+            }
+            if first_comma_after > 0 {
+                first_comma_after
             } else {
-                result.push(format!("{}& {}", cont_prefix, remaining));
+                // No break point at all — emit as-is
+                if is_first {
+                    result.push(format!("{}{}", " ".repeat(indent), remaining));
+                } else {
+                    result.push(format!("{}& {}", cont_prefix, remaining));
+                }
+                break;
             }
-            break;
         };
 
         let chunk = content[pos..pos + best_break].trim_end();