Allow tuning loader options

src/main/scala/io/circe/yaml/Parser.scala

@@ -1,22 +1,25 @@
 package io.circe.yaml
 
-import Parser._
 import cats.syntax.either._
 import io.circe._
+import io.circe.yaml.Parser._
 import java.io.{ Reader, StringReader }
-import org.yaml.snakeyaml.LoaderOptions
-import org.yaml.snakeyaml.Yaml
+import org.yaml.snakeyaml.{ LoaderOptions, Yaml }
 import org.yaml.snakeyaml.constructor.SafeConstructor
 import org.yaml.snakeyaml.nodes._
 import scala.collection.JavaConverters._
 
 final case class Parser(
-  maxAliasesForCollections: Int = 50
+  maxAliasesForCollections: Int = Parser.defaultMaxAliasesForCollections,
+  nestingDepthLimit: Int = Parser.defaultNestingDepthLimit,
+  codePointLimit: Int = Parser.defaultCodePointLimit
 ) {
 
   private val loaderOptions = {
     val options = new LoaderOptions()
     options.setMaxAliasesForCollections(maxAliasesForCollections)
+    options.setNestingDepthLimit(nestingDepthLimit)
+    options.setCodePointLimit(codePointLimit)
     options
   }
 
@@ -40,19 +43,43 @@ final case class Parser(
 
   private[this] def parseStream(reader: Reader): Stream[Node] =
     new Yaml(loaderOptions).composeAll(reader).asScala.toStream
+
+  def copy(
+    maxAliasesForCollections: Int = this.maxAliasesForCollections,
+    nestingDepthLimit: Int = this.nestingDepthLimit,
+    codePointLimit: Int = this.codePointLimit
+  ): Parser = new Parser(maxAliasesForCollections, nestingDepthLimit, codePointLimit)
+
+  def copy(maxAliasesForCollections: Int): Parser = new Parser(
+    maxAliasesForCollections = maxAliasesForCollections,
+    nestingDepthLimit = this.nestingDepthLimit,
+    codePointLimit = this.codePointLimit
+  )
+
+  def this(maxAliasesForCollections: Int) =
+    this(maxAliasesForCollections, Parser.defaultNestingDepthLimit, Parser.defaultCodePointLimit)
 }
 
 object Parser {
+  val defaultMaxAliasesForCollections: Int = 50 // to prevent YAML at
+  // https://en.wikipedia.org/wiki/Billion_laughs_attack
+  val defaultNestingDepthLimit: Int = 50
+  val defaultCodePointLimit: Int = 3 * 1024 * 1024 // 3MB
+
   val default: Parser = Parser()
 
+  def apply(maxAliasesForCollections: Int): Parser =
+    new Parser(maxAliasesForCollections = maxAliasesForCollections)
+
   private[yaml] object CustomTag {
     def unapply(tag: Tag): Option[String] = if (!tag.startsWith(Tag.PREFIX))
       Some(tag.getValue)
     else
       None
   }
 
-  private[yaml] class FlatteningConstructor extends SafeConstructor {
+  private[yaml] class FlatteningConstructor(val loaderOptions: LoaderOptions = new LoaderOptions)
+      extends SafeConstructor(loaderOptions) {
     def flatten(node: MappingNode): MappingNode = {
       flattenMapping(node)
       node

src/test/scala/io/circe/yaml/ParserTests.scala

@@ -71,7 +71,6 @@ class ParserTests extends AnyFlatSpec with Matchers with EitherValues {
         .parse(
           ""
         )
-        .right
         .value == Json.False
     )
   }
@@ -82,7 +81,6 @@ class ParserTests extends AnyFlatSpec with Matchers with EitherValues {
         .parse(
           "   "
         )
-        .right
         .value == Json.False
     )
   }
@@ -122,4 +120,59 @@ class ParserTests extends AnyFlatSpec with Matchers with EitherValues {
         .isLeft
     )
   }
+
+  it should "parse when within depth limits" in {
+    assert(
+      Parser(nestingDepthLimit = 3)
+        .parse(
+          """
+            | foo:
+            |   bar:
+            |     baz
+            |""".stripMargin
+        )
+        .isRight
+    )
+  }
+
+  it should "fail to parse when depth limit is exceeded" in {
+    assert(
+      Parser(nestingDepthLimit = 1)
+        .parse(
+          """
+            | foo:
+            |   bar:
+            |     baz
+            |""".stripMargin
+        )
+        .isLeft
+    )
+  }
+
+  it should "parse when within code point limit" in {
+    assert(
+      Parser(codePointLimit = 1 * 1024 * 1024) // 1MB
+        .parse(
+          """
+            | foo:
+            |   bar:
+            |     baz
+            |""".stripMargin
+        )
+        .isRight
+    )
+  }
+
+  it should "fail to parse when code point limit is exceeded" in {
+    assert(
+      Parser(codePointLimit = 13) // 13B
+        .parse(
+          """
+            | foo:
+            |   bar
+            |""".stripMargin
+        )
+        .isLeft
+    )
+  }
 }