style: use scala3 indentation style

Author: kelvin-olaiya

src/test/scala/io/github/kelvindev15/prolog/core/TestRecursiveStructs.scala

@@ -9,65 +9,55 @@ import org.scalatest.matchers.should.Matchers
 class TestRecursiveStructs extends AnyFunSuite with Matchers:
   private val cmpGoal = Conjunction(Atom("X"), Atom("Y"), Atom("Z"))
 
-  test("Cannot create a conjunction of goals from no terms") {
-    assertThrows[IllegalArgumentException] {
+  test("Cannot create a conjunction of goals from no terms"):
+    assertThrows[IllegalArgumentException]:
       Conjunction.wrapIfNecessary()
-    }
-  }
-
-  test("A conjunction of goal is a recursive predicate with arity 2 and with ',' as a functor") {
+    
+  test("A conjunction of goal is a recursive predicate with arity 2 and with ',' as a functor"):
     cmpGoal shouldBe a [Term]
     cmpGoal.arity shouldBe 2
     cmpGoal.functor shouldBe Atom(",")
-  }
 
-  test("Goal conjunction arguments") {
+  test("Goal conjunction arguments"):
     cmpGoal.first shouldBe Atom("X")
     cmpGoal.second shouldBe Conjunction(Atom("Y"), Atom("Z"))
-  }
+    
   private val goals = Seq(
     Atom("X"),
     Conjunction(Atom("X"), Variable("O")),
     Variable("Z"),
     Conjunction(Constant(1), Constant(2)))
   private val linearizationExpectation = goals.take(3) ++ Seq(Constant(1), Constant(2))
 
-  test("Compound goal linearized arguments") {
+  test("Compound goal linearized arguments"):
     val complexGoalConjunction = Conjunction(goals *)
     complexGoalConjunction.linearizedArguments shouldBe linearizationExpectation
-  }
 
-  test("Disjunction of goals linearized arguments") {
+  test("Disjunction of goals linearized arguments"):
     val complexGoalDisjunction = Disjunction(goals *)
     complexGoalDisjunction.linearizedArguments shouldBe linearizationExpectation
-  }
 
   private val list = PrologList(Atom("a"), Atom("b"), Atom("c"), Atom("d"))
 
-  test("PrologList creation") {
+  test("PrologList creation"):
     list shouldBe a [Term]
     list.functor shouldBe Atom(".")
     list.arity shouldBe 2
     list.arguments.head shouldBe Atom("a")
     list.arguments.tail.head shouldBe a [PrologList]
-  }
 
-  test("Prolog list arguments") {
+  test("Prolog list arguments"):
     list.linearizedArguments shouldBe Seq("a", "b", "c", "d").map(Atom(_))
-  }
 
-  test("Creation of a prolog list with Cons and Nil") {
+  test("Creation of a prolog list with Cons and Nil"):
     Cons(Atom("a"), Cons(Atom("b"), Cons(Atom("c"), Cons(Atom("d"), Nil)))) shouldBe list
-  }
-
-  test("A list can end also with a variable") {
+  
+  test("A list can end also with a variable"):
     val list = Cons(Atom("a"), Variable("X"))
     list shouldBe a [PrologList]
     list.linearizedArguments shouldBe Seq(Atom("a"), Variable("X"))
-  }
 
-  test("A list not ending with a variable") {
+  test("A list not ending with a variable"):
     val list = PrologList(Atom("a"), Variable("X"))
     list shouldBe Cons(Atom("a"), Cons(Variable("X"), Nil))
     assert(list != Cons(Atom("a"), Variable("X")))
-  }

src/test/scala/io/github/kelvindev15/prolog/core/TestRules.scala

@@ -13,23 +13,18 @@ class TestRules extends AnyFlatSpec with Matchers:
     Struct(Atom("father"), Variable("Z"), Variable("Y"))
   )
 
-  "A rule" can "have a single term body" in {
+  "A rule" can "have a single term body" in:
     Rule(Struct(Atom("edible"), Variable("X")), Struct(Atom("food"), Variable("X"))) shouldBe a [Term]
-  }
 
-  "The functor of a rule" should "be ':-'" in {
+  "The functor of a rule" should "be ':-'" in:
     grandfatherRule.functor shouldBe Atom("':-'")
-  }
 
-  "The arity of a rule" should "be 2" in {
+  "The arity of a rule" should "be 2" in:
     grandfatherRule.arity shouldBe 2
-  }
 
