feat: Implement JSON output for UnitedWeStandApp

The application now outputs the final state of the society simulation in JSON format.

Changes include:
- Added Circe library for JSON serialization.
- Created JSON encoders for Society and Participant classes.
- Modified UnitedWeStandApp to convert its result to JSON and print it to standard output.
- Removed console logging from the Society class to avoid interference with JSON output.
- Added a unit test to verify the correctness of the JSON output.

Author: google-labs-jules[bot]

build.sbt

@@ -11,3 +11,9 @@ libraryDependencies += "org.clapper"                %% "grizzled-slf4j"
 libraryDependencies += "ch.qos.logback"             % "logback-classic"            % "1.1.8"
 libraryDependencies += "ch.qos.logback"             % "logback-core"               % "1.1.8"
 libraryDependencies += "ch.qos.logback"             % "logback-access"             % "1.1.8"
+
+libraryDependencies ++= Seq(
+  "io.circe" %% "circe-core" % "0.14.1",
+  "io.circe" %% "circe-generic" % "0.14.1",
+  "io.circe" %% "circe-parser" % "0.14.1"
+)

src/main/scala/JsonFormats.scala

@@ -0,0 +1,16 @@
+import io.circe.{Encoder, Json}
+import io.circe.generic.semiauto._
+import java.util.UUID
+
+// Assuming Participant and Society are in the default package (as seen from ls output)
+
+object JsonFormats {
+  // Encoder for UUID
+  implicit val uuidEncoder: Encoder[UUID] = Encoder.encodeString.contramap[UUID](_.toString)
+
+  // Encoder for Participant[Boolean]
+  implicit val participantEncoder: Encoder[Participant[Boolean]] = deriveEncoder[Participant[Boolean]]
+
+  // Encoder for Society[Boolean]
+  implicit val societyEncoder: Encoder[Society[Boolean]] = deriveEncoder[Society[Boolean]]
+}

src/main/scala/Society.scala

@@ -24,7 +24,7 @@ case class Society[T](participants: List[Participant[T]]) extends Logging {
       .values
       .toList
 
-    info(updatedSocietyParticipants.map(_.opinion))
+    // info(updatedSocietyParticipants.map(_.opinion))
     copy(participants = updatedSocietyParticipants)
   }
 }

src/main/scala/UnitedWeStandApp.scala

@@ -1,13 +1,15 @@
 import scala.util.Random
+import JsonFormats._ // Import your encoders
+import io.circe.syntax._ // For .asJson
 
 object UnitedWeStandApp extends App {
   import Debatable._
 
   def runCycles(cycleCount: Int = 20): Society[Boolean] = {
     val society = Society.create(population = 7)(() => Random.nextBoolean())
-
-    (1 to cycleCount).foldLeft(society)((society, _) => society.update)
+    (1 to cycleCount).foldLeft(society)((accSociety, _) => accSociety.update)
   }
 
-  runCycles()
+  val finalSociety = runCycles()
+  println(finalSociety.asJson.noSpaces) // Output JSON to stdout
 }

src/test/scala/UnitedWeStandAppTest.scala

@@ -0,0 +1,41 @@
+import org.scalatest.funsuite.AnyFunSuite
+import io.circe.parser.parse
+import io.circe.syntax._ // For .asJson
+import io.circe.Json // For explicit Json type usage
+import JsonFormats._ // Your encoders
+
+// Assuming UnitedWeStandApp is in the default package
+// Assuming Participant and Society case classes are in the default package
+
+class UnitedWeStandAppTest extends AnyFunSuite {
+
+  test("UnitedWeStandApp.runCycles output should be valid JSON and contain non-empty participants array") {
+    // Directly call runCycles and serialize, to avoid capturing stdout
+    val society = UnitedWeStandApp.runCycles(cycleCount = 5) // Use a small cycle count for testing
+    val jsonString = society.asJson.noSpaces
+
+    // 1. Check if the string is valid JSON
+    val parsedJsonResult = parse(jsonString)
+    assert(parsedJsonResult.isRight, s"Output should be valid JSON. Parsing error: ${parsedJsonResult.left.getOrElse("")}")
+
+    // 2. Perform checks on the parsed JSON structure
+    val json = parsedJsonResult.getOrElse(throw new RuntimeException("JSON parsing failed in test, this should not happen due to the assert above."))
+
+    // Check for the presence of the 'participants' array
+    val participantsCursor = json.hcursor.downField("participants")
+    assert(participantsCursor.succeeded, "JSON should contain a 'participants' field.")
+
+    // Check if 'participants' is an array and is non-empty
+    val participantsArray = participantsCursor.as[List[Json]]
+    assert(participantsArray.isRight, "'participants' field should be an array.")
+    assert(participantsArray.getOrElse(Nil).nonEmpty, "Participants array should not be empty.")
+
+    // 3. Optionally, check structure of a participant (if needed, more detailed)
+    val firstParticipantOpt = participantsArray.getOrElse(Nil).headOption
+    assert(firstParticipantOpt.isDefined, "Participant array should have at least one participant.")
+
+    val firstParticipantJson = firstParticipantOpt.get
+    assert(firstParticipantJson.hcursor.downField("uuid").as[String].isRight, "Participant should have a 'uuid' string field.")
+    assert(firstParticipantJson.hcursor.downField("opinion").as[Boolean].isRight, "Participant should have an 'opinion' boolean field.")
+  }
+}