@o3co/ts.hocon 0.1.0

package/tests/lexer.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect } from 'vitest'
+import { tokenize } from '../src/internal/lexer/lexer.js'
+import { ParseError } from '../src/errors.js'
+
+describe('tokenize', () => {
+  it('tokenizes empty string', () => {
+    const tokens = tokenize('')
+    expect(tokens).toHaveLength(1)
+    expect(tokens[0].kind).toBe('eof')
+  })
+
+  it('tokenizes braces and brackets', () => {
+    const tokens = tokenize('{}[]')
+    expect(tokens.map(t => t.kind)).toEqual(['lbrace', 'rbrace', 'lbracket', 'rbracket', 'eof'])
+  })
+
+  it('tokenizes = and +=', () => {
+    const tokens = tokenize('=+=')
+    expect(tokens[0].kind).toBe('equals')
+    expect(tokens[1].kind).toBe('plus_equals')
+  })
+
+  it('tokenizes : and ,', () => {
+    const tokens = tokenize(':,')
+    expect(tokens.map(t => t.kind)).toEqual(['colon', 'comma', 'eof'])
+  })
+
+  it('skips // comments, keeps newline', () => {
+    const tokens = tokenize('// comment\nfoo')
+    expect(tokens[0].kind).toBe('newline')
+    expect(tokens[1].kind).toBe('unquoted')
+    expect(tokens[1].value).toBe('foo')
+  })
+
+  it('skips # comments', () => {
+    const tokens = tokenize('# comment\nfoo')
+    expect(tokens[0].kind).toBe('newline')
+    expect(tokens[1].value).toBe('foo')
+  })
+
+  it('tokenizes quoted strings', () => {
+    const [t] = tokenize('"hello world"')
+    expect(t.kind).toBe('string')
+    expect(t.value).toBe('hello world')
+    expect(t.isQuoted).toBe(true)
+  })
+
+  it('handles escape sequences', () => {
+    const [t] = tokenize('"a\\nb\\tc"')
+    expect(t.value).toBe('a\nb\tc')
+  })
+
+  it('handles \\u unicode escapes', () => {
+    const [t] = tokenize('"\\u0041"')
+    expect(t.value).toBe('A')
+  })
+
+  it('tokenizes triple-quoted strings', () => {
+    const [t] = tokenize('"""hello\nworld"""')
+    expect(t.kind).toBe('triple_string')
+    expect(t.value).toBe('hello\nworld')
+    expect(t.isQuoted).toBe(true)
+  })
+
+  it('strips leading newline from triple-quoted strings', () => {
+    const [t] = tokenize('"""\nhello"""')
+    expect(t.value).toBe('hello')
+  })
+
+  it('tokenizes unquoted strings', () => {
+    const [t] = tokenize('localhost')
+    expect(t.kind).toBe('unquoted')
+    expect(t.value).toBe('localhost')
+    expect(t.isQuoted).toBe(false)
+  })
+
+  it('tokenizes numbers as unquoted', () => {
+    const [t] = tokenize('8080')
+    expect(t.kind).toBe('unquoted')
+    expect(t.value).toBe('8080')
+  })
+
+  it('tokenizes substitutions', () => {
+    const [t] = tokenize('${server.host}')
+    expect(t.kind).toBe('subst')
+    expect(t.value).toBe('server.host')
+  })
+
+  it('tokenizes optional substitutions', () => {
+    const [t] = tokenize('${?foo}')
+    expect(t.kind).toBe('opt_subst')
+    expect(t.value).toBe('foo')
+  })
+
+  it('tokenizes newlines', () => {
+    const tokens = tokenize('a\nb')
+    expect(tokens[1].kind).toBe('newline')
+  })
+
+  it('deduplicates consecutive newlines', () => {
+    const tokens = tokenize('a\n\n\nb')
+    const newlines = tokens.filter(t => t.kind === 'newline')
+    expect(newlines).toHaveLength(1)
+  })
+
+  it('tracks line and col', () => {
+    const tokens = tokenize('a\nb')
+    expect(tokens[0].line).toBe(1)
+    expect(tokens[0].col).toBe(1)
+    expect(tokens[2].line).toBe(2)
+    expect(tokens[2].col).toBe(1)
+  })
+
+  it('sets precedingSpace on token after whitespace', () => {
+    const tokens = tokenize('a b')
+    expect(tokens[1].precedingSpace).toBe(true)
+    expect(tokens[0].precedingSpace).toBe(false)
+  })
+
+  it('strips UTF-8 BOM', () => {
+    const tokens = tokenize('\uFEFFfoo')
+    expect(tokens[0].value).toBe('foo')
+  })
+
+  it('stops unquoted scan at $ for concat', () => {
+    const tokens = tokenize('foo${bar}')
+    expect(tokens[0].kind).toBe('unquoted')
+    expect(tokens[0].value).toBe('foo')
+    expect(tokens[1].kind).toBe('subst')
+    expect(tokens[1].value).toBe('bar')
+    expect(tokens[1].precedingSpace).toBe(false)
+  })
+
+  it('throws ParseError on unterminated string', () => {
+    expect(() => tokenize('"unterminated')).toThrow(ParseError)
+  })
+
+  it('throws ParseError on unterminated substitution', () => {
+    expect(() => tokenize('${foo')).toThrow(ParseError)
+  })
+})

