cddl 0.16.0 → 0.17.0

package/tests/commands/repl.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, vi, expect } from 'vitest'
-import repl from 'node:repl'
-import { builder, handler, evaluate } from '../../src/cli/commands/repl.js'
-import { Tokens } from '../../src/tokens.js'
-
-describe('repl command', () => {
-    it('builder', () => {
-        const yargs: any = {}
-        yargs.epilogue = vi.fn().mockReturnValue(yargs)
-        yargs.help = vi.fn().mockReturnValue(yargs)
-        builder(yargs)
-
-        expect(yargs.epilogue).toHaveBeenCalledTimes(1)
-        expect(yargs.help).toHaveBeenCalledTimes(1)
-    })
-
-    describe('handler', () => {
-        it('starts repl', () => {
-            const startSpy = vi.spyOn(repl, 'start').mockReturnValue({} as any)
-            handler()
-            expect(startSpy).toHaveBeenCalledWith(expect.objectContaining({
-                prompt: '> ',
-                eval: evaluate
-            }))
-            startSpy.mockRestore()
-        })
-    })
-
-    describe('evaluate', () => {
-        it('returns error if no input', () => {
-            const cb = vi.fn()
-            evaluate('', {}, '', cb)
-            expect(cb).toHaveBeenCalledWith(expect.any(Error), null)
-        })
-
-        it('tokenizes input using Lexer', () => {
-            const cb = vi.fn()
-            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-
-            evaluate('foo = 1', {}, '', cb)
-
-            expect(consoleSpy).toHaveBeenCalledTimes(3) // foo, =, 1
-            expect(consoleSpy).toHaveBeenNthCalledWith(1, expect.objectContaining({ Type: Tokens.IDENT, Literal: 'foo' }))
-            expect(consoleSpy).toHaveBeenNthCalledWith(2, expect.objectContaining({ Type: Tokens.ASSIGN, Literal: '=' }))
-            expect(consoleSpy).toHaveBeenNthCalledWith(3, expect.objectContaining({ Type: Tokens.NUMBER, Literal: '1' }))
-
-            expect(cb).toHaveBeenCalledWith(null, null)
-
-            consoleSpy.mockRestore()
-        })
-    })
-})

package/tests/commands/validate.test.ts

@@ -1,66 +0,0 @@
-import url from 'node:url'
-import path from 'node:path'
-import { describe, it, vi, expect, beforeEach, afterAll } from 'vitest'
-import { builder, handler } from '../../src/cli/commands/validate.js'
-
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-const validCDDL = path.join(__dirname, '..', '..', '..', '..', 'examples', 'webdriver', 'local.cddl')
-const buggyCDDL = path.join(__dirname, '..', '..', '..', '..', 'examples', 'commons', 'buggy.cddl')
-
-describe('validate command', () => {
-    it('builder', () => {
-        const yargs: any = {}
-        yargs.epilogue = vi.fn().mockReturnValue(yargs)
-        yargs.help = vi.fn().mockReturnValue(yargs)
-        builder(yargs)
-
-        expect(yargs.epilogue).toBeCalledTimes(1)
-        expect(yargs.help).toBeCalledTimes(1)
-    })
-
-    describe('handler', () => {
-        const consoleLogOrig = console.log.bind(console)
-        const consoleErrorOrig = console.error.bind(console)
-        const processExitOrig = process.exit.bind(process)
-
-        beforeEach(() => {
-            // @ts-expect-error
-            process.exit = vi.fn()
-            console.log = vi.fn()
-            console.error = vi.fn()
-        })
-
-        afterAll(() => {
-            process.exit = processExitOrig
-            console.log = consoleLogOrig
-            console.error = consoleErrorOrig
-        })
-
-        it('fails if file does not exist', () => {
-            handler({ filePath: '/foo/bar', _: [], $0: '' })
-            expect(process.exit).toBeCalledTimes(1)
-            expect(console.error).toBeCalledTimes(1)
-            expect(process.exit).toBeCalledWith(1)
-        })
-
-        it('fails if cddl file is buggy', () => {
-            handler({ filePath: buggyCDDL, _: [], $0: '' })
-            expect(process.exit).toBeCalledTimes(1)
-            expect(console.error).toBeCalledTimes(1)
-            expect(process.exit).toBeCalledWith(1)
-        })
-
-        it('passes if cddl file is valid', () => {
-            handler({ filePath: validCDDL, _: [], $0: '' })
-            expect(process.exit).toBeCalledTimes(0)
-            expect(console.log).toBeCalledTimes(1)
-        })
-
-        it('handles relative paths', () => {
-            handler({ filePath: 'relative/path/to/file.cddl', _: [], $0: '' })
-            expect(process.exit).toBeCalledTimes(1)
-            expect(console.error).toBeCalledTimes(1)
-            expect(process.exit).toBeCalledWith(1)
-        })
-    })
-})

