feat: XML codec implemented

Author: shruti2522

build.sbt

@@ -307,13 +307,14 @@ lazy val zioSchemaXml = project
   .settings(
     libraryDependencies ++= Seq(
       "org.scala-lang.modules" %% "scala-xml"                % scalaXmlVersion,
-      "org.scalaxb"            %% "scalaxb"                  % "1.11.1",
+      "org.scalaxb"            %% "scalaxb"                  % "1.12.4",
       "org.scala-lang.modules" %% "scala-parser-combinators" % "2.4.0",
       "javax.xml.bind"         % "jaxb-api"                  % "2.3.1"
     ),
     Compile / scalaxb / scalaxbXsdSource := new File(baseDirectory.value, "src/test/resources"),
-    Compile / scalaxb / scalaxbDispatchVersion := "1.1.3",
-    Compile / scalaxb / scalaxbPackageName := "generated"
+    Compile / scalaxb / scalaxbPackageName := "generated",
+    Compile / scalacOptions := (Compile / scalacOptions).value.filterNot(_ == "-Xfatal-warnings"),
+    mimaPreviousArtifacts := Set()
   )
   .settings(testDeps)
 

zio-schema-xml/src/main/scala/zio/schema/codec/XmlCodec.scala

@@ -110,24 +110,42 @@ object XmlCodec {
 
       case Schema.Optional(innerSchema, _) =>
         value.asInstanceOf[Option[Any]] match {
-          case Some(v) => encodeNode(v, innerSchema, name, config)
+          case Some(v) => encodeNode(v, innerSchema.asInstanceOf[Schema[Any]], name, config)
           case None    => if (config.omitEmptyElements) Seq.empty else Seq(Elem(null, name, Null, TopScope, true))
         }
 
       case Schema.Sequence(elementSchema, _, g, _, _) =>
-        encodeSequence(g(value), elementSchema, name, config)
+        encodeSequence(g(value), elementSchema.asInstanceOf[Schema[Any]], name, config)
 
       case Schema.Map(keySchema, valueSchema, _) =>
-        encodeMap(value.asInstanceOf[Map[Any, Any]], keySchema, valueSchema, name, config)
+        encodeMap(
+          value.asInstanceOf[Map[Any, Any]],
+          keySchema.asInstanceOf[Schema[Any]],
+          valueSchema.asInstanceOf[Schema[Any]],
+          name,
+          config
+        )
 
       case Schema.Set(elementSchema, _) =>
-        encodeSet(value.asInstanceOf[Set[Any]], elementSchema, name, config)
+        encodeSet(value.asInstanceOf[Set[Any]], elementSchema.asInstanceOf[Schema[Any]], name, config)
 
       case Schema.Either(leftSchema, rightSchema, _) =>
-        encodeEither(value.asInstanceOf[Either[Any, Any]], leftSchema, rightSchema, name, config)
+        encodeEither(
+          value.asInstanceOf[Either[Any, Any]],
+          leftSchema.asInstanceOf[Schema[Any]],
+          rightSchema.asInstanceOf[Schema[Any]],
+          name,
+          config
+        )
 
       case Schema.Tuple2(leftSchema, rightSchema, _) =>
-        encodeTuple(value.asInstanceOf[(Any, Any)], leftSchema, rightSchema, name, config)
+        encodeTuple(
+          value.asInstanceOf[(Any, Any)],
+          leftSchema.asInstanceOf[Schema[Any]],
+          rightSchema.asInstanceOf[Schema[Any]],
+          name,
+          config
+        )
 
       case Schema.Transform(codec, _, g, _, _) =>
         g(value) match {
@@ -432,13 +450,19 @@ object XmlCodec {
           }
 
         case Schema.Sequence(elementSchema, fromChunk, _, _, _) =>
-          decodeSequence(nodes, elementSchema, fromChunk, config, path)
+          decodeSequence(
+            nodes,
+            elementSchema.asInstanceOf[Schema[Any]],
+            fromChunk.asInstanceOf[Chunk[Any] => A],
+            config,
+            path
+          )
 
         case Schema.Map(keySchema, valueSchema, _) =>
           decodeMap(nodes, keySchema, valueSchema, config, path)
 
         case Schema.Set(elementSchema, _) =>
-          decodeSet(nodes, elementSchema, config, path)
+          decodeSet(nodes, elementSchema.asInstanceOf[Schema[Any]], config, path).asInstanceOf[Either[DecodeError, A]]
 
         case Schema.Either(leftSchema, rightSchema, _) =>
           decodeEither(nodes, leftSchema, rightSchema, config, path)

zio-schema-xml/src/main/scala/zio/schema/codec/XmlSchemaCodec.scala

@@ -7,7 +7,6 @@ import scala.xml._
 import zio.schema.StandardType._
 import zio.schema._
 import zio.schema.annotation.validate
-import zio.schema.codec.XmlAnnotations
 import zio.schema.validation.Validation
 import zio.{ Cause, Chunk }
 
@@ -111,7 +110,7 @@ object XmlSchemaCodec extends XmlSchemaCodec {
       case Schema.Sequence(elemSchema, _, _, _, _) =>
         collectDefinitions(elemSchema, visited)
       case Schema.Map(k, v, _) =>
-        collectMapDefinitions(k, v, visited)
+        collectMapDefinitions(k.asInstanceOf[Schema[Any]], v.asInstanceOf[Schema[Any]], visited)
       case Schema.Optional(inner, _)       => collectDefinitions(inner, visited)
       case Schema.Lazy(inner)              => collectDefinitions(inner(), visited)
       case Schema.Transform(s, _, _, _, _) => collectDefinitions(s, visited)
@@ -148,22 +147,21 @@ object XmlSchemaCodec extends XmlSchemaCodec {
     }
   }
 
-  private def collectEnumDefinitions(enum: Schema.Enum[_], visited: Set[String]): (List[Node], String) = {
-    val name = s"${getRootName(enum)}Type"
+  private def collectEnumDefinitions(`enum`: Schema.Enum[_], visited: Set[String]): (List[Node], String) = {
+    val name = s"${getRootName(`enum`)}Type"
     if (visited(name)) {
       (Nil, name)
     } else {
-      // Check if this is a simple string enumeration
-      val isSimpleEnum = enum.cases.forall { c =>
+      val isSimpleEnum = `enum`.cases.forall { c =>
         c.schema match {
           case Schema.Primitive(_, _)                  => true
           case r: Schema.Record[_] if r.fields.isEmpty => true
           case _                                       => false
         }
       }
 
-      if (isSimpleEnum && enum.cases.nonEmpty) {
-        val enumerationNodes = enum.cases.map { c =>
+      if (isSimpleEnum && `enum`.cases.nonEmpty) {
+        val enumerationNodes = `enum`.cases.map { c =>
           elem("xs:enumeration", "value" -> c.id)
         }
         val restriction = elem(
@@ -174,7 +172,7 @@ object XmlSchemaCodec extends XmlSchemaCodec {
         val simpleType = elem("xs:simpleType", List("name" -> name), restriction)
         (List(simpleType), name)
       } else {
-        val (allCaseDefs, caseElems) = enum.cases.foldLeft((List.empty[Node], List.empty[Node])) { (acc, c) =>
+        val (allCaseDefs, caseElems) = `enum`.cases.foldLeft((List.empty[Node], List.empty[Node])) { (acc, c) =>
           val (defs, _) = collectDefinitions(c.schema, visited + name)
           val caseType  = schemaTypeName(c.schema, c.id)
           val caseElem  = elem("xs:element", "name" -> c.id, "type" -> caseType)
@@ -704,10 +702,11 @@ object XmlSchemaCodec extends XmlSchemaCodec {
     if (validation == Validation.succeed) schema else schema.asInstanceOf[Schema[Any]].annotate(validate(validation))
 
   private def decodeEnumeration(typeName: String, enumerations: NodeSeq): Either[DecodeError, Schema[_]] = {
-    val cases = enumerations.map { n =>
+    val casesList = enumerations.map { n =>
       val v = n \@ "value"
       Schema.Case[String, String](v, Schema[String], _.asInstanceOf[String], identity, (s: String) => s == v)
-    }.to(Chunk)
+    }
+    val cases = Chunk.fromIterable(casesList)
 
     val caseSet = cases.foldRight[CaseSet.Aux[String]](CaseSet.Empty[String]()) { (c, cs) =>
       CaseSet.Cons(c, cs)