NimYAML/private/presenter.nim

523 lines
21 KiB
Nim
Raw Normal View History

# NimYAML - YAML implementation in Nim
# (c) Copyright 2015 Felix Krause
#
# See the file "copying.txt", included in this
# distribution, for details about the copyright.
2016-01-24 20:38:29 +00:00
import typetraits
type
DumperState = enum
dBlockExplicitMapKey, dBlockImplicitMapKey, dBlockMapValue,
dBlockInlineMap, dBlockSequenceItem, dFlowImplicitMapKey, dFlowMapValue,
dFlowExplicitMapKey, dFlowSequenceItem, dFlowMapStart,
dFlowSequenceStart
proc needsEscaping(scalar: string): bool {.raises: [].} =
scalar.len == 0 or scalar[0] in ['@', '`'] or
2016-01-14 18:00:03 +00:00
scalar.find({'{', '}', '[', ']', ',', '#', '-', ':', '?', '%', '"',
'\'', '\x0A', '\c'}) != -1
proc writeDoubleQuoted(scalar: string, s: Stream)
{.raises: [YamlPresenterOutputError].} =
try:
s.write('"')
for c in scalar:
if c == '"':
s.write('\\')
s.write(c)
2016-01-14 18:00:03 +00:00
s.write('"')
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
template safeWrite(s: string or char) {.dirty.} =
try:
target.write(s)
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
2016-01-14 21:51:30 +00:00
proc startItem(target: Stream, style: PresentationStyle, indentation: int,
state: var DumperState, isObject: bool)
{.raises: [YamlPresenterOutputError].} =
try:
case state
of dBlockMapValue:
target.write('\x0A')
target.write(repeat(' ', indentation))
2016-01-14 21:51:30 +00:00
if isObject or style == psCanonical:
target.write("? ")
state = dBlockExplicitMapKey
else:
state = dBlockImplicitMapKey
of dBlockInlineMap:
state = dBlockImplicitMapKey
of dBlockExplicitMapKey:
target.write('\x0A')
target.write(repeat(' ', indentation))
target.write(": ")
state = dBlockMapValue
of dBlockImplicitMapKey:
target.write(": ")
state = dBlockMapValue
of dFlowExplicitMapKey:
2016-01-14 21:51:30 +00:00
if style != psMinimal:
target.write('\x0A')
target.write(repeat(' ', indentation))
target.write(": ")
state = dFlowMapValue
of dFlowMapValue:
2016-01-14 21:51:30 +00:00
if (isObject and style != psMinimal) or
style in [psJson, psCanonical]:
target.write(",\x0A" & repeat(' ', indentation))
2016-01-14 21:51:30 +00:00
if style == psJson:
2016-01-14 18:00:03 +00:00
state = dFlowImplicitMapKey
else:
target.write("? ")
2016-01-14 18:00:03 +00:00
state = dFlowExplicitMapKey
2016-01-14 21:51:30 +00:00
elif isObject and style == psMinimal:
2016-01-11 20:01:36 +00:00
target.write(", ? ")
2016-01-11 20:12:38 +00:00
state = dFlowExplicitMapKey
else:
target.write(", ")
state = dFlowImplicitMapKey
of dFlowMapStart:
2016-01-14 21:51:30 +00:00
if (isObject and style != psMinimal) or
style in [psJson, psCanonical]:
target.write("\x0A" & repeat(' ', indentation))
2016-01-14 21:51:30 +00:00
if style == psJson:
2016-01-14 18:00:03 +00:00
state = dFlowImplicitMapKey
else:
target.write("? ")
2016-01-14 18:00:03 +00:00
state = dFlowExplicitMapKey
else:
state = dFlowImplicitMapKey
of dFlowImplicitMapKey:
target.write(": ")
state = dFlowMapValue
of dBlockSequenceItem:
target.write('\x0A')
target.write(repeat(' ', indentation))
target.write("- ")
of dFlowSequenceStart:
case style
2016-01-14 21:51:30 +00:00
of psMinimal, psDefault:
discard
2016-01-14 21:51:30 +00:00
of psCanonical, psJson:
target.write('\x0A')
target.write(repeat(' ', indentation))
2016-01-14 21:51:30 +00:00
of psBlockOnly:
discard # can never happen
state = dFlowSequenceItem
of dFlowSequenceItem:
case style
2016-01-14 21:51:30 +00:00
of psMinimal, psDefault:
target.write(", ")
2016-01-14 21:51:30 +00:00
of psCanonical, psJson:
target.write(",\x0A")
target.write(repeat(' ', indentation))
2016-01-14 21:51:30 +00:00
of psBlockOnly:
discard # can never happen
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
2016-01-28 20:59:26 +00:00
proc anchorName(a: AnchorId): string {.raises: [].} =
result = ""
var i = int(a)
while i >= 0:
let j = i mod 36
if j < 26: result.add(char(j + ord('a')))
else: result.add(char(j + ord('0') - 26))
i -= 36
2016-01-14 21:51:30 +00:00
proc writeTagAndAnchor(target: Stream, tag: TagId, tagLib: TagLibrary,
anchor: AnchorId) {.raises:[YamlPresenterOutputError].} =
try:
if tag notin [yTagQuestionMark, yTagExclamationMark]:
let tagUri = tagLib.uri(tag)
if tagUri.startsWith(tagLib.secondaryPrefix):
target.write("!!")
target.write(tagUri[18..tagUri.high])
target.write(' ')
elif tagUri.startsWith("!"):
target.write(tagUri)
target.write(' ')
else:
target.write("!<")
target.write(tagUri)
target.write("> ")
if anchor != yAnchorNone:
target.write("&")
2016-01-28 20:59:26 +00:00
target.write(anchorName(anchor))
target.write(' ')
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
2016-01-14 21:51:30 +00:00
proc present*(s: YamlStream, target: Stream, tagLib: TagLibrary,
style: PresentationStyle = psDefault,
indentationStep: int = 2) =
var
cached = initQueue[YamlStreamEvent]()
cacheIterator = iterator(): YamlStreamEvent =
while true:
while cached.len > 0:
yield cached.dequeue()
try:
let item = s()
if finished(s):
break
cached.enqueue(item)
2016-01-24 20:21:37 +00:00
except Exception:
var e = newException(YamlPresenterStreamError, "")
e.parent = getCurrentException()
raise e
indentation = 0
levels = newSeq[DumperState]()
for item in cacheIterator():
case item.kind
of yamlStartDocument:
2016-01-14 21:51:30 +00:00
if style != psJson:
# TODO: tag directives
try:
target.write("%YAML 1.2\x0A")
if tagLib.secondaryPrefix != yamlTagRepositoryPrefix:
target.write("%TAG !! " &
tagLib.secondaryPrefix & '\x0A')
target.write("--- ")
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
of yamlScalar:
if levels.len == 0:
2016-01-14 21:51:30 +00:00
if style != psJson:
safeWrite('\x0A')
else:
startItem(target, style, indentation, levels[levels.high],
false)
2016-01-14 21:51:30 +00:00
if style != psJson:
writeTagAndAnchor(target,
item.scalarTag, tagLib, item.scalarAnchor)
2016-01-14 21:51:30 +00:00
if style == psJson:
let hint = guessType(item.scalarContent)
if item.scalarTag in [yTagQuestionMark, yTagBoolean] and
hint in [yTypeBoolTrue, yTypeBoolFalse]:
if hint == yTypeBoolTrue:
safeWrite("true")
else:
safeWrite("false")
elif item.scalarTag in [yTagQuestionMark, yTagNull] and
hint == yTypeNull:
safeWrite("null")
elif item.scalarTag in [yTagQuestionMark, yTagInteger] and
hint == yTypeInteger:
safeWrite(item.scalarContent)
elif item.scalarTag in [yTagQuestionMark, yTagFloat] and
hint in [yTypeFloatInf, yTypeFloatNaN]:
raise newException(YamlPresenterJsonError,
"Infinity and not-a-number values cannot be presented as JSON!")
elif item.scalarTag in [yTagQuestionMark, yTagFloat] and
hint == yTypeFloat:
safeWrite(item.scalarContent)
else:
2016-01-14 18:00:03 +00:00
writeDoubleQuoted(item.scalarContent, target)
2016-01-14 21:51:30 +00:00
elif style == psCanonical or item.scalarContent.needsEscaping:
writeDoubleQuoted(item.scalarContent, target)
else:
safeWrite(item.scalarContent)
of yamlAlias:
2016-01-14 21:51:30 +00:00
if style == psJson:
2016-01-14 18:00:03 +00:00
raise newException(YamlPresenterJsonError,
"Alias not allowed in JSON output")
assert levels.len > 0
startItem(target, style, indentation, levels[levels.high], false)
try:
target.write('*')
target.write(cast[byte]('a') + cast[byte](item.aliasTarget))
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
of yamlStartSequence:
var nextState: DumperState
case style
2016-01-14 21:51:30 +00:00
of psDefault:
var length = 0
while true:
try:
let next = s()
assert (not finished(s))
cached.enqueue(next)
case next.kind
of yamlScalar:
length += 2 + next.scalarContent.len
of yamlAlias:
length += 6
of yamlEndSequence:
break
else:
length = high(int)
break
2016-01-24 20:21:37 +00:00
except Exception:
var e = newException(YamlPresenterStreamError, "")
e.parent = getCurrentException()
raise e
nextState = if length <= 60: dFlowSequenceStart else:
dBlockSequenceItem
2016-01-14 21:51:30 +00:00
of psJson:
2016-01-07 10:58:33 +00:00
if levels.len > 0 and levels[levels.high] in
[dFlowMapStart, dFlowMapValue]:
raise newException(YamlPresenterJsonError,
"Cannot have sequence as map key in JSON output!")
nextState = dFlowSequenceStart
2016-01-14 21:51:30 +00:00
of psMinimal, psCanonical:
nextState = dFlowSequenceStart
2016-01-14 21:51:30 +00:00
of psBlockOnly:
nextState = dBlockSequenceItem
if levels.len == 0:
if nextState == dBlockSequenceItem:
2016-01-14 21:51:30 +00:00
if style != psJson:
writeTagAndAnchor(target,
item.seqTag, tagLib, item.seqAnchor)
else:
2016-01-14 21:51:30 +00:00
if style != psJson:
writeTagAndAnchor(target,
item.seqTag, tagLib, item.seqAnchor)
safeWrite('\x0A')
indentation += indentationStep
else:
startItem(target, style, indentation, levels[levels.high], true)
2016-01-14 21:51:30 +00:00
if style != psJson:
writeTagAndAnchor(target,
item.seqTag, tagLib, item.seqAnchor)
indentation += indentationStep
if nextState == dFlowSequenceStart:
safeWrite('[')
2016-01-14 21:51:30 +00:00
if levels.len > 0 and style in [psJson, psCanonical] and
levels[levels.high] in
[dBlockExplicitMapKey, dBlockMapValue,
dBlockImplicitMapKey, dBlockSequenceItem]:
indentation += indentationStep
levels.add(nextState)
of yamlStartMap:
var nextState: DumperState
case style
2016-01-14 21:51:30 +00:00
of psDefault:
type mapParseState = enum
mpInitial, mpKey, mpValue, mpNeedBlock
var mps = mpInitial
while mps != mpNeedBlock:
try:
let next = s()
assert (not finished(s))
cached.enqueue(next)
case next.kind
of yamlScalar, yamlAlias:
case mps
of mpInitial: mps = mpKey
of mpKey: mps = mpValue
else: mps = mpNeedBlock
of yamlEndMap:
break
else:
mps = mpNeedBlock
2016-01-24 20:21:37 +00:00
except Exception:
var e = newException(YamlPresenterStreamError, "")
e.parent = getCurrentException()
raise e
nextState = if mps == mpNeedBlock: dBlockMapValue else:
dBlockInlineMap
2016-01-14 21:51:30 +00:00
of psMinimal:
nextState = dFlowMapStart
2016-01-14 21:51:30 +00:00
of psCanonical:
nextState = dFlowMapStart
2016-01-14 21:51:30 +00:00
of psJson:
if levels.len > 0 and levels[levels.high] in
[dFlowMapStart, dFlowMapValue]:
raise newException(YamlPresenterJsonError,
"Cannot have map as map key in JSON output!")
nextState = dFlowMapStart
2016-01-14 21:51:30 +00:00
of psBlockOnly:
nextState = dBlockMapValue
if levels.len == 0:
if nextState == dBlockMapValue:
2016-01-14 21:51:30 +00:00
if style != psJson:
writeTagAndAnchor(target,
item.mapTag, tagLib, item.mapAnchor)
else:
2016-01-14 21:51:30 +00:00
if style != psJson:
safeWrite('\x0A')
writeTagAndAnchor(target,
item.mapTag, tagLib, item.mapAnchor)
indentation += indentationStep
else:
if nextState in [dBlockMapValue, dBlockImplicitMapKey]:
2016-01-14 21:51:30 +00:00
if style != psJson:
writeTagAndAnchor(target,
item.mapTag, tagLib, item.mapAnchor)
startItem(target, style, indentation, levels[levels.high],
true)
else:
startItem(target, style, indentation, levels[levels.high],
true)
2016-01-14 21:51:30 +00:00
if style != psJson:
writeTagAndAnchor(target,
item.mapTag, tagLib, item.mapAnchor)
indentation += indentationStep
if nextState == dFlowMapStart:
safeWrite('{')
2016-01-14 21:51:30 +00:00
if levels.len > 0 and style in [psJson, psCanonical] and
levels[levels.high] in
[dBlockExplicitMapKey, dBlockMapValue,
dBlockImplicitMapKey, dBlockSequenceItem]:
indentation += indentationStep
levels.add(nextState)
of yamlEndSequence:
assert levels.len > 0
case levels.pop()
of dFlowSequenceItem:
case style
2016-01-14 21:51:30 +00:00
of psDefault, psMinimal, psBlockOnly:
safeWrite(']')
2016-01-14 21:51:30 +00:00
of psJson, psCanonical:
indentation -= indentationStep
try:
target.write('\x0A')
target.write(repeat(' ', indentation))
target.write(']')
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
if levels.len == 0 or levels[levels.high] notin
[dBlockExplicitMapKey, dBlockMapValue,
dBlockImplicitMapKey, dBlockSequenceItem]:
continue
of dFlowSequenceStart:
2016-01-14 21:51:30 +00:00
if levels.len > 0 and style in [psJson, psCanonical] and
levels[levels.high] in
[dBlockExplicitMapKey, dBlockMapValue,
dBlockImplicitMapKey, dBlockSequenceItem]:
indentation -= indentationStep
safeWrite(']')
of dBlockSequenceItem:
discard
else:
assert false
indentation -= indentationStep
of yamlEndMap:
assert levels.len > 0
2016-01-11 20:10:30 +00:00
let level = levels.pop()
case level
of dFlowMapValue:
case style
2016-01-14 21:51:30 +00:00
of psDefault, psMinimal, psBlockOnly:
safeWrite('}')
2016-01-14 21:51:30 +00:00
of psJson, psCanonical:
indentation -= indentationStep
try:
target.write('\x0A')
target.write(repeat(' ', indentation))
target.write('}')
except:
var e = newException(YamlPresenterOutputError, "")
e.parent = getCurrentException()
raise e
if levels.len == 0 or levels[levels.high] notin
[dBlockExplicitMapKey, dBlockMapValue,
dBlockImplicitMapKey, dBlockSequenceItem]:
continue
of dFlowMapStart:
2016-01-14 21:51:30 +00:00
if levels.len > 0 and style in [psJson, psCanonical] and
levels[levels.high] in
[dBlockExplicitMapKey, dBlockMapValue,
dBlockImplicitMapKey, dBlockSequenceItem]:
indentation -= indentationStep
safeWrite('}')
2016-01-11 20:12:38 +00:00
of dBlockMapValue, dBlockInlineMap:
discard
else:
assert false
indentation -= indentationStep
of yamlEndDocument:
try:
let next = s()
if finished(s):
break
cached.enqueue(next)
2016-01-24 20:21:37 +00:00
except Exception:
var e = newException(YamlPresenterStreamError, "")
e.parent = getCurrentException()
raise e
safeWrite("...\x0A")
2016-01-14 21:51:30 +00:00
proc transform*(input: Stream, output: Stream, style: PresentationStyle,
indentationStep: int = 2) =
var
taglib = initExtendedTagLibrary()
parser = newYamlParser(tagLib)
events = parser.parse(input)
try:
if style == psCanonical:
var specificTagEvents = iterator(): YamlStreamEvent =
for e in events():
var event = e
case event.kind
of yamlStartDocument, yamlEndDocument, yamlEndMap,
yamlAlias, yamlEndSequence:
discard
of yamlStartMap:
if event.mapTag in [yTagQuestionMark,
yTagExclamationMark]:
event.mapTag = yTagMap
of yamlStartSequence:
if event.seqTag in [yTagQuestionMark,
yTagExclamationMark]:
event.seqTag = yTagSequence
of yamlScalar:
if event.scalarTag == yTagQuestionMark:
case guessType(event.scalarContent)
of yTypeInteger:
event.scalarTag = yTagInteger
of yTypeFloat, yTypeFloatInf, yTypeFloatNaN:
event.scalarTag = yTagFloat
of yTypeBoolTrue, yTypeBoolFalse:
event.scalarTag = yTagBoolean
of yTypeNull:
event.scalarTag = yTagNull
of yTypeUnknown:
event.scalarTag = yTagString
elif event.scalarTag == yTagExclamationMark:
event.scalarTag = yTagString
yield event
present(specificTagEvents, output, tagLib, style,
indentationStep)
else:
present(events, output, tagLib, style, indentationStep)
except YamlPresenterStreamError:
let e = getCurrentException()
2016-01-24 20:38:29 +00:00
if e.parent of IOError:
raise cast[ref IOError](e.parent)
2016-01-24 20:38:29 +00:00
elif e.parent of YamlParserError:
raise cast[ref YamlParserError](e.parent)
else:
# never happens
assert(false)
2016-01-27 14:18:01 +00:00
except YamlPresenterJsonError, YamlPresenterOutputError:
raise
except Exception:
# compiler bug: https://github.com/nim-lang/Nim/issues/3772
assert(false)