package/tests/complex_types.test.ts

@@ -1,18 +0,0 @@
-import url from 'node:url'
-import path from 'node:path'
-import { describe, it, expect } from 'vitest'
-
-import Parser from '../src/parser.js'
-
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-
-describe('complex types', () => {
-    it('can parse complex types correctly', () => {
-        const p = new Parser(path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'complex_types.cddl'))
-        const ast = p.parse()
-        const localValue = ast.find((item: any) => item.Name === 'LocalValue')
-
-        expect(localValue).toBeDefined()
-        expect(localValue).toMatchSnapshot()
-    })
-})

package/tests/examples.test.ts

@@ -1,25 +0,0 @@
-import url from 'node:url'
-import path from 'node:path'
-import { describe, it, expect } from 'vitest'
-
-import Parser from '../src/parser.js'
-
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-
-describe('examples', () => {
-    describe('common', () => {
-        const testCases: { name: string, fixture: string }[] = [
-            { name: 'can parse group choice', fixture: 'group_choice.cddl' },
-            { name: 'can parse literals', fixture: 'literals.cddl' },
-            { name: 'can parse mixin union', fixture: 'mixin_union.cddl' },
-            { name: 'can parse named group choice', fixture: 'named_group_choice.cddl' }
-        ]
-
-        for (const { name, fixture } of testCases) {
-            it(name, async () => {
-                const p = new Parser(path.join(__dirname, '..', '..', '..', 'examples', 'commons', fixture))
-                expect(p.parse()).toMatchSnapshot()
-            })
-        }
-    })
-})