package/tests/lightbend/lightbend.test.ts

@@ -0,0 +1,39 @@
+// tests/lightbend/lightbend.test.ts
+//
+// Lightbend HOCON spec compliance tests, mirroring go.hocon's lightbend_test.go.
+// Tests equiv01-05 directories (each .conf compared against original.json).
+import { describe, it, expect } from 'vitest'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { parse } from '../../src/parse.js'
+
+const dataDir = new URL('./testdata', import.meta.url).pathname
+
+// Known skip reasons for specific test files
+const equivSkip = new Set([
+  'equiv03/includes.conf', // requires .properties file support
+])
+
+describe('Lightbend HOCON equiv tests', () => {
+  for (let i = 1; i <= 5; i++) {
+    const dir = join(dataDir, `equiv${String(i).padStart(2, '0')}`)
+    const jsonPath = join(dir, 'original.json')
+    if (!existsSync(jsonPath)) continue
+
+    const expected = JSON.parse(readFileSync(jsonPath, 'utf-8'))
+    const entries = readdirSync(dir)
+
+    for (const entry of entries) {
+      if (!entry.endsWith('.conf')) continue
+      const rel = `equiv${String(i).padStart(2, '0')}/${entry}`
+      if (equivSkip.has(rel)) continue
+
+      it(rel, () => {
+        const confPath = join(dir, entry)
+        const confContent = readFileSync(confPath, 'utf-8')
+        const config = parse(confContent, { baseDir: dir })
+        expect(config.toObject()).toEqual(expected)
+      })
+    }
+  }
+})

package/tests/lightbend/testdata/a_1.conf

@@ -0,0 +1 @@
+a=1

package/tests/lightbend/testdata/b_2.conf

@@ -0,0 +1 @@
+b=2

package/tests/lightbend/testdata/beanconfig/beanconfig01.conf

