cobolx 1.0.0

package/src/ui.rs

@@ -0,0 +1,2 @@
+pub mod draw;
+pub mod tui;

package/tests/indexer_tests.rs

@@ -0,0 +1,192 @@
+use std::fs::{self, File};
+use std::io::Write;
+use tempfile::tempdir;
+
+#[test]
+fn init_indexer_persists_program_copybook_and_call_edges() {
+    let dir = tempdir().unwrap();
+    let copy_dir = dir.path().join("copy");
+    fs::create_dir_all(&copy_dir).unwrap();
+
+    File::create(dir.path().join("MAIN.cbl"))
+        .unwrap()
+        .write_all(
+            br#"
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. MAIN.
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+       01 WS-NEXT-PGM PIC X(8).
+       COPY CUSTOMER.
+       PROCEDURE DIVISION.
+           CALL "SUB001"
+               USING WS-NEXT-PGM.
+           CALL WS-NEXT-PGM.
+           STOP RUN.
+"#,
+        )
+        .unwrap();
+
+    File::create(dir.path().join("SUB001.cbl"))
+        .unwrap()
+        .write_all(
+            br#"
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. SUB001.
+       PROCEDURE DIVISION.
+           EXIT PROGRAM.
+"#,
+        )
+        .unwrap();
+
+    File::create(dir.path().join("CUSTOMER.cpy"))
+        .unwrap()
+        .write_all(
+            br#"
+       01 CUSTOMER-REC.
+          05 CUST-ID PIC X(10).
+          05 CUST-BALANCE PIC S9(7)V99
+             COMP-3.
+          05 CUST-ALIAS REDEFINES CUST-ID PIC X(10).
+          05 CUST-ADDR OCCURS
+             3 TIMES
+             PIC X(20).
+"#,
+        )
+        .unwrap();
+
+    let mut store = rdo::memory::MemoryStore::open_or_create(dir.path()).unwrap();
+    let report = rdo::cobol::indexer::index_sandbox(dir.path(), &mut store).unwrap();
+
+    assert_eq!(report.source_count, 2);
+    assert_eq!(report.copybook_count, 1);
+    assert_eq!(report.programs.len(), 2);
+    assert_eq!(report.copybook_uses, 1);
+    assert_eq!(report.resolved_copybooks, 1);
+    assert_eq!(report.static_calls, 1);
+    assert_eq!(report.dynamic_calls, 1);
+    assert_eq!(report.data_items, 6);
+
+    let conn = store.connection();
+    let programs: i64 = conn
+        .query_row("SELECT COUNT(*) FROM programs", [], |row| row.get(0))
+        .unwrap();
+    let copies: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM copybook_uses WHERE resolve_status = 'resolved'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let static_calls: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM call_edges WHERE kind = 'static'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let dynamic_calls: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM call_edges WHERE kind = 'dynamic'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let data_items: i64 = conn
+        .query_row("SELECT COUNT(*) FROM data_items", [], |row| row.get(0))
+        .unwrap();
+    let cust_id_pic: String = conn
+        .query_row(
+            "SELECT pic FROM data_items WHERE name = 'CUST-ID'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let comp3_usage: String = conn
+        .query_row(
+            "SELECT usage_clause FROM data_items WHERE name = 'CUST-BALANCE'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let comp3_pic: String = conn
+        .query_row(
+            "SELECT pic FROM data_items WHERE name = 'CUST-BALANCE'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let redefines: String = conn
+        .query_row(
+            "SELECT redefines FROM data_items WHERE name = 'CUST-ALIAS'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let occurs: i64 = conn
+        .query_row(
+            "SELECT occurs FROM data_items WHERE name = 'CUST-ADDR'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    let ws_layout: (i64, i64, String) = conn
+        .query_row(
+            "SELECT byte_offset, byte_size, storage_kind FROM data_items WHERE name = 'WS-NEXT-PGM'",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .unwrap();
+    let customer_group: (i64, i64, String) = conn
+        .query_row(
+            "SELECT byte_offset, byte_size, storage_kind FROM data_items WHERE name = 'CUSTOMER-REC'",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .unwrap();
+    let cust_id_layout: (i64, i64) = conn
+        .query_row(
+            "SELECT byte_offset, byte_size FROM data_items WHERE name = 'CUST-ID'",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+    let comp3_layout: (i64, i64, String) = conn
+        .query_row(
+            "SELECT byte_offset, byte_size, storage_kind FROM data_items WHERE name = 'CUST-BALANCE'",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .unwrap();
+    let alias_layout: (i64, i64) = conn
+        .query_row(
+            "SELECT byte_offset, byte_size FROM data_items WHERE name = 'CUST-ALIAS'",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+    let occurs_layout: (i64, i64) = conn
+        .query_row(
+            "SELECT byte_offset, byte_size FROM data_items WHERE name = 'CUST-ADDR'",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+
+    assert_eq!(programs, 2);
+    assert_eq!(copies, 1);
+    assert_eq!(static_calls, 1);
+    assert_eq!(dynamic_calls, 1);
+    assert_eq!(data_items, 6);
+    assert_eq!(cust_id_pic, "X(10)");
+    assert_eq!(comp3_pic, "S9(7)V99");
+    assert_eq!(comp3_usage, "COMP-3");
+    assert_eq!(redefines, "CUST-ID");
+    assert_eq!(occurs, 3);
+    assert_eq!(ws_layout, (0, 8, "display".to_string()));
+    assert_eq!(customer_group, (8, 75, "group".to_string()));
+    assert_eq!(cust_id_layout, (8, 10));
+    assert_eq!(comp3_layout, (18, 5, "packed-decimal".to_string()));
+    assert_eq!(alias_layout, (8, 10));
+    assert_eq!(occurs_layout, (23, 60));
+}

package/tests/memory_store_tests.rs

@@ -0,0 +1,21 @@
+use tempfile::tempdir;
+
+#[test]
+fn first_open_creates_memory_database_and_schema() {
+    let dir = tempdir().unwrap();
+
+    let store = rdo::memory::MemoryStore::open_or_create(dir.path()).unwrap();
+
+    assert!(store.db_path().exists());
+
+    let count: i64 = store
+        .connection()
+        .query_row(
+            "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name IN ('files', 'programs', 'runs', 'skills')",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+
+    assert_eq!(count, 4);
+}

package/tests/project_files_tests.rs

@@ -0,0 +1,72 @@
+use rdo::memory::MemoryStore;
+use tempfile::tempdir;
+
+#[test]
+fn markdown_files_are_created_appended_and_read_under_docs_dir() {
+    let dir = tempdir().unwrap();
+    let store = MemoryStore::open_or_create(dir.path()).unwrap();
+
+    let path = store
+        .write_markdown("analysis/init.md", "# Init\n")
+        .unwrap();
+    store
+        .append_markdown("analysis/init.md", "\nCOBOL inventory ready.\n")
+        .unwrap();
+
+    assert!(path.starts_with(store.docs_dir()));
+    assert!(path.starts_with(dir.path().join("docs")));
+    assert_eq!(
+        store.read_markdown("analysis/init.md").unwrap(),
+        "# Init\n\nCOBOL inventory ready.\n"
+    );
+}
+
+#[test]
+fn skill_files_are_created_and_read_under_skills_dir() {
+    let dir = tempdir().unwrap();
+    let store = MemoryStore::open_or_create(dir.path()).unwrap();
+
+    let path = store
+        .write_skill_file("cobol-migration/SKILL.md", "# COBOL Migration\n")
+        .unwrap();
+
+    assert!(path.starts_with(store.skills_dir()));
+    assert_eq!(
+        store.read_skill_file("cobol-migration/SKILL.md").unwrap(),
+        "# COBOL Migration\n"
+    );
+}
+
+#[test]
+fn windows_style_relative_paths_are_normalized() {
+    let dir = tempdir().unwrap();
+    let store = MemoryStore::open_or_create(dir.path()).unwrap();
+
+    let path = store
+        .write_markdown("analysis\\windows.md", "# Windows\n")
+        .unwrap();
+
+    assert!(path.starts_with(dir.path().join("docs")));
+    assert_eq!(
+        store.read_markdown("analysis/windows.md").unwrap(),
+        "# Windows\n"
+    );
+}
+
+#[test]
+fn project_file_writer_rejects_unsafe_or_wrong_paths() {
+    let dir = tempdir().unwrap();
+    let store = MemoryStore::open_or_create(dir.path()).unwrap();
+
+    assert!(store.write_markdown("../escape.md", "bad").is_err());
+    assert!(store.write_markdown("..\\escape.md", "bad").is_err());
+    assert!(store.write_markdown("C:\\tmp\\escape.md", "bad").is_err());
+    assert!(store.write_markdown("\\\\srv\\share\\x.md", "bad").is_err());
+    assert!(store.write_markdown("CON.md", "bad").is_err());
+    assert!(
+        store
+            .write_markdown("notes/not-markdown.txt", "bad")
+            .is_err()
+    );
+    assert!(store.write_skill_file("../SKILL.md", "bad").is_err());
+}

package/tests/sandbox_tests.rs

@@ -0,0 +1,178 @@
+use std::fs::{self, File};
+use std::io::Write;
+use tempfile::tempdir;
+
+#[test]
+fn test_scan_finds_cobol_files_flat() {
+    let dir = tempdir().unwrap();
+
+    // Create mock COBOL files with various supported extensions
+    File::create(dir.path().join("main.cbl"))
+        .unwrap()
+        .write_all(b"IDENTIFICATION DIVISION.")
+        .unwrap();
+    File::create(dir.path().join("utility.cpy"))
+        .unwrap()
+        .write_all(b"01 WS-VAR PIC X.")
+        .unwrap();
+    File::create(dir.path().join("test.cob"))
+        .unwrap()
+        .write_all(b"PROCEDURE DIVISION.")
+        .unwrap();
+    File::create(dir.path().join("other.coo"))
+        .unwrap()
+        .write_all(b"DATA DIVISION.")
+        .unwrap();
+
+    // Create non-COBOL files that should be ignored
+    File::create(dir.path().join("README.md")).unwrap();
+    File::create(dir.path().join("Cargo.toml")).unwrap();
+
+    let result = rdo::cobol::scanner::scan_sandbox(dir.path()).unwrap();
+
+    assert_eq!(result.len(), 4);
+
+    let sources: Vec<_> = result
+        .iter()
+        .filter(|f| f.file_type == rdo::cobol::scanner::CobolFileType::Source)
+        .collect();
+    let copybooks: Vec<_> = result
+        .iter()
+        .filter(|f| f.file_type == rdo::cobol::scanner::CobolFileType::Copybook)
+        .collect();
+
+    assert_eq!(
+        sources.len(),
+        3,
+        "Should find 3 source files (.cbl, .cob, .coo)"
+    );
+    assert_eq!(copybooks.len(), 1, "Should find 1 copybook file (.cpy)");
+}
+
+#[test]
+fn test_scan_recursive_finds_nested_files() {
+    let dir = tempdir().unwrap();
+
+    // Create nested directory structure
+    let sub1 = dir.path().join("module_a");
+    let sub2 = dir.path().join("module_b");
+    let sub2_nested = sub2.join("submodule");
+    fs::create_dir_all(&sub1).unwrap();
+    fs::create_dir_all(&sub2_nested).unwrap();
+
+    File::create(dir.path().join("main.cbl"))
+        .unwrap()
+        .write_all(b"ROOT")
+        .unwrap();
+    File::create(sub1.join("helper.cbl"))
+        .unwrap()
+        .write_all(b"SUB1")
+        .unwrap();
+    File::create(sub2.join("process.cob"))
+        .unwrap()
+        .write_all(b"SUB2")
+        .unwrap();
+    File::create(sub2_nested.join("deep.cpy"))
+        .unwrap()
+        .write_all(b"DEEP")
+        .unwrap();
+
+    let result = rdo::cobol::scanner::scan_sandbox(dir.path()).unwrap();
+
+    assert_eq!(
+        result.len(),
+        4,
+        "Should find all 4 COBOL files across nested dirs"
+    );
+
+    // Verify paths are sorted
+    for i in 1..result.len() {
+        assert!(
+            result[i - 1].path <= result[i].path,
+            "Results should be sorted by path"
+        );
+    }
+}
+
+#[test]
+fn test_scan_excludes_hidden_and_build_dirs() {
+    let dir = tempdir().unwrap();
+
+    // Create directories that should be excluded
+    let git_dir = dir.path().join(".git");
+    let target_dir = dir.path().join("target");
+    let node_modules = dir.path().join("node_modules");
+    let vendor_dir = dir.path().join("vendor");
+    let build_dir = dir.path().join("build");
+    let hidden_dir = dir.path().join(".hidden");
+    let valid_dir = dir.path().join("src");
+
+    for d in &[
+        &git_dir,
+        &target_dir,
+        &node_modules,
+        &vendor_dir,
+        &build_dir,
+        &hidden_dir,
+        &valid_dir,
+    ] {
+        fs::create_dir_all(d).unwrap();
+    }
+
+    // Put COBOL files in excluded dirs (should NOT be found)
+    File::create(git_dir.join("hooks.cbl")).unwrap();
+    File::create(target_dir.join("out.cbl")).unwrap();
+    File::create(node_modules.join("dep.cbl")).unwrap();
+    File::create(vendor_dir.join("lib.cbl")).unwrap();
+    File::create(build_dir.join("gen.cbl")).unwrap();
+    File::create(hidden_dir.join("secret.cbl")).unwrap();
+
+    // Put COBOL files in valid dirs (SHOULD be found)
+    File::create(dir.path().join("root.cbl"))
+        .unwrap()
+        .write_all(b"ROOT")
+        .unwrap();
+    File::create(valid_dir.join("app.cob"))
+        .unwrap()
+        .write_all(b"APP")
+        .unwrap();
+
+    let result = rdo::cobol::scanner::scan_sandbox(dir.path()).unwrap();
+
+    assert_eq!(
+        result.len(),
+        2,
+        "Should only find files outside excluded directories"
+    );
+
+    let names: Vec<String> = result
+        .iter()
+        .map(|f| f.path.file_name().unwrap().to_string_lossy().into_owned())
+        .collect();
+    assert!(names.contains(&"root.cbl".to_string()));
+    assert!(names.contains(&"app.cob".to_string()));
+}
+
+#[test]
+fn test_scan_empty_directory() {
+    let dir = tempdir().unwrap();
+
+    let result = rdo::cobol::scanner::scan_sandbox(dir.path()).unwrap();
+    assert!(result.is_empty(), "Empty dir should return no results");
+}
+
+#[test]
+fn test_scan_tracks_file_size() {
+    let dir = tempdir().unwrap();
+
+    let content = b"IDENTIFICATION DIVISION.\nPROGRAM-ID. HELLO.\n";
+    File::create(dir.path().join("sized.cbl"))
+        .unwrap()
+        .write_all(content)
+        .unwrap();
+
+    let result = rdo::cobol::scanner::scan_sandbox(dir.path()).unwrap();
+
+    assert_eq!(result.len(), 1);
+    assert_eq!(result[0].size_bytes, content.len() as u64);
+}