package/tests/group-choices.test.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import Parser from '../src/parser.js'
-import * as fs from 'node:fs'
-
-vi.mock('node:fs')
-
-describe('Group Choice Parsing', () => {
-    const parse = (cddl: string) => {
-        vi.mocked(fs.readFileSync).mockReturnValue(cddl)
-        const parser = new Parser('dummy.cddl')
-        return parser.parse()
-    }
-
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    describe('Group Choice (//)', () => {
-        it('should verify group choice operator //', () => {
-            const cddl = `
-                mygroup = (int // text)
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-
-        it('should throw error when group choice operator // is at start of group', () => {
-            const cddl = `
-                mygroup = (// int)
-            `
-            expect(() => parse(cddl)).toThrowError('Unexpected group choice operator "//" at start of group')
-        })
-
-        it('should parse nested group choice', () => {
-            const cddl = `
-                mygroup = ((int // text))
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-
-        it('should parse group choice with multiple items', () => {
-             const cddl = `
-                mygroup = (int, text // float)
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-    })
-
-    describe('Map Group Choice', () => {
-        it('should parse group choice inside map', () => {
-            const cddl = `
-                mymap = {
-                    "a" => 1 //
-                    "b" => 2
-                }
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-    })
-
-    describe('Type Choice (/)', () => {
-        it('should parse type choice inside group', () => {
-             const cddl = `
-                mygroup = (int / text)
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-
-        it('should treat comments around type choice separators the same', () => {
-            const slashAfterComment = `
-                FlowStrategy = "drop-oldest"            ; Discard oldest when buffer is full
-                             / "pause-producer"          ; Apply backpressure to slow production
-                             / "sample"                  ; Deliver every Nth event under pressure
-            `
-            const slashBeforeComment = `
-                FlowStrategy = "drop-oldest" /           ; Discard oldest when buffer is full
-                               "pause-producer" /        ; Apply backpressure to slow production
-                               "sample"                  ; Deliver every Nth event under pressure
-            `
-
-            expect(parse(slashAfterComment)).toEqual(parse(slashBeforeComment))
-        })
-
-        // This tests the change: closingTokens.includes(Tokens.RPAREN) && this.peekToken.Type === Tokens.SLASH
-        it('should correctly handle slash in mixed context', () => {
-            const cddl = `
-                myrule = [ (int / text) ]
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-
-        it('should parse inline array alternatives inside map properties', () => {
-            const cddl = `
-                StorePutParams = {
-                    storeNamespace: [* text],
-                    key: text,
-                    value: {* text => any},
-                    ? index: bool / [* text],
-                    ? ttl: uint,
-                }
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-    })
-
-    describe('Blocks with Braces', () => {
-        // Covers changes in openSegment and parseAssignmentValue regarding Tokens.LBRACE
-        it('should parse nested group inside map', () => {
-            // This relates to the removal of special LPAREN handling inside LBRACE in openSegment
-            const cddl = `
-                myrule = { (int) }
-            `
-            const ast = parse(cddl)
-            // Expecting parsing to succeed and structure to be correct
-            expect(ast).toMatchSnapshot()
-        })
-
-         it('should parse bare group inside brace', () => {
-            const cddl = `
-                myrule = { int }
-            `
-            const ast = parse(cddl)
-            expect(ast).toMatchSnapshot()
-        })
-    })
-})

package/tests/lexer.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from 'vitest'
-
-import { Tokens } from '../src/tokens.js'
-import Lexer from '../src/lexer.js'
-
-describe('lexer', () => {
-    it('should allow to read token', () => {
-        const input = '=+(){},/<>'
-        const tests = [
-            [Tokens.ASSIGN, '='],
-            [Tokens.PLUS, '+'],
-            [Tokens.LPAREN, '('],
-            [Tokens.RPAREN, ')'],
-            [Tokens.LBRACE, '{'],
-            [Tokens.RBRACE, '}'],
-            [Tokens.COMMA, ','],
-            [Tokens.SLASH, '/'],
-            [Tokens.LT, '<'],
-            [Tokens.GT, '>']
-        ]
-
-        const l = new Lexer(input)
-        for (const [Type, Literal] of tests) {
-            const token = l.nextToken()
-            expect(token.Type).toBe(Type)
-            expect(token.Literal).toBe(Literal)
-        }
-    })
-
-    it('should read identifiers and comments', () => {
-        const input = '   headers,       ; Headers for the recipient'
-        const tests = [
-            [Tokens.IDENT, 'headers'],
-            [Tokens.COMMA, ','],
-            [Tokens.COMMENT, '; Headers for the recipient']
-        ]
-
-        const l = new Lexer(input)
-        for (const [Type, Literal] of tests) {
-            const token = l.nextToken()
-            expect(token.Type).toBe(Type)
-            expect(token.Literal).toBe(Literal)
-        }
-    })
-
-    it('should correctly report location info', () => {
-        const input = 'a = 1'
-        const l = new Lexer(input)
-
-        // consume tokens until EOF
-        while (l.nextToken().Type !== 'EOF') {}
-
-        // consume more EOFs to push position further
-        for (let i = 0; i < 10; ++i) {
-            l.nextToken()
-        }
-
-        // This should trigger the fallback
-        const locEnd = l.getLocation()
-        expect(locEnd.line).toBe(0)
-        expect(locEnd.position).toBe(0)
-    })
-})

package/tests/module.test.ts

@@ -1,21 +0,0 @@
-import url from 'node:url'
-import path from 'node:path'
-import { describe, it, expect } from 'vitest'
-
-import CDDL from '../src/index.js'
-
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-const validCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'arrays.cddl')
-const buggyCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'buggy.cddl')
-
-describe('validate', () => {
-    it('should return a json in success case', () => {
-        const ast = CDDL.parse(validCDDL)
-        expect(typeof ast).toBe('object')
-    })
-
-    it('should throw an error if invalud', () => {
-        expect(() => CDDL.parse(buggyCDDL))
-            .toThrow()
-    })
-})

package/tests/parser.test.ts

@@ -1,63 +0,0 @@
-import url from 'node:url'
-import path from 'node:path'
-import fs from 'node:fs'
-import { describe, it, expect, vi } from 'vitest'
-
-import Parser from '../src/parser.js'
-
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-
-describe('parser', () => {
-    const testCases: { name: string, fixture: string }[] = [
-        { name: 'should correctly parse CDDL file', fixture: 'example.cddl' },
-        { name: 'can parse compositions', fixture: 'compositions.cddl' },
-        { name: 'can parse ranges', fixture: 'ranges.cddl' },
-        { name: 'can parse occurrences', fixture: 'occurrences.cddl' },
-        { name: 'can parse arrays', fixture: 'arrays.cddl' },
-        { name: 'can parse unwrapped arrays', fixture: 'unwrapping.cddl' },
-        { name: 'can parse comments', fixture: 'comments.cddl' },
-        { name: 'can parse choices', fixture: 'choices.cddl' },
-        { name: 'can parse nested groups', fixture: 'nested.cddl' },
-        { name: 'can parse operators', fixture: 'operators.cddl' }
-    ]
-
-    for (const { name, fixture } of testCases) {
-        it(name, async () => {
-            const p = new Parser(path.join(__dirname, '..', '..', '..', 'examples', 'commons', fixture))
-            expect(p.parse()).toMatchSnapshot()
-        })
-    }
-
-    it('throws if group identifier is missing', () => {
-        vi.spyOn(fs, 'readFileSync').mockReturnValue('=')
-        const p = new Parser('foo.cddl')
-        expect(() => p.parse()).toThrow('group identifier expected')
-        vi.restoreAllMocks()
-    })
-
-    it('throws if assignment operator is missing', () => {
-        vi.spyOn(fs, 'readFileSync').mockReturnValue('groupName bar')
-        const p = new Parser('foo.cddl')
-        expect(() => p.parse()).toThrow('group identifier expected')
-        vi.restoreAllMocks()
-    })
-
-    it('skips blank comment lines in assignment comments', () => {
-        vi.spyOn(fs, 'readFileSync').mockReturnValue('; heading\n;\nfoo = int\n')
-        const p = new Parser('foo.cddl')
-
-        expect(p.parse()).toEqual([{
-            Type: 'variable',
-            Name: 'foo',
-            IsChoiceAddition: false,
-            PropertyType: ['int'],
-            Comments: [{
-                Type: 'comment',
-                Content: 'heading',
-                Leading: false
-            }]
-        }])
-
-        vi.restoreAllMocks()
-    })
-})

package/tests/utils.test.ts

@@ -1,211 +0,0 @@
-import { describe, it, expect } from 'vitest'
-
-import type {
-    Array as CDDLArray,
-    Assignment,
-    Comment,
-    Group,
-    NativeTypeWithOperator,
-    Property,
-    PropertyReference,
-    Variable
-} from '../src/ast.js'
-import { Tokens, type Token } from '../src/tokens.js'
-import {
-    hasSpecialNumberCharacter,
-    isAlphabeticCharacter,
-    isCDDLArray,
-    isDigit,
-    isGroup,
-    isLetter,
-    isLiteralWithValue,
-    isNamedGroupReference,
-    isNativeTypeWithOperator,
-    isProperty,
-    isPropertyReference,
-    isRange,
-    isUnNamedProperty,
-    isVariable,
-    parseNumberValue,
-    pascalCase
-} from '../src/utils.js'
-
-const comments: Comment[] = []
-
-function createVariable (): Variable {
-    return {
-        Type: 'variable',
-        Name: 'my-variable',
-        IsChoiceAddition: false,
-        PropertyType: 'tstr',
-        Comments: comments
-    }
-}
-
-function createGroup (): Group {
-    return {
-        Type: 'group',
-        Name: 'my-group',
-        IsChoiceAddition: false,
-        Properties: [],
-        Comments: comments
-    }
-}
-
-function createArray (): CDDLArray {
-    return {
-        Type: 'array',
-        Name: 'my-array',
-        Values: [],
-        Comments: comments
-    }
-}
-
-function createProperty (overrides: Partial<Property> = {}): Property {
-    return {
-        HasCut: false,
-        Occurrence: { n: 1, m: 1 },
-        Name: 'foo',
-        Type: 'tstr',
-        Comments: comments,
-        ...overrides
-    }
-}
-
-describe('utils', () => {
-    describe('character helpers', () => {
-        it('should detect letters and alphabetic characters', () => {
-            expect(isLetter('a')).toBe(true)
-            expect(isLetter('Z')).toBe(true)
-            expect(isLetter('1')).toBe(false)
-
-            expect(isAlphabeticCharacter('a')).toBe(true)
-            expect(isAlphabeticCharacter(Tokens.ATSIGN)).toBe(true)
-            expect(isAlphabeticCharacter(Tokens.UNDERSCORE)).toBe(true)
-            expect(isAlphabeticCharacter(Tokens.DOLLAR)).toBe(true)
-            expect(isAlphabeticCharacter('-')).toBe(false)
-        })
-
-        it('should detect digits and special number characters', () => {
-            expect(isDigit('1')).toBe(true)
-            expect(isDigit('0')).toBe(true)
-            expect(isDigit('a')).toBe(false)
-            expect(isDigit(Tokens.NL)).toBe(false)
-            expect(isDigit(Tokens.SPACE)).toBe(false)
-
-            expect(hasSpecialNumberCharacter(Tokens.MINUS.charCodeAt(0))).toBe(true)
-            expect(hasSpecialNumberCharacter(Tokens.DOT.charCodeAt(0))).toBe(true)
-            expect(hasSpecialNumberCharacter('x'.charCodeAt(0))).toBe(true)
-            expect(hasSpecialNumberCharacter('b'.charCodeAt(0))).toBe(true)
-            expect(hasSpecialNumberCharacter('1'.charCodeAt(0))).toBe(false)
-        })
-    })
-
-    describe('number parsing helpers', () => {
-        it('should parse floats, integers and prefixed numbers', () => {
-            const floatToken: Token = { Type: Tokens.FLOAT, Literal: '12.5' }
-            const intToken: Token = { Type: Tokens.INT, Literal: '42' }
-            const hexToken: Token = { Type: Tokens.INT, Literal: '0x10' }
-            const binaryToken: Token = { Type: Tokens.INT, Literal: '0b10' }
-
-            expect(parseNumberValue(floatToken)).toBe(12.5)
-            expect(parseNumberValue(intToken)).toBe(42)
-            expect(parseNumberValue(hexToken)).toBe('0x10')
-            expect(parseNumberValue(binaryToken)).toBe('0b10')
-        })
-    })
-
-    describe('name helpers', () => {
-        it('should convert names to pascal case', () => {
-            expect(pascalCase('my-example_name')).toBe('MyExampleName')
-        })
-    })
-
-    describe('assignment guards', () => {
-        it('should detect variables, groups and arrays', () => {
-            const variable: Assignment = createVariable()
-            const group: Assignment = createGroup()
-            const array: Assignment = createArray()
-
-            expect(isVariable(variable)).toBe(true)
-            expect(isVariable(group)).toBe(false)
-
-            expect(isGroup(group)).toBe(true)
-            expect(isGroup(variable)).toBe(false)
-
-            expect(isCDDLArray(array)).toBe(true)
-            expect(isCDDLArray(group)).toBe(false)
-        })
-    })
-
-    describe('property guards', () => {
-        it('should detect named and unnamed properties', () => {
-            const property = createProperty()
-            const unnamedProperty = createProperty({ Name: '' })
-
-            expect(isProperty(property)).toBe(true)
-            expect(isProperty({ Name: 'foo' })).toBe(false)
-
-            expect(isUnNamedProperty(unnamedProperty)).toBe(true)
-            expect(isUnNamedProperty(property)).toBe(false)
-        })
-    })
-
-    describe('reference and operator guards', () => {
-        it('should detect property references and named group references', () => {
-            const groupReference: PropertyReference = {
-                Type: 'group',
-                Value: 'my-group',
-                Unwrapped: false
-            }
-            const numericGroupReference: PropertyReference = {
-                Type: 'group',
-                Value: 123,
-                Unwrapped: false
-            }
-
-            expect(isPropertyReference(groupReference)).toBe(true)
-            expect(isPropertyReference({ Type: 'group' })).toBe(false)
-
-            expect(isNamedGroupReference(groupReference)).toBe(true)
-            expect(isNamedGroupReference(numericGroupReference)).toBe(false)
-        })
-
-        it('should detect native types with operators and ranges', () => {
-            const nativeTypeWithOperator: NativeTypeWithOperator = {
-                Type: {
-                    Type: 'group',
-                    Value: 'my-group',
-                    Unwrapped: false
-                },
-                Operator: {
-                    Type: 'default',
-                    Value: 'tstr'
-                }
-            }
-            const rangeReference: PropertyReference = {
-                Type: 'range',
-                Value: {
-                    Min: 0,
-                    Max: 10,
-                    Inclusive: true
-                },
-                Unwrapped: false
-            }
-
-            expect(isNativeTypeWithOperator(nativeTypeWithOperator)).toBe(true)
-            expect(isNativeTypeWithOperator({ Type: 'tstr' })).toBe(false)
-
-            expect(isRange({ Type: rangeReference })).toBe(true)
-            expect(isRange({ Type: 'range' })).toBe(false)
-        })
-    })
-
-    describe('literal guards', () => {
-        it('should detect literals with values', () => {
-            expect(isLiteralWithValue({ Type: 'literal', Value: 'foo' })).toBe(true)
-            expect(isLiteralWithValue({ Type: 'literal' })).toBe(false)
-            expect(isLiteralWithValue({ Type: 'group', Value: 'foo' })).toBe(false)
-        })
-    })
-})

package/tests/webdriver-local.test.ts

@@ -1,15 +0,0 @@
-import url from 'node:url'
-import path from 'node:path'
-import { describe, it, expect } from 'vitest'
-
-import Parser from '../src/parser.js'
-
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-
-describe('webdriver local cddl', () => {
-    it('can parse local.cddl', () => {
-        const filePath = path.join(__dirname, '..', '..', '..', 'examples', 'webdriver', 'local.cddl')
-        const p = new Parser(filePath)
-        expect(p.parse()).toMatchSnapshot()
-    })
-})