An explicit block scalar indentation indicator is the content indentation relative to the block scalar's parent node. For an inline mapping value (`- aaa: |2`) the parent is the mapping, but a compact inline mapping never pushes its indentation onto the main stack, so the indicator was added to the stack level (0) rather than the mapping's (2). The content indentation then came out too small and the next mapping key was pulled into the scalar. Capture at the header whether the block scalar is an inline mapping value (a mapping value was seen on its line). When it is, fold the deepest applicable implicit indentation into the indicator's base; a direct sequence item (`- |1`), which has no mapping value on its line, keeps the sequence's own level, so the explicit indicators on sequence items stay correct. Raises yaml-test-suite value-level conformance to 191/194 (98.5%) with the parse-level and should-error rejection rates unchanged. 463 tests pass.
182 lines
7.8 KiB
Swift
182 lines
7.8 KiB
Swift
extension PureYAML.Parsing.Scanner {
|
|
func scanComment(_ state: inout State) {
|
|
let start = state.reader.mark
|
|
state.reader.advance()
|
|
if state.reader.peek() == " " {
|
|
state.reader.advance()
|
|
}
|
|
let value = state.reader.consume { character in
|
|
!isLineBreak(character)
|
|
}
|
|
state.append(.comment(value), mark: start, endMark: state.reader.mark)
|
|
}
|
|
|
|
func scanQuotedScalar(
|
|
_ style: PureYAML.Parsing.ScalarStyle,
|
|
state: inout State,
|
|
) throws {
|
|
let start = state.reader.mark
|
|
let quote: Character = style == .doubleQuoted ? "\"" : "'"
|
|
state.reader.advance()
|
|
var value = ""
|
|
var previousWasEscape = false
|
|
while let character = state.reader.peek() {
|
|
if style == .singleQuoted, character == quote, state.reader.peek(offset: 1) == quote {
|
|
value.append(character)
|
|
state.reader.advance()
|
|
value.append(character)
|
|
state.reader.advance()
|
|
continue
|
|
}
|
|
if character == quote, !previousWasEscape {
|
|
break
|
|
}
|
|
value.append(character)
|
|
previousWasEscape = character == "\\" && style == .doubleQuoted && !previousWasEscape
|
|
state.reader.advance()
|
|
if character != "\\" {
|
|
previousWasEscape = false
|
|
}
|
|
// A line that begins with a document marker (`---` / `...`) is forbidden inside a
|
|
// multi-line scalar: the marker would be ambiguous with a document boundary.
|
|
if isLineBreak(character), isAtDocumentMarker(state.reader) {
|
|
throw PureYAML.Parsing.ParseError.documentMarkerInScalar(line: state.reader.mark.line)
|
|
}
|
|
}
|
|
guard state.reader.peek() == quote else {
|
|
throw PureYAML.Parsing.ParseError.unterminatedQuotedString(line: start.line)
|
|
}
|
|
state.reader.advance()
|
|
// Unlike a plain scalar (which consumes the space before a `:` into itself), a quoted scalar
|
|
// stops at its closing quote, so the reader sits at any spaces before a `:`. A space between
|
|
// an implicit key and its mapping-value indicator is allowed, so look past them.
|
|
if isAtMappingValueIndicatorAfterSpaces(state: state), canSynthesizeImplicitBlockKey(state) {
|
|
// A block implicit key must lie on a single line, so a quoted scalar that spanned a line
|
|
// break (its open and close quotes sit on different lines) cannot be one. The rule is
|
|
// block-only: a flow mapping key may span lines, so the check is gated on block context.
|
|
// An explicit key (`? ...`) carries no `:` directly after the scalar, so never reaches here.
|
|
guard start.line == state.reader.mark.line || state.flowDepth > 0 else {
|
|
throw PureYAML.Parsing.ParseError.multilineImplicitKey(line: start.line)
|
|
}
|
|
state.append(.mappingKey, mark: start, endMark: start)
|
|
}
|
|
state.append(.scalar(value: value, style: style), mark: start, endMark: state.reader.mark)
|
|
}
|
|
|
|
func scanBlockScalarHeader(
|
|
_ style: PureYAML.Parsing.BlockScalarStyle,
|
|
state: inout State,
|
|
) {
|
|
let start = state.reader.mark
|
|
var chomping = PureYAML.Parsing.BlockScalarChomping.clip
|
|
var indentationIndicator: Int?
|
|
state.reader.advance()
|
|
while let character = state.reader.peek(), isBlockScalarHeaderCharacter(character) {
|
|
if character == "-" {
|
|
chomping = .strip
|
|
} else if character == "+" {
|
|
chomping = .keep
|
|
} else if character.isNumber {
|
|
indentationIndicator = Int(String(character))
|
|
}
|
|
state.reader.advance()
|
|
}
|
|
state.append(
|
|
.blockScalarHeader(style: style, chomping: chomping),
|
|
mark: start,
|
|
endMark: state.reader.mark,
|
|
)
|
|
state.pendingBlockScalarIndentation = true
|
|
state.pendingBlockScalarIndentationIndicator = indentationIndicator
|
|
// A root block scalar (the document's own node) has no enclosing collection: it sits at the
|
|
// base indentation with no mapping value, explicit key, block-entry implicit indent, or flow
|
|
// context introducing it on this line. Only then is its parent the document (indentation -1),
|
|
// letting its content begin at column 0. A sequence item or mapping value keeps its parent's
|
|
// indent as the floor instead.
|
|
state.pendingBlockScalarIsRootNode = state.indentation == [0]
|
|
&& !state.sawMappingValueOnLine
|
|
&& !state.pendingExplicitKey
|
|
&& state.validImplicitIndentation.isEmpty
|
|
&& state.flowDepth == 0
|
|
// Whether this block scalar is an inline mapping value (`- key: |2`). Such a value's parent is
|
|
// the mapping, which sits at an implicit indentation off the main stack, so an explicit
|
|
// indicator is measured relative to it. A direct sequence item (`- |2`) has no mapping value
|
|
// on its line and keeps the sequence's own indentation as the base.
|
|
state.pendingBlockScalarInlineMappingValue = state.sawMappingValueOnLine && state.flowDepth == 0
|
|
}
|
|
|
|
func scanBlockScalarContent(_ state: inout State) {
|
|
let start = state.reader.mark
|
|
let value = state.blockScalarContentPrefix + state.reader.consume { character in
|
|
!isLineBreak(character)
|
|
}
|
|
state.blockScalarContentPrefix = ""
|
|
state.append(.scalar(value: value, style: .plain), mark: start, endMark: state.reader.mark)
|
|
}
|
|
|
|
func scanNamedToken(
|
|
kind: (String) -> PureYAML.Parsing.TokenKind,
|
|
missingNameError: (Int) -> PureYAML.Parsing.ParseError,
|
|
state: inout State,
|
|
) throws {
|
|
let start = state.reader.mark
|
|
state.reader.advance()
|
|
let name = state.reader.consume { character in
|
|
!isTokenTerminator(character)
|
|
}
|
|
guard !name.isEmpty else {
|
|
throw missingNameError(start.line)
|
|
}
|
|
state.append(kind(name), mark: start, endMark: state.reader.mark)
|
|
}
|
|
|
|
func scanTag(_ state: inout State) throws {
|
|
let start = state.reader.mark
|
|
state.reader.advance()
|
|
var value = "!"
|
|
if state.reader.peek() == "<" {
|
|
value.append(state.reader.advance() ?? "<")
|
|
var didClose = false
|
|
while let character = state.reader.peek() {
|
|
value.append(character)
|
|
state.reader.advance()
|
|
if character == ">" {
|
|
didClose = true
|
|
break
|
|
}
|
|
}
|
|
guard didClose else {
|
|
throw PureYAML.Parsing.ParseError.unterminatedTag(line: start.line)
|
|
}
|
|
} else {
|
|
value += state.reader.consume { character in
|
|
!isTokenTerminator(character)
|
|
}
|
|
value = expandTag(value, state: state)
|
|
}
|
|
state.append(.tag(value), mark: start, endMark: state.reader.mark)
|
|
}
|
|
|
|
func scanPlainScalar(_ state: inout State) {
|
|
let start = state.reader.mark
|
|
var value = ""
|
|
while let character = state.reader.peek() {
|
|
if shouldEndPlainScalar(character, state: state, accumulated: value) {
|
|
break
|
|
}
|
|
value.append(character)
|
|
state.reader.advance()
|
|
}
|
|
var trimmed = trimTrailingSpaces(value)
|
|
let isMappingKey = appendMappingKeyIfNeeded(start: start, state: &state)
|
|
if !isMappingKey {
|
|
trimmed = scanPlainScalarContinuations(
|
|
after: trimmed,
|
|
firstLineIndent: start.column - 1,
|
|
state: &state,
|
|
)
|
|
}
|
|
state.append(.scalar(value: trimmed, style: .plain), mark: start, endMark: state.reader.mark)
|
|
}
|
|
}
|