Parse Only true/false as Booleans, Keep True/TRUE as Strings in [email protected]

[fuyalasmit]

How to parse only lowercase true/false as booleans, preserve True/TRUE/False/FALSE as strings?

I'm working on a project where I need to parse YAML such that only lowercase true and false are treated as booleans, while values like True, TRUE, False, FALSE are parsed as strings to preserve their exact capitalization in the JSON output.

Example YAML:

arguments:
  - type: String
    value: True
  - type: String  
    value: TRUE
  - type: Boolean
    value: true

Desired JSON output:

{
  "arguments": [
    { "type": "String", "value": "True" },
    { "type": "String", "value": "TRUE" }, 
    { "type": "Boolean", "value": true }
  ]
}

I've tried using schema: 'json' but it's too restrictive and causes parsing errors for other valid YAML constructs. Is there a way to create a custom schema or use parsing options that only treats lowercase true/false as booleans?
Any help would be appreciated!

[eemeli]

Here's how I would customize the core schema to provide what you want:

import { Schema, parse } from 'yaml'

const schema = new Schema({ schema: 'core' })
for (let i = 0; i < schema.tags.length; ++i)
  if (schema.tags[i].tag === 'tag:yaml.org,2002:bool')
    schema.tags[i] = { ...schema.tags[i], test: /^(?:true|false)$/ }

parse('[ true, True, TRUE ]', { schema })
// [ true, 'True', 'TRUE' ]

It looks like the ability to use a Schema instance as the schema option value isn't well documented; I'll need to fix that.

[fuyalasmit]

That is not what I wanted, anyways thanks!

[eemeli]

No, you really should try that:

const data = {
  arguments: [
    { type: "String", value: "True" },
    { type: "String", value: "true" },
    { type: "String", value: "13.4" }
  ]
}

YAML.stringify(data, { schema: 'failsafe' })

arguments:
  - type: String
    value: True
  - type: String
    value: true
  - type: String
    value: 13.4

Is that not exactly what you want?

[fuyalasmit]

Not really, the above example I provided was specific for the edge case I was facing.

Particularly talking for my case, type field could be other than String, like Number or Boolean.
And as far as I know, schema: 'failsafe' throws error if it sees other than Strings, Sequences (arrays), Mappings (objects)

const data = {
  arguments: [
    { type: "String", value: "True" },
    { type: "String", value: "true" },
    { type: "String", value: "13.4" },
    { type: "Number", value: 13.4 },
    { type: "Boolean", value: true },

  ]
}

YAML.stringify(data, { schema: 'failsafe' })

This fails.

What I actually want:

arguments:
  - type: String
    value: True
  - type: String
    value: true
  - type: String
    value: 13.4
  - type: Number
    value: 13.4
  - type: String
    value: true

[eemeli]

That kind of dynamic typing is probably best implemented on top of a library like yaml. If I were in your shoes, I'd use schema: 'failsafe' and do the custom scalar parsing and serialization after parse() and before stringify().

Or use explicit YAML tags for the value types, rather than the structure you're planning, representing your last example as:

arguments:
  - !!str True
  - !!str true
  - !!str 13.4
  - !!float 13.4
  - !!str true

[fuyalasmit]

Will look into the first one, thanks!