@@ -0,0 +1,131 @@
+{
+  "booleans" : {
+      "trueVal" : true,
+      "trueValAgain" : ${booleans.trueVal},
+      "falseVal" : false,
+      "falseValAgain" : ${booleans.falseVal},
+      "on" : "on",
+      "off" : "off"
+  }
+
+    "numbers" : {
+       "byteVal" : "1",
+       "byteObj" : ${numbers.byteVal},
+       "shortVal" : "2",
+       "shortObj" : ${numbers.shortVal},
+       "intVal" : "3",
+       "intObj" : ${numbers.intVal},
+       "longVal" : "4",
+       "longObj" : ${numbers.longVal},
+       "doubleVal" : "1.0",
+       "doubleObj" : ${numbers.doubleVal}
+    }
+//
+    "strings" : {
+        "abcd" : "abcd",
+        "abcd-again" : ${strings.a}${strings.b}${strings.c}${strings.d},
+        "a" : "a",
+        "b" : "b",
+        "c" : "c",
+        "d" : "d",
+        "concatenated" : null bar 42 baz true 3.14 hi,
+        "double" : "3.14",
+        "number" : "57",
+        "null" : "null",
+        "true" : "true",
+        "yes" : "yes",
+        "false" : "false",
+        "no" : "no"
+    },
+
+    "arrays" : {
+        "empty" : [],
+        "ofInt" : [1, 2, 3],
+        "ofString" : [ ${strings.a}, ${strings.b}, ${strings.c} ],
+        "of-double" : [3.14, 4.14, 5.14],
+        "of-long" : { "1" : 32, "2" : 42, "3" : 52 }, // object-to-list conversion
+        "ofNull" : [null, null, null],
+        "ofBoolean" : [true, false],
+        "ofArray" : [${arrays.ofString}, ${arrays.ofString}, ${arrays.ofString}],
+        "ofObject" : [${numbers}, ${booleans}, ${strings}],
+        "ofConfig" : [${numbers}, ${booleans}, ${strings}],
+        "ofConfigObject" : [${numbers}, ${booleans}, ${strings}],
+        "ofConfigValue" : [1, 2, "a"],
+        "ofDuration" : [1, 2h, 3 days],
+        "ofMemorySize" : [1024, 1M, 1G],
+        "ofStringBean" : [
+                {
+                        abcd : "testAbcdOne"
+                        yes : "testYesOne"
+                },
+                {
+                        abcd : "testAbcdTwo"
+                        yes : "testYesTwo"
+                }
+        ]
+    },
+    "bytes" : {
+        "kilobyte" : "1kB",
+        "kibibyte" : "1K",
+        "thousandBytes" : "1000B"
+    },
+    "durations" : {
+        "second" : 1s,
+        "secondAsNumber" : 1000,
+        "halfSecond" : 0.5s
+    },
+    "validation" : {
+      "shouldBeInt" : true,
+      "should-be-boolean" : 42,
+      "should-be-list" : "hello"
+    },
+    "preferCamelNames" : {
+      "foo-bar" : "no",
+      "fooBar" : "yes",
+      "baz-bar" : "no",
+      "bazBar" : "yes"
+    },
+    "values" : {
+      "obj" : 42,
+      "config" : ${strings},
+      "configObj" : ${numbers},
+      "configValue" : "hello world",
+      "list" : [1,2,3],
+      "unwrappedMap" : ${validation}
+    },
+    "enums" : {
+      "problem" : "P1",
+      "solutions" : ["S1", "S3"]
+    },
+    "objects" : {
+      "valueObject": {
+        "mandatoryValue": "notNull"
+      }
+    },
+    "sets" : {
+      "empty" : [],
+      "ofInt" : [1, 2, 3, 2, 3],
+      "ofString" : [ ${strings.a}, ${strings.b}, ${strings.c} ],
+      "of-double" : [3.14, 4.14, 4.14, 5.14],
+      "of-long" : { "1" : 32, "2" : 42, "3" : 52 }, // object-to-list conversion
+      "ofNull" : [null, null, null],
+      "ofBoolean" : [true, false, false],
+      "ofArray" : [${arrays.ofString}, ${arrays.ofString}, ${arrays.ofString}],
+      "ofObject" : [${numbers}, ${booleans}, ${strings}],
+      "ofConfig" : [${numbers}, ${booleans}, ${strings}],
+      "ofConfigObject" : [${numbers}, ${booleans}, ${strings}],
+      "ofConfigValue" : [1, 2, "a"],
+      "ofDuration" : [1, 2h, 3 days],
+      "ofMemorySize" : [1024, 1M, 1G],
+      "ofStringBean" : [
+        {
+          abcd : "testAbcdOne"
+          yes : "testYesOne"
+        },
+        {
+          abcd : "testAbcdTwo"
+          yes : "testYesTwo"
+        }
+      ]
+    }
+}

