Index

Modules: nyml, nyml/dump, nyml/meta, nyml/parser.

API symbols

`$`:

• nyml: proc `$`(n: YAML): string

add:

• parser: proc add(lex`gensym0: var Lexer)

current:

• parser: proc current(lex`gensym0: var Lexer): char

Document:

• meta: type Document

dump:

• dump: proc dump(n: JsonNode): string

exists:

• meta: proc exists(field: JsonNode): bool

fromYaml:

• nyml: template fromYaml[T: typedesc](str: string; obj: T): untyped

get:

• meta: proc get(doc: Document; key: string = ""; default: JsonNode = nil): JsonNode

getContents:

• parser: proc getContents(p: var Parser): string

getError:

• parser: proc getError(lex`gensym0: Lexer): string
• parser: proc getError[T: Parser](p: var T): string

getErrors:

• meta: proc getErrors(doc: Document): string

getToken:

• parser: proc getToken(lex: var Lexer): TokenTuple

handleAltString:

• parser: proc handleAltString(lex: var Lexer; kind: TokenKind)

handleComment:

• parser: proc handleComment(lex: var Lexer; kind: TokenKind)

handleUnknown:

• parser: proc handleUnknown(lex: var Lexer)

handleVariable:

• parser: proc handleVariable(lex: var Lexer; kind: TokenKind)

hasError:

• parser: proc hasError(lex`gensym0: Lexer): bool
• parser: proc hasError[T: Parser](p: var T): bool

hasErrors:

• meta: proc hasErrors(doc: Document): bool

hasLetters:

• parser: proc hasLetters(lex`gensym0: var Lexer; pos`gensym0: int): bool

hasNumbers:

• parser: proc hasNumbers(lex`gensym0: var Lexer; pos`gensym0: int): bool

inc:

• parser: proc inc(lex`gensym0: var Lexer; offset`gensym0 = 1)

init:

• meta: proc init[N: YAML](newNyml: typedesc[N]; str: string; pretty = false; data: JsonNode): N

isPretty:

• meta: proc isPretty(n: YAML): bool

JD:

• dump: object JD

Lexer:

• parser: object Lexer

LexerException:

• parser: object LexerException

lexReady:

• parser: proc lexReady(lex`gensym0: var Lexer)

newDocument:

• meta: proc newDocument(contents: JsonNode): Document

newLexer:

• parser: proc newLexer(fileContent`gensym0: string; allowMultilineStrings`gensym0 = false): Lexer

parse:

• nyml: proc parse(n: YAML): Parser

Parser:

• parser: object Parser

parseYAML:

• parser: proc parseYAML(yml: YAML; strContents: string): Parser

rules:

• meta: proc rules(doc: var Document; docRules: openArray[tuple[key: string, kind: JsonNodeKind]])

setError:

• parser: proc setError(lex`gensym0: var Lexer; message`gensym0: string)

skip:

• parser: proc skip(lex`gensym0: var Lexer)

toJson:

• nyml: proc toJson(n: YAML): Document

toJsonStr:

• nyml: proc toJsonStr(n: YAML; prettyPrint = false; indent = 2): string
• nyml: proc toJsonStr(n: YAML; ruler: seq[string]; prettyPrint = false; indent = 2): string

TokenKind:

• parser: enum TokenKind

TokenTuple:

• parser: tuple TokenTuple

toYAML:

• nyml: proc toYAML(json: JsonNode): string
• nyml: proc toYAML(json: string): string

yaml:

• nyml: proc yaml(contents: string; prettyPrint = false; data: JsonNode = nil): YAML

YAML:

• meta: object YAML

YAMLException:

• meta: object YAMLException