circe/circe-yaml

YAML parser for circe using SnakeYAML

circe

circe is a JSON library for Scala (and Scala.js).

Please see the guide for more information about why circe exists and how to use it.

Community

Adopters

Are you using circe? Please consider opening a pull request to list your organization here:

• Abacus
• Anduin Transactions
• Apollo Agriculture
• AutoScout24
• Babylon Health
• Banno inside of Jack Henry
• BBC
• Broad Institute
• Chartboost (sending hundreds of thousands of messages per second on our Ad Exchange)
• CiBO Technologies (using circe to (de)serialize data in support of a sustainable revolution in agriculture)
• ClearScore
• Codacy
• Colisweb
• Connio (creating and managing digital twins with Circe and Akka)
• Coya
• Criteo (collecting 200.000 events per second from our banners)
• Dassault Systèmes
• Datalogue
• Dreamlines
• DriveTribe
• Earnest
• Elastic
• Emmy Sharing
• FOLIO
• GLNGN Server
• Gympass
• Gutefrage
• Hello Soda
• HERE Technologies
• Hireproof
• HolidayCheck
• ImmobilienScout24
• Immozentral
• Indix
• ITV
• Kinoplan
• Latitude Financial Services
• MatchesFashion
• Merit
• Metacommerce
• Mobile GmbH
• MomentFeed
• New Work
• Nike
• Ocado Technology
• On Air Entertainment
• Onfocus
• Opt Technologies
• OVO Energy
• Panaseer
• Permutive
• Prezi
• Project September (using circe to exchange and store data within the platform and serve data using GraphQL with Sangria)
• Raster Foundry
• Ravel Law (using circe to (de)serialize data for search, analytics, and visualization of tens of millions of legal opinions)
• REA Group - realestate.com.au
• Reonomy
• Resilient plc
• Sky
• Snowplow Analytics
• SoundCloud (transforming 200,000,000 JSON events every hour in MapReduce ETLs)
• Spotify (using circe for JSON IO in Scio)
• SpotX
• Stripe
• Stylight
• TabMo (parsing more than 100k events per second with Akka Stream and Spark)
• Tinkoff
• The Guardian
• Threat Stack
• Tranzzo
• Twilio (sending many, many millions of messages a day with Circe and Akka)
• Uberall
• VEACT
• WeWork
• Whisk
• Wide Angle Analytics
• Zalando
• Zendesk

Other circe organization projects

Please get in touch on Gitter if you have a circe-related project that you'd like to discuss hosting under the circe organization on GitHub.

• circe-benchmarks: Benchmarks for comparing the performance of circe and other JSON libraries for the JVM.
• circe-config: A library for translating between HOCON, Java properties, and JSON documents.
• circe-derivation: Experimental generic derivation with improved compile times.
• circe-fs2: A library that provides streaming JSON parsing and decoding built on fs2 and Jawn.
• circe-iteratee: A library that provides streaming JSON parsing and decoding built on iteratee.io and Jawn.
• circe-jackson: A library that provides Jackson-supported parsing and printing for circe.
• circe-spray: A library that provides JSON marshallers and unmarshallers for Spray using circe.
• circe-yaml: A library that uses SnakeYAML to support parsing YAML 1.1 into circe's Json.

Related projects

The following open source projects are either built on circe or provide circe support:

• Actor Messenger: A platform for instant messaging.
• akka-http-json: A library that supports using circe for JSON marshalling and unmarshalling in Akka HTTP.
• akka-stream-json: A library that provides JSON support for stream based applications using Jawn as a parser with a convenience example for circe.
• Argus: Generates models and circe encoders and decoders from JSON schemas.
• Blackdoor JOSE: circe JSON support for blackdoor JOSE and JWT.
• borer: Allows circe encoders/decoders to be reused for CBOR (de)serialization.
• circe-debezium: Circe codecs for Debezium payload types
• circe-geojson: Circe support for GeoJSON (RFC 7946)
• circe-kafka: Implicit conversion of Encoder and Decoder into Kafka Serializer/Deserializer/Serde
• cornichon: A DSL for JSON API testing.
• Cosmos: An API for DCOS services that uses circe.
• crjdt: A conflict-free replicated JSON datatype in Scala.
• diffson: A Scala diff / patch library for JSON.
• elastic4s: A Scala client for Elasticsearch with circe support.
• Enumeratum: Enumerations for Scala with circe integration.
• Featherbed: A REST client library with circe support.
• Finch: A library for building web services with circe support.
• fintrospect: HTTP contracts for Finagle with circe support.
• fluflu: A Fluentd logger.
• Github4s: A GitHub API wrapper written in Scala.
• content-api-models: The Guardian's Content API Thrift models.
• http4s: A purely functional HTTP library for client and server applications.
• IdeaLingua: Staged Interface Definition and Data Modeling Language & RPC system currently targeting Scala, Go, C# and TypeScript. Scala codegen generates models and JSON codecs using circe.
• Iglu Schema Repository: A JSON Schema repository with circe support.
• jsactor: An actor library for Scala.js with circe support.
• jsoniter-scala-circe: A booster for faster parsing/printing to/from circe AST and decoding/encoding of java.time._ and BigInt types.
• jwt-circe: A JSON Web Token implementation with circe support.
• kadai-log: A logging library with circe support.
• msgpack4z-circe: A MessagePack implementation with circe support.
• ohNoMyCirce: Friendly compile error messages for shapeless's Generic, circe's Encoder & Decoder and slick's case class mapping.
• play-circe: circe support for Play!.
• pulsar4s: A Scala client for Apache-Pulsar with circe support.
• Rapture: Support for using circe's parsing and AST in Rapture JSON.
• roc: A PostgreSQL client built on Finagle.
• sangria-circe: circe marshalling for Sangria, a GraphQL implementation.
• scalist: A Todoist API client.
• scala-jsonapi: Scala support library for integrating the JSON API spec with Spray, Play! or Circe
• scala-json-rpc: JSON-RPC 2.0 library for Scala and Scala.js
• scalatest-json-circe: Scalatest matchers for Json with appropriate equality and descriptive error messages.
• Scio: A Scala API for Apache Beam and Google Cloud Dataflow, uses circe for JSON IO
• seals: Tools for schema evolution and language-integrated schemata (derives circe encoders and decoders).
• shaclex: RDF validation using SHACL or ShEx.
• Slick-pg: Slick extensions for PostgreSQL.
• sttp: Scala HTTP client.
• Synapses: A lightweight Neural Network library, for js, jvm and .net.
• telepooz: A Scala wrapper for the Telegram Bot API built on circe.
• Zenith: Functional HTTP library built on circe.

Examples

The following projects provide examples, templates, or benchmarks that include circe:

• https://github.com/alanphillips78/akka-http-microservice-blueprint
• https://github.com/bneil/fcs_boilerplate
• https://github.com/gvolpe/simple-http4s-api
• https://github.com/vitorsvieira/akka-http-circe-json-template
• https://github.com/stephennancekivell/some-jmh-json-benchmarks-circe-jackson
• https://github.com/pauljamescleary/scala-pet-store

Contributors and participation

circe is a fork of Argonaut, and if you find it at all useful, you should thank Mark Hibberd, Tony Morris, Kenji Yoshida, and the rest of the Argonaut contributors.

circe is currently maintained by Darren Gibson and Erlend Hamnaberg. After the 1.0 release, all pull requests will require two sign-offs by a maintainer to be merged.

The circe project is a typelevel affiliate project, and follow the Typelevel Code of Conduct

Please see the contributors' guide for details on how to submit a pull request.

License

circe is licensed under the Apache License, Version 2.0 (the "License"); you may not use this software except in compliance with the License.

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

circe-yaml's Issues

convert symbols to strings (i.e. strip leading :)

was just porting some stuff over from ruby and ran into this. super hard to catch even staring right at it :(

require 'yaml'
yaml_string = [:symbol].to_yaml
# => "---\n- :symbol\n"
YAML.loadyaml_string)
# => [:symbol]

import io.circe.yaml.parser
val yamlString = "---\n- :symbol\n"
parser.parse(yamlString).right.get
// actual: [":symbol"]
// prefer: ["symbol"]

ScalaJS support