-  "The rule grandfather(X, Y) :- father(X, Z), father(Z, Y)" should "have 2 terms in the linearized version" in {
+  "The rule grandfather(X, Y) :- father(X, Z), father(Z, Y)" should "have 2 terms in the linearized version" in:
     grandfatherRule.body.accept(BinaryToFlatVisitor()) should have size 2
-  }
 
-  it should "have a grandfather(X, Y) as a head" in {
+  it should "have a grandfather(X, Y) as a head" in:
     assert(grandfatherRule.head.isDefined)
     grandfatherRule.head.get shouldBe Struct(Atom("grandfather"), Variable("X"), Variable("Y"))
-  }

src/test/scala/io/github/kelvindev15/prolog/core/TestStructs.scala

@@ -7,33 +7,26 @@ import org.scalatest.matchers.should.Matchers
 
 class TestStructs extends AnyFlatSpec with Matchers:
 
-  "A struct" should "be comprised of a functor and a sequence of one ore more arguments" in {
+  "A struct" should "be comprised of a functor and a sequence of one ore more arguments" in:
     Seq(
       Struct(Atom("father"), Atom("abraham"), Atom("therach")),
       Struct(Atom("sum"), Numeric(2), Numeric(5), Numeric(7))
-    ) foreach {
-      _ shouldBe a[Term]
-    }
-  }
+    ) foreach { _ shouldBe a[Term] }
 
-  "The arity of a Struct " should "equal the number of arguments" in {
+  "The arity of a Struct " should "equal the number of arguments" in:
     val args = Seq(Variable("X"), Atom("pasta"), Constant(4.5))
     Struct(Atom("order"), args*).arity shouldBe args.size
-  }
 
-  "The functor of the struct equivalent to father(X, X) " should "be the atom father" in {
+  "The functor of the struct equivalent to father(X, X) " should "be the atom father" in:
     Struct(Atom("father"), Variable("X"), Variable("X")).functor shouldBe Atom("father")
-  }
 
-  "Non ground term variables" should "not be empty" in {
+  "Non ground term variables" should "not be empty" in:
     Struct(Atom("likes"), Atom("mario"), Variable("X")).variables shouldEqual Seq(Variable("X"))
     Struct(Atom("likes"), Atom("mario"), Struct(Atom("food"), Variable("X"))).variables shouldEqual Seq(Variable("X"))
-  }
 
-  "Only terms with no variables" should "be ground" in {
+  "Only terms with no variables" should "be ground" in:
     val groundTerm = Struct(Atom("likes"), Atom("mario"), Atom("pizza"))
     assert(groundTerm.isGround)
 
     val nonGroundTerm = Struct(Atom("likes"), Atom("mario"), Struct(Atom("food"), Variable("X")))
     assert(!nonGroundTerm.isGround)
-  }

src/test/scala/io/github/kelvindev15/prolog/core/TestVariables.scala

@@ -7,21 +7,15 @@ import org.scalatest.matchers.should.Matchers
 
 class TestVariables extends AnyFlatSpec with Matchers:
 
-  "_" should "be an anonymous variable" in {
+  "_" should "be an anonymous variable" in:
     assert(Variable("_").isAnonymous)
-  }
 
-  "A variable name" should "be an alphanumerical string beginning with an with an uppercase letter" in {
-    Seq("X", "X2", "Abraham", "Snake_variable", "_") foreach {
-      Variable(_) shouldBe a[Variable]
-    }
+  "A variable name" should "be an alphanumerical string beginning with an with an uppercase letter" in:
+    Seq("X", "X2", "Abraham", "Snake_variable", "_") foreach { Variable(_) shouldBe a[Variable] }
     Seq("a", "2X", "X$", "A-Y") foreach { name =>
-      assertThrows[IllegalArgumentException] {
+      assertThrows[IllegalArgumentException]:
         Variable(name)
-      }
     }
-  }
 
-  it should "not be ground" in {
+  it should "not be ground" in:
     assert(!Variable("X").isGround)
-  }

src/test/scala/io/github/kelvindev15/prolog/core/theory/TestTheory.scala

@@ -11,16 +11,14 @@ import org.scalatest.matchers.should.Matchers
 class TestTheory extends AnyFunSuite with BeforeAndAfterAll with Matchers:
   private val rule = Rule(Struct(Atom("eatable"), Variable("X")), Struct(Atom("food"), Variable("X")))
 
-  test("Adding a rule to a prolog program") {
+  test("Adding a rule to a prolog program"):
     var program = Theory()
     program shouldBe empty
     program = program add rule
     program should have size 1
-  }
 
-  test("Removing a rule from a prolog program") {
+  test("Removing a rule from a prolog program"):
     var program = Theory(rule)
     program should have size 1
     program = program remove rule
     program shouldBe empty
-  }