package/tests/lightbend/testdata/bom.conf

@@ -0,0 +1,2 @@
+#
+foo = bar

package/tests/lightbend/testdata/cycle.conf

@@ -0,0 +1 @@
+include "cycle.conf"

package/tests/lightbend/testdata/env-variables.conf

@@ -0,0 +1,16 @@
+secret = a
+secret = ${?SECRET_A}
+secrets = ["b", "c"]
+secrets = [${?SECRET_B}, ${?SECRET_C}]
+
+myList = ${MY_LIST[]}
+myOptionalList = ${?MY_LIST[]}
+myOptionalUndefinedList = ${?UNDEFINED_LIST[]}
+numList = ${NUM_LIST[]}
+
+# list concatenation with env var list expansion
+prependedList = ["x", "y"] ${?MY_LIST[]}
+appendedList = ${?MY_LIST[]} ["x", "y"]
+selfAppendedList = ["x"]
+selfAppendedList = ${?selfAppendedList} ${?MY_LIST[]}
+appendedUndefined = ["x", "y"] ${?UNDEFINED_LIST[]}

package/tests/lightbend/testdata/equiv01/comments.conf

@@ -0,0 +1,45 @@
+{  // These are some integers
+    "ints" : { # we can comment them with # too
+        "fortyTwo" : 42, ## double-# !
+        "fortyTwoAgain" : 42 # { }
+    },
+######## COMMENT COMMENT COMMENT
+/// I COMMENT YOU
+    "floats" : {
+        "fortyTwoPointOne" : 42.1,
+        "fortyTwoPointOneAgain" : 42.1
+        // I CAN HAS COMMENT
+    },
+
+    "strings" : {
+        "abcd" : // I got yr comment right here
+  "abcd",
+        "abcdAgain" : "abcd",
+        "a" : "a",
+        "b" : "b",
+        "c" : "c",
+        "d" : "d",
+        "concatenated" # more to say?
+: "null bar 42 baz true 3.14 hi"
+    },
+
+    "arrays" : {
+        "empty" : [],
+        "1" : [ 1 ],
+        "12" : [1, 2],
+        "123" : [1, 2, 3],
+        "ofString" : [ "a", "b", "c" ]
+    },
+
+    "booleans" : {
+        "true" : true,
+        "trueAgain" : true,
+        "false" : false,
+        "falseAgain" : false
+    },
+
+    "nulls" : {
+        "null" : null,
+        "nullAgain" : null
+    }
+}

package/tests/lightbend/testdata/equiv01/equals.conf

@@ -0,0 +1,41 @@
+{
+    "ints" = {
+        "fortyTwo" = 42,
+        "fortyTwoAgain" = 42
+    },
+
+    "floats" = {
+        "fortyTwoPointOne" = 42.1,
+        "fortyTwoPointOneAgain" = 42.1
+    },
+
+    "strings" = {
+        "abcd" = "abcd",
+        "abcdAgain" = "abcd",
+        "a" = "a",
+        "b" = "b",
+        "c" = "c",
+        "d" = "d",
+        "concatenated" = "null bar 42 baz true 3.14 hi"
+    },
+
+    "arrays" = {
+        "empty" = [],
+        "1" = [ 1 ],
+        "12" = [1, 2],
+        "123" = [1, 2, 3],
+        "ofString" = [ "a", "b", "c" ]
+    },
+
+    "booleans" = {
+        "true" = true,
+        "trueAgain" = true,
+        "false" = false,
+        "falseAgain" = false
+    },
+
+    "nulls" = {
+        "null" = null,
+        "nullAgain" = null
+    }
+}

