gitronics 0.6.0__tar.gz → 0.6.2__tar.gz

{gitronics-0.6.0 → gitronics-0.6.2}/.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
             - name: Install Rust stable
               uses: dtolnay/rust-toolchain@stable
               with:
-                  components: clippy
+                  components: clippy, rustfmt
 
             - name: Set up Python (Required for PyO3 test linking)
               id: setup-python
@@ -49,12 +49,30 @@ jobs:
                       target
                   key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
+            - name: rustfmt
+              run: cargo fmt --all --check
+
             - name: Test
               run: cargo test --workspace --features pyo3/auto-initialize
 
             - name: Clippy
               run: cargo clippy --workspace -- -D warnings
 
+    ruff:
+        name: Python lint (ruff)
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: astral-sh/setup-uv@v5
+
+            # Pinned so a new ruff release can't fail CI unexpectedly; bump deliberately.
+            - name: ruff lint
+              run: uvx ruff@0.15.21 check python
+
+            - name: ruff format
+              run: uvx ruff@0.15.21 format --check python
+
     python:
         name: Python tests (${{ matrix.os }})
         runs-on: ${{ matrix.os }}

{gitronics-0.6.0 → gitronics-0.6.2}/Cargo.lock

@@ -390,7 +390,7 @@ dependencies = [
 
 [[package]]
 name = "gitronics"
-version = "0.6.0"
+version = "0.6.2"
 dependencies = [
  "chrono",
  "clap",

{gitronics-0.6.0 → gitronics-0.6.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gitronics"
-version = "0.6.0"
+version = "0.6.2"
 edition = "2024"
 description = "Build MCNP neutronics models from modular components"
 license = "EUPL-1.2"

{gitronics-0.6.0 → gitronics-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitronics
-Version: 0.6.0
+Version: 0.6.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{gitronics-0.6.0 → gitronics-0.6.2}/python/tests/test_cli_works.py

@@ -6,8 +6,12 @@ def test_cli_works():
     # Run in a subprocess so clap's process::exit(0) on --help doesn't kill pytest.
     # Actual behaviour is covered by the Rust unit tests.
     result = subprocess.run(
-        [sys.executable, "-c", "from gitronics import _cli_main; _cli_main()", "--help"],
+        [
+            sys.executable,
+            "-c",
+            "from gitronics import _cli_main; _cli_main()",
+            "--help",
+        ],
         capture_output=True,
     )
     assert result.returncode == 0
-    

{gitronics-0.6.0 → gitronics-0.6.2}/src/project_manager/load_project_files.rs

@@ -10,7 +10,7 @@ use migjorn::Model;
 use rayon::prelude::*;
 
 use crate::types::{FileName, FillerName};
-use crate::utils::{GitronicsError, parse_model_file, read_data_cards_text};
+use crate::utils::{GitronicsError, parse_model_file, read_data_cards_text, sort_data_card_chunks};
 
 use super::ProjectManager;
 
@@ -91,7 +91,9 @@ impl ProjectManager {
     }
 
     /// Concatenates the data-card text of every file in `names`, one blank-line
-    /// separated block per file, in configuration order.
+    /// separated block per file. Blocks are ordered by the id of each file's
+    /// first data card (deterministic output, independent of configuration
+    /// order); cards inside a file keep their original order.
     fn load_data_cards_text(&self, names: &[FileName]) -> Result<String, GitronicsError> {
         let mut chunks = Vec::new();
         for name in names {
@@ -99,6 +101,7 @@ impl ProjectManager {
             info!("Loading: {}", path.display());
             chunks.push(read_data_cards_text(path, name)?);
         }
+        sort_data_card_chunks(&mut chunks);
         Ok(chunks.join("\n"))
     }
 }

{gitronics-0.6.0 → gitronics-0.6.2}/src/utils.rs

@@ -158,6 +158,53 @@ pub fn read_data_cards_text(path: &Path, file_name: &FileName) -> Result<String,
     Ok(kept.join("\n"))
 }
 
+/// Sort key mirroring a data card's id: cards whose mnemonic ends in a number
+/// (`M1`, `F4`, `TR1`) order by that number and come first; mnemonics without a
+/// trailing number (`SDEF`, `MODE`) fall back to alphabetical order and come
+/// last — matching the old `DataCardId::{Int, String}` ordering.
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+enum DataCardKey {
+    Int(u32),
+    Str(String),
+}
+
+/// The sort key of a data-card file block, derived from the id of its first
+/// data card. Full-line comments (and blank lines) are skipped so a comment
+/// header does not decide the order.
+fn first_data_card_key(chunk: &str) -> DataCardKey {
+    for line in chunk.lines() {
+        if is_mcnp_comment(line) {
+            continue;
+        }
+        // First whitespace token is the mnemonic, minus any leading `*`.
+        let mnemonic = line
+            .split_whitespace()
+            .next()
+            .unwrap_or("")
+            .trim_start_matches('*');
+        // Split the trailing id number off the mnemonic letters (`TR1` -> 1,
+        // `F4:N` -> 4).
+        let digits: String = mnemonic
+            .chars()
+            .skip_while(|c| !c.is_ascii_digit())
+            .take_while(|c| c.is_ascii_digit())
+            .collect();
+        return match digits.parse::<u32>() {
+            Ok(id) => DataCardKey::Int(id),
+            Err(_) => DataCardKey::Str(mnemonic.to_ascii_uppercase()),
+        };
+    }
+    DataCardKey::Str(String::new())
+}
+
+/// Order data-card file blocks by the id of each block's first data card,
+/// keeping the cards inside a block in their original order (a stable sort over
+/// whole blocks). Restores the deterministic output the pre-migjorn-0.2 build
+/// produced via `order_data_cards_groups_by_id`.
+pub fn sort_data_card_chunks(chunks: &mut [String]) {
+    chunks.sort_by_key(|chunk| first_data_card_key(chunk));
+}
+
 /// True if `line` is an MCNP full-line comment (first non-blank character is
 /// `c`/`C`, followed by whitespace or end of line) or blank.
 fn is_mcnp_comment(line: &str) -> bool {
@@ -282,6 +329,35 @@ mod tests {
         assert!(err.to_string().contains("Duplicate file name `file1`"));
     }
 
+    #[test]
+    fn test_sort_data_card_chunks_by_first_card_id() {
+        // Blocks arrive in arbitrary configuration order.
+        let mut chunks = vec![
+            "m10 1001 1\nm2 8016 1".to_string(), // first card M10 -> 10
+            "C header\nm1 6000 1".to_string(),   // comment skipped, M1 -> 1
+            "sdef pos=0 0 0".to_string(),        // no id -> sorts last
+            "m3 26000 1".to_string(),            // M3 -> 3
+        ];
+        sort_data_card_chunks(&mut chunks);
+        assert_eq!(
+            chunks,
+            vec![
+                "C header\nm1 6000 1".to_string(),
+                "m3 26000 1".to_string(),
+                "m10 1001 1\nm2 8016 1".to_string(),
+                "sdef pos=0 0 0".to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_sort_data_card_chunks_is_stable_within_block() {
+        // Cards inside a block are never reordered, even if not id-sorted.
+        let mut chunks = vec!["m5 1001 1\nm2 8016 1".to_string()];
+        sort_data_card_chunks(&mut chunks);
+        assert_eq!(chunks, vec!["m5 1001 1\nm2 8016 1".to_string()]);
+    }
+
     #[test]
     fn test_io_path_normalizes_parent_segments_when_not_canonicalizable() {
         let err = GitronicsError::io_path(