As far as I understand, circe-yaml is not published as a ScalaJs lib.

Is there something I miss? If not, is there something preventing compilation into ScalaJs?

Thanks for your answer.

Make a new release (or setup sbt-ci-release)

Hello,
can we please make a new release?
I've cut https://github.com/circe/circe-yaml/releases/tag/v0.14.3-RC1 but there's no GitHub Action setup to make a release.

Or even better, set up https://github.com/sbt/sbt-ci-release/ . That way the release process will be automated.

/cc @zarthross @zmccoy @jeffmay

Non-decimal integer types not parsed correctly

The YAML spec for the int tag allows hex, binary, octal and sexagesimal in addition to decimal numbers: http://yaml.org/type/int.html

circe-yaml fails to parse the following valid YAML:

number: 0xFF

with the error io.circe.ParsingFailure: Invalid numeric string 0xFF

I think it would make sense to parse that YAML as equivalent to the JSON document {"number": 255}.

Security Vulnerability CVE-2022-1471 for [email protected]

CVE-2022-1471

Recommended fix is to use SnakeYaml's SafeConsturctor when parsing untrusted content to restrict deserialization.

Law failure: Illegal embedded sign character

I was running the tests and the roundtrip test failed:

[info] SnakeYamlSymmetricSerializationTests:
[info] - snake.printer.printer.roundTrip *** FAILED ***
[info]   GeneratorDrivenPropertyCheckFailedException was thrown during property evaluation.
[info]    (Discipline.scala:14)
[info]     Falsified after 8 successful property evaluations.
[info]     Location: (Discipline.scala:14)
[info]     Occurred when passed generated values (
[info]       arg0 = {
[info]     "㿄㤥蕯萹쯦懹㿞৷⼔ᤇ끭◪麫鑗㍠宜鎺豎룇౰㛅戯㈰멿筎໲ꁏ亙ⱥﮅ㰡龥㈞㴽鳘돹ᘝ⻥煄孟倛㋇ꡇ頎紙ꨦ⩘ⶔ퐿೑﬿셬湹" : -0e+650527972106855168975387490925118
[info]   } // 11 shrinks
[info]     )
[info]     Label of failing property:
[info]       Expected: Right({
[info]     "㿄㤥蕯萹쯦懹㿞৷⼔ᤇ끭◪麫鑗㍠宜鎺豎룇౰㛅戯㈰멿筎໲ꁏ亙ⱥﮅ㰡龥㈞㴽鳘돹ᘝ⻥煄孟倛㋇ꡇ頎紙ꨦ⩘ⶔ퐿೑﬿셬湹" : -0e+650527972106855168975387490925118
[info]   })
[info]   Received: Left(io.circe.ParsingFailure: Illegal embedded sign character)

Empty YAML throws a MatchError

Parsing an empty YAML document causes the parser to exit with a MatchError exception pointing to io.circe.yaml.parser.yamlToJson:97.

This may be a bit tricky case, since empty file (in terms of fields - it may contain comments) is a valid YAML (with a single, null value), but not a valid JSON. Regardless, it seems reasonable to expect that a ParsingFailure would be returned in such case - instead, a MatchError is thrown.

Please let me know if you'd be willing to accept a pull request with fixes for that problem.

Parsing json to yaml formatting options required for the yaml class

Hi im trying to parse a json string to yaml
current output

environment: kubernetes
actions:
  action1:
    read:
    - parquet:
      - path: hdfs
      - tableName: table
    transform:
    - transform:
      - columnToTransform: ''
      - coalesce: ''
    write:
    - parquet:
      - path: ''

but i require output in the below format as i couldnt and methods available for it
i need double quotes("") for environment,path,tab value in the yaml output

environment: "kubernetes"
actions:
  action1:
    read:
    - parquet:
      - path: "hdfs"
      - tab: "table"
    transform:
    - transform:
      - column: ''
      - partition: ''
    write:
    - parquet:
      - pth: 'hdfs'

Scala Native support

Add support for Scala-Native similarly to circe/circe#1077