package/tests/lightbend/testdata/equiv01/no-commas.conf

@@ -0,0 +1,55 @@
+{
+    "ints" : {
+        "fortyTwo" : 42
+        "fortyTwoAgain" : 42
+    }
+
+    "floats" : {
+        "fortyTwoPointOne" : 42.1
+        "fortyTwoPointOneAgain" : 42.1
+    }
+
+    "strings" : {
+        "abcd" : "abcd"
+        "abcdAgain" : "abcd"
+        "a" : "a"
+        "b" : "b"
+        "c" : "c"
+        "d" : "d"
+        "concatenated" : "null bar 42 baz true 3.14 hi"
+    }
+
+    "arrays" : {
+        "empty" : []
+        "1" : [ 1 ]
+        "12" : [1
+                2]
+        "123" : [1
+                 2
+                 3 ]
+        "ofString" : [
+
+"a"
+  "b"
+  "c"
+
+]
+    }
+
+    "booleans" : {
+
+        "true" : true
+
+        "trueAgain" : true
+
+        "false" : false
+
+        "falseAgain" : false
+
+    }
+
+    "nulls" : {
+        "null" : null
+        "nullAgain" : null
+    }
+}

package/tests/lightbend/testdata/equiv01/no-root-braces.conf

@@ -0,0 +1,40 @@
+"ints" : {
+    "fortyTwo" : 42,
+    "fortyTwoAgain" : 42
+},
+
+"floats" : {
+    "fortyTwoPointOne" : 42.1,
+    "fortyTwoPointOneAgain" : 42.1
+},
+
+"strings" : {
+    "abcd" : "abcd",
+    "abcdAgain" : "abcd",
+    "a" : "a",
+    "b" : "b",
+    "c" : "c",
+    "d" : "d",
+    "concatenated" : "null bar 42 baz true 3.14 hi"
+},
+
+"arrays" : {
+    "empty" : [],
+    "1" : [ 1 ],
+    "12" : [1, 2],
+    "123" : [1, 2, 3],
+    "ofString" : [ "a", "b", "c" ]
+},
+
+"booleans" : {
+    "true" : true,
+    "trueAgain" : true,
+    "false" : false,
+    "falseAgain" : false
+},
+
+"nulls" : {
+    "null" : null,
+    "nullAgain" : null
+}
+

package/tests/lightbend/testdata/equiv01/no-whitespace.json

@@ -0,0 +1 @@
+{"ints":{"fortyTwo":42,"fortyTwoAgain":42},"floats":{"fortyTwoPointOne":42.1,"fortyTwoPointOneAgain":42.1},"strings":{"abcd":"abcd","abcdAgain":"abcd","a":"a","b":"b","c":"c","d":"d","concatenated":"null bar 42 baz true 3.14 hi"},"arrays":{"empty":[],"1":[1],"12":[1,2],"123":[1,2,3],"ofString":["a","b","c"]},"booleans":{"true":true,"trueAgain":true,"false":false,"falseAgain":false},"nulls":{"null":null,"nullAgain":null}}

package/tests/lightbend/testdata/equiv01/omit-colons.conf

@@ -0,0 +1,44 @@
+{
+    "ints" {
+        "fortyTwo" : 42,
+        "fortyTwoAgain" : 42
+    },
+
+    "floats"
+{
+        "fortyTwoPointOne" : 42.1,
+        "fortyTwoPointOneAgain" : 42.1
+    },
+
+    "strings"   
+
+   {
+        "abcd" : "abcd",
+        "abcdAgain" : "abcd",
+        "a" : "a",
+        "b" : "b",
+        "c" : "c",
+        "d" : "d",
+        "concatenated" : "null bar 42 baz true 3.14 hi"
+    },
+
+    "arrays"            {    
+        "empty" : [],
+        "1" : [ 1 ],
+        "12" : [1, 2],
+        "123" : [1, 2, 3],
+        "ofString" : [ "a", "b", "c" ]
+    },
+
+    "booleans" {
+        "true" : true,
+        "trueAgain" : true,
+        "false" : false,
+        "falseAgain" : false
+    },
+
+    "nulls" {
+        "null" : null,
+        "nullAgain" : null
+    }
+}

