plum

#![allow(non_snake_case)]

use plum_core::formatSource;

#[test]

fn formatsSimpleFunction() {

    let input = "fun main() =\n  x = 1\n";

    let result = formatSource(input).expect("formatSource should succeed");

    assert!(result.contains("main()"));

    assert!(result.contains("x ="));

}

#[test]

fn formatsBinaryOperatorSpacing() {

    let input = "fun add(a: Int, b: Int) -> Int =\n  a+b\n";

    let result = formatSource(input).expect("formatSource should succeed");

    assert!(result.contains("a + b"));

}

#[test]

fn rejectsSyntaxError() {

    let input = "@@@@invalid@@@@\n";

    let result = formatSource(input);

    assert!(result.is_err());

}

#[test]

fn idempotentOnAlreadyFormatted() {

    let input = "fun main() =\n  x = 1 + 2\n";

    let first = formatSource(input).expect("first pass");

    let second = formatSource(&first).expect("second pass");

    assert_eq!(first, second, "formatting should be idempotent");

}

/// Regression test for a real bug: Topiary inserts NO whitespace between

/// adjacent leaves unless a query says to, so keywords with no explicit

/// spacing rule glue to the next token ("module" + "test" -> "moduletest").

/// This exercises most of the keyword vocabulary in one pass.

#[test]

fn keywordsGetSpacedCorrectly() {

    let input = "\

module test

import std/os

type Cat(IAnimal) =

  name: Str

  age: Int

  fun speak(self) -> Str =

    \"meow\"

fun classify(x: Int) -> Str =

  if x < 0

    return \"neg\"

  else if x == 0

    return \"zero\"

  else

    return \"pos\"

fun loop() -> Int =

  i := 0

  while i < 5

    i = i + 1

  return i

fun main() =

  assert 1 == 1

  return

";

    let once = formatSource(input).expect("first pass");

    assert!(once.contains("module test"), "got: {once}");

    assert!(once.contains("import std/os"), "got: {once}");

    assert!(once.contains("type Cat"), "got: {once}");

    assert!(once.contains("fun speak"), "got: {once}");

    assert!(once.contains("if x < 0"), "got: {once}");

    assert!(once.contains("else if x == 0"), "got: {once}");

    let twice = formatSource(&once).expect("second pass");

    assert_eq!(once, twice, "formatting should be idempotent");

}

/// Regression test: `import std/os` used to format down to `import /` — the

/// `url` grammar rule matched each path segment with a bare inline regex (no

/// node of its own), and Topiary's leaf collection only ever copies a

/// child NODE's own span, silently dropping any parent text a bare regex

/// like that leaves uncovered.

#[test]

fn importPathSegmentsSurviveFormatting() {

    let input = "module test\nimport std/http/content_type\n";

    let once = formatSource(input).expect("first pass");

    assert!(once.contains("import std/http/content_type"), "got: {once}");

}

/// Regression test: the ternary `?`/`:` had no spacing rule at all, and enum

/// variants / match cases (`| Foo`, `match ... case`) live directly under

/// their parent node (no wrapping body), so they need their own hardline

/// rules distinct from a `fn` body's.

#[test]

fn ternaryEnumAndMatchFormatCorrectlyAndIdempotently() {

    let input = "\

module test

enum Color =

  | Red

  | Green

  fun isRed(self) -> Bool =

    match self

      Red => True

      Green => False

fun abs(x: Int) -> Int =

  x < 0 ? -x : x

";

    let once = formatSource(input).expect("first pass");

    assert!(once.contains("x < 0 ? -x : x"), "got: {once}");

    assert!(once.contains("| Red"), "got: {once}");

    let twice = formatSource(&once).expect("second pass");

    assert_eq!(once, twice, "formatting should be idempotent");

}

/// Regression test: a standalone comment between two statements/methods used

/// to glue onto the end of the previous line on a SECOND formatting pass

/// (the naive fix, `@prepend_hardline`, would instead wrongly force even a

/// TRAILING same-line comment onto its own line) — `@prepend_input_softline`

/// preserves whichever the source actually had.

#[test]

fn commentsFormatIdempotently() {

    let input = "\

fun abs(self) -> Int =

  self < 0 ? -self : self

# a standalone comment between two functions

fun square(self) -> Int =

  self * self # a trailing comment

";

    let once = formatSource(input).expect("first pass");

    let twice = formatSource(&once).expect("second pass");

    assert_eq!(once, twice, "formatting should be idempotent");

}