plum

#![allow(non_snake_case)]

use plum_core::loadAndMerge;

use std::fs;

use tempfile::TempDir;

/// Writes `name` (without a directory prefix — always placed directly under

/// the temp dir's `lib_path` subdirectory) with `contents`, creating parent

/// directories as needed (so `"std/option"` works).

fn writeLibFile(lib_path: &std::path::Path, name: &str, contents: &str) -> std::path::PathBuf {

    let path = lib_path.join(format!("{}.plum", name));

    fs::create_dir_all(path.parent().unwrap()).unwrap();

    fs::write(&path, contents).unwrap();

    path

}

#[test]

fn importSeesImportedDeclarations() {

    let dir = TempDir::new().unwrap();

    let lib_path = dir.path().join("libs");

    writeLibFile(&lib_path, "helper", "module fixtures\n\nfun helperFn() -> Int =\n  42\n");

    let entry = writeLibFile(&lib_path, "main", "module fixtures\n\nimport helper\n\nfun main() -> Int =\n  helperFn()\n");

    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");

    let names: Vec<&str> = merged.items.iter().filter_map(|i| match i {

        plum_core::ast::Item::Fn(f) => Some(f.name.as_str()),

        _ => None,

    }).collect();

    assert!(names.contains(&"main"), "expected 'main' in merged items, got {:?}", names);

    assert!(names.contains(&"helperFn"), "expected 'helperFn' in merged items, got {:?}", names);

}

#[test]

fn transitiveImportSurfacesGrandchildDeclarations() {

    let dir = TempDir::new().unwrap();

    let lib_path = dir.path().join("libs");

    writeLibFile(&lib_path, "c", "module fixtures\n\nfun cFn() -> Int =\n  3\n");

    writeLibFile(&lib_path, "b", "module fixtures\n\nimport c\n\nfun bFn() -> Int =\n  cFn()\n");

    let entry = writeLibFile(&lib_path, "a", "module fixtures\n\nimport b\n\nfun main() -> Int =\n  bFn()\n");

    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");

    let names: Vec<&str> = merged.items.iter().filter_map(|i| match i {

        plum_core::ast::Item::Fn(f) => Some(f.name.as_str()),

        _ => None,

    }).collect();

    assert!(names.contains(&"cFn"), "expected transitively-imported 'cFn', got {:?}", names);

}

#[test]

fn diamondImportIncludesSharedDependencyOnce() {

    let dir = TempDir::new().unwrap();

    let lib_path = dir.path().join("libs");

    writeLibFile(&lib_path, "d", "module fixtures\n\nfun dFn() -> Int =\n  4\n");

    writeLibFile(&lib_path, "b", "module fixtures\n\nimport d\n\nfun bFn() -> Int =\n  dFn()\n");

    writeLibFile(&lib_path, "c", "module fixtures\n\nimport d\n\nfun cFn() -> Int =\n  dFn()\n");

    let entry = writeLibFile(&lib_path, "a", "module fixtures\n\nimport b\nimport c\n\nfun main() -> Int =\n  bFn() + cFn()\n");

    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");

    let d_count = merged.items.iter().filter(|i| matches!(i, plum_core::ast::Item::Fn(f) if f.name == "dFn")).count();

    assert_eq!(d_count, 1, "expected 'dFn' exactly once in a diamond import, got {}", d_count);

}

#[test]

fn importCycleResolvesWithoutHangingOrErroring() {

    let dir = TempDir::new().unwrap();

    let lib_path = dir.path().join("libs");

    writeLibFile(&lib_path, "b", "module fixtures\n\nimport a\n\nfun bFn() -> Int =\n  1\n");

    let entry = writeLibFile(&lib_path, "a", "module fixtures\n\nimport b\n\nfun main() -> Int =\n  bFn()\n");

    let merged = loadAndMerge(&entry, &lib_path).expect("import cycle should resolve, not error");

    let names: Vec<&str> = merged.items.iter().filter_map(|i| match i {

        plum_core::ast::Item::Fn(f) => Some(f.name.as_str()),

        _ => None,

    }).collect();

    assert!(names.contains(&"main"));

    assert!(names.contains(&"bFn"));

}

#[test]

fn unresolvableImportIsAClearError() {

    let dir = TempDir::new().unwrap();

    let lib_path = dir.path().join("libs");

    let entry = writeLibFile(&lib_path, "main", "module fixtures\n\nimport does_not_exist\n\nfun main() -> Int =\n  0\n");

    let result = loadAndMerge(&entry, &lib_path);

    assert!(result.is_err());

    let msg = result.unwrap_err();

    assert!(msg.contains("does_not_exist"), "expected error to name the missing import, got: {}", msg);

}

#[test]

fn duplicateTopLevelNameAcrossFilesIsAClearError() {

    let dir = TempDir::new().unwrap();

    let lib_path = dir.path().join("libs");

    writeLibFile(&lib_path, "helper", "module fixtures\n\nfun sharedFn() -> Int =\n  1\n");

    let entry = writeLibFile(&lib_path, "main", "module fixtures\n\nimport helper\n\nfun sharedFn() -> Int =\n  2\n");

    let result = loadAndMerge(&entry, &lib_path);

    assert!(result.is_err());

    let msg = result.unwrap_err();

    assert!(msg.contains("sharedFn"), "expected error to name the duplicate 'sharedFn', got: {}", msg);

}

#[test]

fn sameMethodNameOnDifferentReceiversAcrossFilesIsNotACollision() {

    let dir = TempDir::new().unwrap();

    let lib_path = dir.path().join("libs");

    writeLibFile(&lib_path, "cat", "\

module fixtures

type Cat =

  age: Int

  fun length(self) -> Int =

    self.age

");

    let entry = writeLibFile(&lib_path, "main", "\

module fixtures

import cat

type Box =

  items: Int

  fun length(self) -> Int =

    self.items

fun main() -> Int =

  0

");

    let merged = loadAndMerge(&entry, &lib_path).expect("same method name on different receivers should not collide");

    let method_count = merged.items.iter().filter(|i| matches!(i, plum_core::ast::Item::Fn(f) if f.name == "length")).count();

    assert_eq!(method_count, 2, "expected both 'length' methods to survive the merge, got {}", method_count);

}