package/tests/lightbend/testdata/equiv01/original.json

@@ -0,0 +1,41 @@
+{
+    "ints" : {
+        "fortyTwo" : 42,
+        "fortyTwoAgain" : 42
+    },
+
+    "floats" : {
+        "fortyTwoPointOne" : 42.1,
+        "fortyTwoPointOneAgain" : 42.1
+    },
+
+    "strings" : {
+        "abcd" : "abcd",
+        "abcdAgain" : "abcd",
+        "a" : "a",
+        "b" : "b",
+        "c" : "c",
+        "d" : "d",
+        "concatenated" : "null bar 42 baz true 3.14 hi"
+    },
+
+    "arrays" : {
+        "empty" : [],
+        "1" : [ 1 ],
+        "12" : [1, 2],
+        "123" : [1, 2, 3],
+        "ofString" : [ "a", "b", "c" ]
+    },
+
+    "booleans" : {
+        "true" : true,
+        "trueAgain" : true,
+        "false" : false,
+        "falseAgain" : false
+    },
+
+    "nulls" : {
+        "null" : null,
+        "nullAgain" : null
+    }
+}

package/tests/lightbend/testdata/equiv01/path-keys.conf

@@ -0,0 +1,29 @@
+{
+    ints.fortyTwo : 42,
+    ints.fortyTwoAgain : 42,
+
+    floats.fortyTwoPointOne : 42.1,
+    floats.fortyTwoPointOneAgain : 42.1,
+
+    strings.abcd : "abcd",
+    strings.abcdAgain : "abcd",
+    strings.a : "a",
+    strings.b : "b",
+    strings.c : "c",
+    strings.d : "d",
+    strings.concatenated : "null bar 42 baz true 3.14 hi",
+
+    arrays."empty" : [],
+    arrays."1" : [ 1 ],
+    arrays.12 : [1, 2],
+    arrays.123 : [1, 2, 3],
+    arrays.ofString : [ "a", "b", "c" ],
+
+    booleans.true : true,
+    booleans.trueAgain : true,
+    booleans.false : false,
+    booleans.falseAgain : false,
+
+    nulls.null : null,
+    nulls.nullAgain : null
+}

package/tests/lightbend/testdata/equiv01/properties-style.conf

@@ -0,0 +1,37 @@
+# this file is in a no-braces java properties style,
+# but it's a .conf file with json-style escaping,
+# not a Java properties file.
+# lots of playing with whitespace and commas
+# in here to test various cases; don't copy
+# this as exemplary, it has gratuitously
+# stupid formatting.
+ints.fortyTwo=42
+ints.fortyTwoAgain = 42  // whitespace ignored around the =
+floats.fortyTwoPointOne=42.1
+floats.fortyTwoPointOneAgain:42.1 // colon is fine too
+strings.abcd=abcd
+strings.abcdAgain : "abcd",  // colon and quotes and comma!
+strings.a=a
+strings.b=b
+strings.c="c",
+strings.d:"d"
+strings.concatenated=null bar 42 baz true 3.14 hi # this gets squished to a string
+arrays.empty=[]
+arrays.1 : [ 1 ]
+# it's allowed to omit commas in arrays if you have newlines
+arrays.12 = [
+ 1
+ 2
+]
+arrays.123 = [1,
+2
+3]
+arrays.ofString = [ "a", "b", "c" ]
+booleans.true=true
+booleans.trueAgain=${booleans.true}
+booleans.false=false
+# you could quote keys, though here it's pointless
+# since the key contains no special characters
+"booleans"."falseAgain" : ${booleans.false},
+nulls.null=${nulls.nullAgain}
+nulls.nullAgain=null