I have limited knowledge on how to add support for Scala Native but it is something I am available to explore (following circe/circe#2017 as a starting point). Would that be too tricky?

I am exploring a native application that reads YAML file and this library would come in handy.

`Parser.parseDocuments` diverges in behaviour with respect to `Parser.parse`

Parser.parseDocuments has a few scenarios in which it throws exceptions instead of returning a Left.
See PR #342 with tests that highlight both the current behaviour and the expected behaviour if it aligned with Parser.parse.

Preserving order of properties

circe can preserve the order given when creating objects, it seems that circe-yaml does not. Is there a way to do it that I'm missing, or can it be fixed?

object YamlOrderTest extends App {

  import io.circe.syntax._

  val json =
    Json.fromFields(Seq[(String, Json)](
      "swagger" -> "2.0".asJson,
      "info" -> "info".asJson,
      "paths" -> "paths".asJson,
      "definitions" -> "definitions".asJson,
      "tags" -> "tags".asJson
    ))

  println(io.circe.Printer.noSpaces.pretty(json))
  println(io.circe.yaml.Printer.spaces2.pretty(json))
  
}

{"swagger":"2.0","info":"info","paths":"paths","definitions":"definitions","tags":"tags"}
tags: tags
paths: paths
info: info
definitions: definitions
swagger: '2.0'

Cheers

Flaky test

Scalacheck fails on some strange unicode input; should add explicit test for this case:

https://travis-ci.org/circe/circe-yaml/jobs/181718573

snake.printer.printer.roundTrip *** FAILED ***
[info]   GeneratorDrivenPropertyCheckFailedException was thrown during property evaluation.
[info]    (Discipline.scala:14)
[info]     Falsified after 8 successful property evaluations.
[info]     Location: (Discipline.scala:14)
[info]     Occurred when passed generated values (
[info]       arg0 = [
[info]     [
[info]       [
[info]         {
[info]           "\u0085" : null
[info]         }
[info]       ]
[info]     ]
[info]   ] // 16 shrinks
[info]     )
[info]     Label of failing property:
[info]       (Right([
[info]     [
[info]       [
[info]         {
[info]           " " : null
[info]         }
[info]       ]
[info]     ]
[info]   ]) ?== Right([
[info]     [
[info]       [
[info]         {
[info]           "\u0085" : null
[info]         }
[info]       ]
[info]     ]
[info]   ])) failed

Split long urls to new line

version: 0.13.0

command

import cats.syntax.either._
import io.circe.yaml._
import io.circe.yaml.syntax._

val json = io.circe.jawn.parse("""{"foo":{"description": "hello, this is a random url on circe repo. Please check this file https://github.com/circe/circe-yaml/blob/master/src/main/scala/io/circe/yaml/parser/package.scala"}}""").valueOr(throw _)
io.circe.yaml.Printer().pretty(json)

actual

"foo:
  description: hello, this is a random url on circe repo. Please check this file https://github.com/circe/circe-yaml/blob/master/src/main/scala/io/circe/yaml/parser/package.scala
"

expected

"foo:
  description: hello, this is a random url on circe repo. Please check this file 
  https://github.com/circe/circe-yaml/blob/master/src/main/scala/io/circe/yaml/parser/package.scala
"

This url exceeds 80 characters (the default max column) but is treated somehow as a single character so it stays in 1 line.
could we make it split to a new line?

Option Parameters always returning None

Try to set default value using options to set default value if not set. But, the parsed yaml always returning None whether we set default value or not.

sbt:

libraryDependencies += "io.circe" %% "circe-yaml" % "0.14.1"
libraryDependencies += "io.circe" %% "circe-generic" % "0.14.2"
libraryDependencies += "io.circe" %% "circe-generic-extras" % "0.14.2"

Snippet:

import cats.syntax.either._
import io.circe._
import io.circe.generic.auto._
import io.circe.generic.extras.Configuration
import io.circe.yaml 

case class Config(url: String,
                      user: String,
                      password: String,
                      fetchSize: Option[Integer] = Some(1000))

implicit val customConfig: Configuration = Configuration.default.withDefaults

val sample =
  """
    |url: "some-sample-url"
    |user: "user"
    |password: "secret"
    |""".stripMargin    

val json = yaml.parser.parse(sample)

val foo = json
  .leftMap(err => err: Error)
  .flatMap(_.as[Config])
  .valueOr(throw _)

Change the fetchSize with or without default value is indifferent. Does any config that I am missing here? Thanks

Can't call io.circe.yaml.parser.parse on an input stream reader in 0.15.1

If you try to do

io.circe.yaml.parser.parse(new InputStreamReader(null))

Then you get a compilation error

type mismatch;
 found   : java.io.InputStreamReader
 required: String

I would imagine this change to be responsible d3d0907#diff-f063ea063fa1652fe54e2ad024f6209661708310bfbaf78c7b303fbc7095db2aR12

Though I don't see all the details.

If you replace io.circe.yaml.parser.parse with Parser.default.parse i.e. its definition, it compiles fine.

Edit - I think issue is basically this

object X extends App {
  B.f(0)
}

trait A {
  def f(x: String): String
}

package object B extends A {
  def f(x: Int): String = ???
  def f(x: String): String = ???
}

Edit - I suppose it's pertinent to say I am using scala 2.12

Release against circe 0.12.3?

It would be nice to have an official release compiled against the current circe-core version

printer.print is verbose

scala> io.circe.yaml.printer.print(io.circe.Json.fromInt(1))
res1: String =
"%YAML 1.1
--- 1
"

It would be nice if we separated print from printDocument and print would just be a minimal printer, similar to Json's default printer.

Build for 2.13.0

Scala 2.13.0 was released, so it would be great to have circe-yaml build for it.

Control characters in strings should be escaped

This issue is a restatement and minimization of #15. The problem is that control characters in strings aren't being escaped during printing:

scala> val Right(json) = io.circe.jawn.parse("\"\\u0085\"")
json: io.circe.Json = "\u0085"

scala> io.circe.yaml.Printer.spaces2.pretty(json)
res0: String =
"'�  '
"

From the spec:

YAML streams use the printable subset of the Unicode character set. On input, a YAML processor must accept all printable ASCII characters, the space, tab, line break, and all Unicode characters beyond #x9F. On output, a YAML processor must only produce these acceptable characters, and should also escape all non-printable Unicode characters. The allowed character range explicitly excludes the surrogate block #xD800-#xDFFF, DEL #x7F, the C0 control block #x0-#x1F (except for #x9, #xA, and #xD), the C1 control block #x80-#x9F, #xFFFE, and #xFFFF. Any such characters must be presented using escape sequences.

I have no idea how YAML libraries in general (or SnakeYAML in particular) handle this issue. It seems reasonable to me to say that if a string contains these characters, it must be represented using the double-quoted style no matter what the user-specified scalar style is, but I'd prefer for someone who actually knows something about YAML to say whether that's what we should do here.

Support merge keys

SnakeYAML supports YAML's "merge key" extension, which makes the last four elements in this sequence resolve to the same thing:

scala> val doc = """
     | ---
     | - &CENTER { x: 1, y: 2 }
     | - &LEFT { x: 0, y: 2 }
     | - &BIG { r: 10 }
     | - &SMALL { r: 1 }
     | 
     | # All the following maps are equal:
     | 
     | - # Explicit keys
     |   x: 1
     |   y: 2
     |   r: 10
     |   label: center/big
     | 
     | - # Merge one map
     |   << : *CENTER
     |   r: 10
     |   label: center/big
     | 
     | - # Merge multiple maps
     |   << : [ *CENTER, *BIG ]
     |   label: center/big
     | 
     | - # Override
     |   << : [ *BIG, *LEFT, *SMALL ]
     |   x: 1
     |   label: center/big
     | """

This functionality isn't currently available in circe-yaml, which does resolve the references but returns JSON objects with "<<" keys in them.

I need this functionality, and while I could hack it with cursors or something I'd rather take advantage of the fact that SnakeYAML can do it for me. This seems pretty easy—you can just subclass org.yaml.snakeyaml.constructor.SafeConstructor and call its protected flattenMapping on your mapping nodes.

I'm assuming we don't want this to be the default behavior, so I think we'll want some way to set options either in the parser itself or in the yamlToJson method. I'm happy to take a stab at this as soon as possible but if anyone has ideas about how it should look, please let me know.

/cc @jeremyrsmith @jeffmay @jonas @denisrosset

List of dictionaries not indented correctly

version: 0.13.0

command:

val json = io.circe.jawn.parse("""{"foo":[{"abc": "barasdfasdfasdf", "cs": "barasdfasdfasdf", "abcas": "barasdfasdfasdf", "absb": "barasdfasdfasdf"}], "bar": {"a": 1}}""").valueOr(throw _)
io.circe.yaml.Printer(indicatorIndent = 2).pretty(json)

expected:

"foo:
  - abc: barasdfasdfasdf
    cs: barasdfasdfasdf
    abcas: barasdfasdfasdf
    absb: barasdfasdfasdf
bar:
  a: 1
"

actual:

"foo:
  -
  abc: barasdfasdfasdf
  cs: barasdfasdfasdf
  abcas: barasdfasdfasdf
  absb: barasdfasdfasdf
bar:
  a: 1
"

If I change indent from 2 to 4:

new command:

val json = io.circe.jawn.parse("""{"foo":[{"abc": "barasdfasdfasdf", "cs": "barasdfasdfasdf", "abcas": "barasdfasdfasdf", "absb": "barasdfasdfasdf"}], "bar": {"a": 1}}""").valueOr(throw _)
io.circe.yaml.Printer(dropNullKeys = true, indicatorIndent = 2, indent=4).pretty(json)

then it becomes:

"foo:
  - abc: barasdfasdfasdf
    cs: barasdfasdfasdf
    abcas: barasdfasdfasdf
    absb: barasdfasdfasdf
bar:
    a: 1
"

Is there ways that I can have strictly 2 indentation spaces for all?

Please support automatic case class decoding with default values

Hello. Suppose I have a case class like

Duh(hello: String, world: String = "World")

and I want to use the super automagic generic programming technique for magically decoding yaml to an instance of Duh when my yaml file looks like:

hello: hello

Right now this doesn't work because it complains that there's no world field in the file. But I want it to use the default World string provided in the constructor when there's no world field.

I hope this is easy. Otherwise everyone is going to be mad at me for wasting half a day trying to make our code better instead of broken.

Thank you.

The Printer throws an exception when serializing `Json` to `String`

The Printer throws an exception when serializing Json to String. See #1 for an example of how to cause the tests to fail.

Support fail on duplicate key option

circe/circe#1130 was resolved for the Jawn parser (circe/circe#1149), but I don't believe this is the case for circe-yaml

Happy to be told I'm wrong, but would be very happy to see/use this feature with circe-yaml as well.

Float / Double serialized in unnatural way

Fractional double values are printed in a quite unexpected way. This is what I get:

            points:
            - x: -0
              y: 1
            - x: -5519150495529175e-16
              y: 1
            - x: -1
              y: 5519150495529175e-16
            - x: -1
              y: 0

While not incorrect, this is quite unexpected and not much human readable. This is what I would like to get:

            points:
            - x: -0
              y: 1
            - x: -0.5519150495529175
              y: 1
            - x: -1
              y: 0.55519150495529175
            - x: -1
              y: 0

New release?

Any ETA on a new release that includes SnakeYAML 1.32 or higher? Thanks.

yaml literals

it would be great to have support for a compile-time interpolator for yaml literals equivalent to the json""" ... """ literals available in Circe.

Allow parsing to class with default parameter

case class
case class Program(name: String, id: Int, active: Boolean = false) extends AlarmEntity
yaml

zone:
   name: String
   id: Int

io.circe.yaml.parser should extend io.circe.Parser

... so that we can call...

1. Parser.decode, and...
2. Parser.decodeAccumulating

... instead of the suggested spell in the README.md of this project.

Last, but not least: Thanks for this very useful library!

Support override for `nestingDepthLimit` and `codePointLimit`

Similarly to what #136 highlights, SnakeYaml sets various default limits, and supports overriding these values via LoaderOptions.

We have a project that parses yaml files which exceeds those limits and are currently using workarounds for this.

Support maxAliasesForCollections override

SnakeYaml defaults "maxAliasesForCollections" to 50, and supports overriding this value via https://www.javadoc.io/doc/org.yaml/snakeyaml/latest/org/yaml/snakeyaml/LoaderOptions.html. This would probably be implemented the same way as #120.

We have a project that parses yml files with more than 50 aliases - currently using a workaround for this.

String values written quoted when using scala-yaml backend

import io.circe.generic.semiauto._
import io.circe.syntax._
import io.circe._
import io.circe.yaml._
import io.circe.yaml.scalayaml.Printer

case class V(string: String)
object V {
  implicit val vEncoder: Encoder[V] = deriveEncoder
}

val v = V("hello world")
val yamlString = Printer.pretty(v.asJson)

println(yamlString)

Result is string: "hello world" instead of expected string: hello world.

The quotes are there because of jsonToNode last case:

    case json =>
      Node.ScalarNode(json.toString)

Here json.toString calls:

• spaces2
• Printer.spaces2.print(this)
• unsafePrintToAppendable
• foldWith
• folder.onString

PrintingFolder.onString starts with writer.append('"'), which is understandable, given it is used to produce Json values, which are quoted.

v1.15.0 is on Maven Central

https://repo1.maven.org/maven2/io/circe/circe-yaml_3/1.15.0/

Unfortunately it is too late to pretend this "didn't happen". Not sure what the best path forward is 😕

memory leak when using parser since 0.8.0

Hi,

Since version 0.8.0 we observe an increasing of heap memory usage when using yaml parser which is never released (so lead to a OutOfMemory quickly); do not happen in version 0.7.0 but still happen in version 0.11.0-M1

By analyzing quickly a heap dump when memory in high, it seems to be caused mainly by org.yaml.snakeyaml.nodes.{Mark,ScalarNode} instances

Regards,

Parsing YAML in JS

Hi all,

I've been having good success using js-yaml along with Circe to parse YAML in JS, so I thought I'd post a short comment here:

// build.sbt
libraryDependencies ++= Seq(
  "org.scalablytyped" %%% "js-yaml" % "3.12-dt-20200625Z-862e6d",
  "io.circe" %%% "circe-scalajs" % circeVersion
),
Compile / npmDependencies += "js-yaml" -> "3.12"

import io.circe.Decoder

import io.circe.scalajs._
import typings.jsYaml.{mod => yaml}

import scala.util.Try
object YamlDecoder {
  def parseAndDecode[T : Decoder](s: String): Either[Throwable, T] = {
    Try(yaml.load(s)).toEither.flatMap(decodeJs[T](_))
  }
}

Would something like this be worthy to put into circe-yaml itself?

Use SnakeYAML Engine to add YAML 1.2 syntax support

SnakeYAML Engine project reference here: https://bitbucket.org/asomov/snakeyaml-engine/src/master/

In my opinion, the YAML 1.1 => 1.2 syntax update represents a key feature of YAML parsing, given that YAML 1.2 is officially a superset of JSON

io.circe.yaml.parse is not threadsafe

yamlToJson uses a shared flattener (here) which extends SafeConstructor which extends BaseConstructor which contains a map of constructed objets which is not thread safe.

0.4.0 Not Published For Scala 2.12 (seems to be an accident)

For some reason the final 0.4.0 artifact for Scala 2.12 is not in maven central. From what I can see, prerelease snaphshots were published, so this seems to just be an oversight.

#question: How to think about yaml schema management ?

Should there be support for yaml schema management ? validation, conversion, etc?

This project handles yaml and then there is circe-json-schema specifically for json schema validation.
This states the relation between json schema and yaml schema:

YAML has advanced features that cannot be directly mapped to JSON, most YAML files use features that can be validated by JSON Schema. JSON Schema is the most portable and broadly supported choice for YAML validation

source: https://json-schema-everywhere.github.io/yaml

I am coming from the pov of applications to data management (asset catalog, data schema, etc)

Feature request for SnakeYAML

Hi all, we are completely rewriting SnakeYAML (using YAML 1.2 and Java 8).
Are you interested in participating ?
What would you like to implement ?

0.14 release?

Any ETA on a 0.14 release? Thanks!

Move to same organization and resolver as circe?

Should we update the organization to io.circe and resolver to match?