Sublime Text Syntax Definition.sublime-syntax

%YAML 1.2
---
name: Sublime Text Syntax Definition (YAML)
scope: source.yaml.sublime.syntax
version: 2

file_extensions:
  - sublime-syntax

variables:
  c_indicator: '[-?:,\[\]{}#&*!|>''"%@`]'
  c_flow_indicator: '[\[\]{},]'

  ns_plain_first_plain_out: |-
    (?x:
        [^\s{{c_indicator}}]
      | [?:-] \S
    )

  _flow_scalar_end_plain_out: |-
    (?x:
      (?=
          \s* $
        | \s+ \#
        | \s* : (\s|$)
      )
    )

  _flow_scalar_end_plain_in: |-
    (?x:
      (?=
          \s* $
        | \s+ \#
        | \s* : (\s|$)
        | \s* : {{c_flow_indicator}}
        | \s* {{c_flow_indicator}}
      )
    )

  # based on YAML.sublime-syntax's _flow_key_out_lookahead
  block_key_lookahead: |-
    (?x:
      (?=
        (
            {{ns_plain_first_plain_out}}
            (
                [^\s:]
              | : \S
              | \s+ (?![#\s])
            )*
          | \".*\" # simplified
          | \'.*\'
        )
        \s*
        :
        (\s|$)
      )
    )

  block_key_lookahead_bol: |-
    (?x:
      (?=
        ^ [ ]*
        {{ns_plain_first_plain_out}}
        (
            [^\s:]
          | : \S
          | \s+ (?![#\s])
        )*
        \s*
        :
        (\s|$)
      )
    )

  non_numeric_block_key_lookahead_bol: |-
    (?x:
      (?=
        ^ [ ]*
        (?!\d) # exclude number matches
        {{ns_plain_first_plain_out}}
        (
            [^\s:]
          | : \S
          | \s+ (?![#\s])
        )*
        \s*
        :
        (\s|$)
      )
    )

  plain_scalar_but_not_block_key: (?={{ns_plain_first_plain_out}})(?!{{block_key_lookahead}})

contexts:
  comment:
    # section comment
    - match: ^\s*(#+)\s*(\[)\s*([^#\]]+?)\s*(\])\s*(#+)\n?$
      scope: comment.line.number-sign.yaml
      captures:
        1: punctuation.definition.comment.line.number-sign.yaml
        2: punctuation.section.brackets.begin.sublime-syntax
        3: entity.name.section.sublime-syntax
        4: punctuation.section.brackets.end.sublime-syntax
        5: punctuation.definition.comment.line.number-sign.yaml  # may be unusual
    - include: Packages/YAML/YAML.sublime-syntax#comment

  main:
    - match: (name)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.type.display-name.sublime-syntax
        2: punctuation.separator.key-value.yaml

    - match: (scope)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.type.scope-name.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_scope

    - match: (version)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.type.version.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_int

    - match: (hidden)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.modifier.hidden.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_bool

    - match: (extends)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.type.extends.sublime-syntax
        2: punctuation.separator.key-value.yaml

    - match: ((?:hidden_)?file_extensions)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml entity.name.tag.yaml
        2: punctuation.separator.key-value.yaml

    - match: (first_line_match)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.other.first_line_match.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_regexp

    - match: (variables)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.control.flow.variables.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: variables_block

    - match: (contexts)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.control.flow.contexts.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: contexts_block

    - include: comment
    - include: yaml-tags-anchors

    - include: scope:source.yaml

  variables_block:
    - meta_scope: meta.block.variables.sublime-syntax
    - include: comment
    - include: yaml-tags-anchors
    - match: '^ +{{block_key_lookahead}}'
      push: variable
    - match: ^(?=\S)
      pop: true

  variable:
    # (based on YAML.sublime-syntax#block-pair)
    - match: :(?=\s|$)
      scope: punctuation.separator.mapping.key-value.yaml
      set: expect_regexp
    # http://yaml.org/spec/1.2/spec.html#style/flow/single-quoted
    # c-single-quoted(n,c)
    - match: "'"
      scope: punctuation.definition.string.begin.yaml
      push:
        - meta_scope: string.quoted.single.yaml
        - meta_content_scope: entity.name.constant.sublime-syntax
        - meta_include_prototype: false
        - match: "''"
          scope: constant.character.escape.single-quoted.yaml
        - match: "'"
          scope: punctuation.definition.string.end.yaml
          pop: true
    - include: Packages/YAML/YAML.sublime-syntax#flow-scalar-plain-out-implicit-type-12
    - match: ''
      push:
        - meta_scope: string.unquoted.plain.out.yaml entity.name.constant.sublime-syntax
        - match: '{{_flow_scalar_end_plain_out}}'
          pop: true

  contexts_block:
    - meta_scope: meta.block.contexts.sublime-syntax
    - include: comment
    - include: yaml-tags-anchors
    - include: context_definition
    - include: context_content
    - match: ^(?=\S)
      pop: true
    - include: scope:source.yaml

  context_definition:
    # (based on YAML.sublime-syntax#block-pair)
    - match: ^ {1,2}{{block_key_lookahead}}
      push:
        - include: Packages/YAML/YAML.sublime-syntax#flow-scalar-plain-out-implicit-type-12
        - match: :(?=\s|$)
          scope: punctuation.separator.mapping.key-value.yaml
          pop: true
        - match: ''
          set:
            - meta_scope: string.unquoted.plain.out.yaml entity.name.function.context.sublime-syntax
            - match: '{{_flow_scalar_end_plain_out}}'
              pop: true

  context_content:
    - match: (match)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.other.match.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_regexp

    - match: (escape)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.other.escape.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_regexp

    - match: ((?:escape_)?captures)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.type.captures.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_captures

    - match: ((?:embed_)?scope)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.type.scope-name.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_scope

    - match: (include|embed)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.operator.include.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_include

    - match: (branch|push|set)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.control.flow.push.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_context_list
      # can also be a normal context mapping (in which case the context pops)

    - match: (with_prototype)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.control.flow.push.sublime-syntax
        2: punctuation.separator.key-value.yaml

    - match: (pop)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.control.flow.pop.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_bool_or_int

    - match: (meta_(?:content_)?scope)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.type.scope-name.meta.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_scope

    - match: ((?:meta_include|apply)_prototype)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.control.flow.include-prototype.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_bool

    - match: (meta_(?:append|prepend))\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml storage.modifier.context-extension.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_bool

    - match: (comment)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml entity.name.tag.yaml
        3: punctuation.separator.key-value.yaml
      push: expect_comment

    - match: (clear_scopes)\s*(:)(?=\s|$)  # expects bool or number
      captures:
        1: string.unquoted.plain.out.yaml storage.modifier.clear-scopes.sublime-syntax
        2: punctuation.separator.key-value.yaml

    - match: (branch_point)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.declaration.branch-point.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_branch_point

    - match: (fail)\s*(:)(?=\s|$)
      captures:
        1: string.unquoted.plain.out.yaml keyword.control.flow.break.sublime-syntax
        2: punctuation.separator.key-value.yaml
      push: expect_branch_point_reference

  expect_captures:
    - meta_content_scope: meta.expect-captures
    - include: comment
    - include: yaml-tags-anchors
    - match: (\d+)\s*(:)(?=\s|$)
      captures:
        1: constant.numeric.integer.yaml
        2: punctuation.separator.key-value.yaml
      push: expect_scope
    - match: '{{non_numeric_block_key_lookahead_bol}}'
      pop: true
    - match: (?=\S)
      pop: true

  expect_scope:
    # ends upon EOL
    - meta_content_scope: meta.expect-scope
    - include: comment
    - include: yaml-tags-anchors
    - match: (?={{ns_plain_first_plain_out}})
      set:
        - meta_scope: meta.scope.sublime-syntax string.unquoted.plain.out.yaml
        - match: '{{_flow_scalar_end_plain_out}}'
          set:
            - match: \n?
              scope: meta.scope.sublime-syntax
              pop: true
        - match: \.
          scope: punctuation.separator.scope-segments.sublime-syntax
        # TODO match common scope names?
    # - include: scope:source.yaml
    - match: $
      pop: true

    - match: (?:(\|)|(>))([1-9])?([-+])?
      captures:
        1: keyword.control.flow.block-scalar.literal.yaml
        2: keyword.control.flow.block-scalar.folded.yaml
        3: constant.numeric.indentation-indicator.yaml
        4: storage.modifier.chomping-indicator.yaml
      set:
        # We need to match the first non-empty line
        # to determine the block's indentation level
        # (without verifying that indentation is big enough).
        - match: ^([ ]+)(?!$)
          set:
            - meta_scope: meta.scope.sublime-syntax string.unquoted.block.yaml
            - match: ^(?!\1|\s*$)
              pop: true
            - match: \.
              scope: punctuation.separator.scope-segments.sublime-syntax
            - include: regexp
        - match: ^(?=\S)  # the block is empty
          pop: true
        - include: comment
        - include: yaml-tags-anchors
        - match: .+
          scope: invalid.illegal.expected-comment-or-newline.yaml

  expect_branch_point:
    - meta_content_scope: meta.expect-branch-point
    - include: comment
    - include: yaml-tags-anchors
    - match: (?={{ns_plain_first_plain_out}})
      set:
        - meta_scope: meta.branch-point.sublime-syntax
            string.unquoted.plain.out.yaml
            entity.name.label.branch-point.sublime-syntax
        - match: '{{_flow_scalar_end_plain_out}}'
          pop: true
    - match: $|(?=\S)
      pop: true

  expect_branch_point_reference:
    - meta_content_scope: meta.expect-branch-point-reference
    - include: comment
    - include: yaml-tags-anchors
    - match: (?={{ns_plain_first_plain_out}})
      set:
        - meta_scope: meta.branch-point-reference.sublime-syntax
            string.unquoted.plain.out.yaml
            variable.other.branch-point.sublime-syntax
        - match: '{{_flow_scalar_end_plain_out}}'
          pop: true
    - match: $|(?=\S)
      pop: true

  expect_include:
    - meta_content_scope: meta.expect-context
    - include: comment
    - include: yaml-tags-anchors
    - include: include
    - match: $|(?=\S)
      pop: true

  expect_context_list:
    - meta_content_scope: meta.expect-context.list
    - include: comment
    - include: yaml-tags-anchors
    # array-like context list
    - match: \[
      scope: punctuation.definition.array.begin.sublime-syntax
      set:
        - meta_scope: meta.context-list.sublime-syntax meta.flow-sequence.yaml
        - match: \]
          scope: punctuation.definition.array.end.sublime-syntax
          pop: true
        - match: ','
          scope: punctuation.separator.array-element.sublime-syntax
        - include: comment
        - include: yaml-tags-anchors
        - include: include
    # multi-line context list
    - match: ^
      set:
        - meta_scope: meta.expect-context-list-or-content
        - include: comment
        - include: yaml-block-sequence
        - include: include_anonymous
        # first item after push/set looks like an included context
        # -> maybe include, maybe incomplete key
        # -> provide completions for both (context references and keys)
        - match: ^([ ]+)(?=-\s*{{plain_scalar_but_not_block_key}})
          set:
            - meta_content_scope: meta.context-list-or-content.sublime-syntax
            - include: context_list_content
            # if the first line contains a context reference
            # -> provide completions for context references only,
            #    beginning from the second line
            - match: ^(?=([ ]+)-)
              set:
                - meta_scope: meta.context-list.sublime-syntax
                - include: context_list_content
        # limit context to the current line
        - match: $|(?=\S)
          set: expect_include
    # maybe single include
    - match: (?=\S)
      set: expect_include

  context_list_content:
    - include: comment
    - include: include
    - include: yaml-block-sequence
    - include: include_anonymous
    # pop off at none-empty line with different indention than first include item
    - match: ^(?!(\s*$|\1-))
      pop: true
    - match: \S.+$
      scope: invalid.illegal.include.sublime-syntax

  include_anonymous:
    # a line with two (or more) hyphons after each other indicates the start
    # of an anonymous context block embedded into a context list
    - match: ^([ ]+)(?=- -)
      push:
        - clear_scopes: 1  # remove context-list... meta scopes
        - meta_content_scope: meta.anonymous-context.sublime-syntax
        - include: contexts_block
        - match: ^(?!(\s*$|\1 +))
          pop: true

  include:
    - match: '{{plain_scalar_but_not_block_key}}'
      push:
        - meta_scope: meta.include.sublime-syntax string.unquoted.plain.out.yaml
        - match: '{{_flow_scalar_end_plain_in}}'
          pop: true
        # scope-based includes
        - match: scope(:)(?=\w)
          scope: support.type.include.sublime-syntax
          captures:
            1: punctuation.definition.scope-include.sublime-syntax
          set:
            - meta_content_scope: meta.include.sublime-syntax string.unquoted.plain.out.yaml
            - match: '{{_flow_scalar_end_plain_in}}'
              pop: true
            - match: '#'
              scope: punctuation.separator.context-name.sublime-syntax
              set: expect_include
        # absolute includes
        - match: \w((?!\s#|:\s)[^{{c_flow_indicator}}])+\.sublime-syntax(?=\s*(#|$))
          scope: support.module.file-path.sublime-syntax
          set:
            - match: '{{_flow_scalar_end_plain_in}}'
              # use plain-in for when inside of a 'context-list', although not always accurate
              pop: true
            - match: '#'
              scope: meta.include.sublime-syntax
                string.unquoted.plain.out.yaml
                punctuation.separator.context-name.sublime-syntax
              pop: true
        # local includes
        - match: '[\w-]+{{_flow_scalar_end_plain_in}}'  # matches until first '/' or ',' or ']'
          scope: variable.other.sublime-syntax
        # We don't recognize this anything else, so just match as string
        - match: ''
          set:
            - meta_scope: string.unquoted.plain.out.yaml
            - match: '{{_flow_scalar_end_plain_in}}'
              pop: true

  expect_bool_or_int:
    - meta_content_scope: meta.expect-bool-or-int
    - include: comment
    - include: yaml-tags-anchors
    - include: expect_bool_value
    - include: expect_int_value
    - match: $
      pop: true

  expect_bool:
    - meta_content_scope: meta.expect-bool
    - include: comment
    - include: yaml-tags-anchors
    - include: expect_bool_value
    - match: $
      pop: true

  expect_bool_value:
    - match: \b(true|false){{_flow_scalar_end_plain_out}}
      scope: constant.language.boolean.yaml
      pop: true

  expect_int:
    - meta_content_scope: meta.expect-int
    - include: comment
    - include: yaml-tags-anchors
    - include: expect_int_value
    - match: $
      pop: true

  expect_int_value:
    - match: (?:0|[1-9][0-9_]*){{_flow_scalar_end_plain_out}}
      scope: constant.numeric.integer.decimal.yaml
      pop: true

  expect_comment:
    - meta_content_scope: meta.expect-comment
    - include: comment
    - include: yaml-tags-anchors
    - match: '"'
      scope: punctuation.definition.string.begin.yaml
      push:
        - meta_scope: comment.other.quoted.double.sublime-syntax
        - match: \\.
          scope: constant.character.escape.yaml
        - match: '"'
          scope: punctuation.definition.string.end.yaml
          pop: true

    - match: "'"
      scope: punctuation.definition.string.begin.yaml
      set:
        - meta_scope: comment.other.quoted.single.sublime-syntax
        - match: "''"
          scope: constant.character.escape.yaml
        - match: "'"
          scope: punctuation.definition.string.end.yaml
          pop: true

    - match: '{{plain_scalar_but_not_block_key}}'
      set:
        - meta_scope: comment.other.plain.sublime-syntax
        - match: '{{_flow_scalar_end_plain_out}}'
          pop: true

    - match: (?:(\|)|(>))([1-9])?([-+])?
      captures:
        1: punctuation.definition.block.scalar.literal.yaml
        2: punctuation.definition.block.scalar.folded.yaml
        3: constant.numeric.indentation-indicator.yaml
        4: storage.modifier.chomping-indicator.yaml
      set:
        - match: ^([ ]+)(?!$)  # match first non-empty line to determine indentation level
          # note that we do not check if indentation is enough
          set:
            - meta_scope: comment.other.unquoted.block.sublime-syntax
            - match: ^(?!\1|\s*$)
              pop: true
        - match: ^(?=\S)  # the block is empty
          pop: true
        - include: comment  # include comments but not properties
        - match: .+
          scope: invalid.illegal.expected-comment-or-newline.yaml

    - match: '{{block_key_lookahead_bol}}'
      pop: true
    - match: (?=\S)
      pop: true

  expect_regexp:
    - meta_content_scope: meta.expect-regexp
    - include: comment
    - include: yaml-tags-anchors

    # Not including the regexp syntax here because of the required double-escapes.
    # As such, double-quoting is discouraged.
    - match: '"'
      scope: punctuation.definition.string.begin.yaml
      push:
        - meta_scope: string.quoted.double.yaml
        - meta_content_scope: source.regexp.oniguruma
        - include: regexp_variable
        - match: \\.
          scope: constant.character.escape.yaml
        - match: '"'
          scope: punctuation.definition.string.end.yaml
          pop: 2

    - match: "'"
      scope: punctuation.definition.string.begin.yaml
      push:
        - meta_scope: meta.string.yaml
        - meta_content_scope: source.regexp.oniguruma
        - match: "'(?!')"
          scope: punctuation.definition.string.end.yaml
          pop: 2
        - match: ''
          push: regexp
          with_prototype:
            - include: regexp_variable
            - match: "''"
              scope: constant.character.escape.yaml
              push: regexp_quantifier_pop
            - match: \\''
              scope: constant.character.escape.regexp.yaml
              push: regexp_quantifier_pop
            - match: (?=')
              pop: true

    - match: '{{plain_scalar_but_not_block_key}}'
      push:
        - meta_scope: meta.string.yaml source.regexp.oniguruma
        - match: '{{_flow_scalar_end_plain_out}}'
          pop: true
        - include: regexp
      with_prototype:
        # Variables don't work in with_protoype blocks:
        # https://github.com/SublimeTextIssues/Core/issues/1488
        # - match: '{{_flow_scalar_end_plain_out}}'
        - match: |-
            (?x:
              (?=
                  \s* $
                | \s+ \#
                | \s* : (\s|$)
              )
            )
          pop: true
        - include: regexp_variable

    - match: (?:(\|)|(>))([1-9])?([-+])?
      captures:
        1: keyword.control.flow.block-scalar.literal.yaml
        2: keyword.control.flow.block-scalar.folded.yaml
        3: constant.numeric.indentation-indicator.yaml
        4: storage.modifier.chomping-indicator.yaml
      set:
        # We need to match the first non-empty line
        # to determine the block's indentation level
        # (without verifying that indentation is big enough).
        # To be more precise, this *should* then be checked in a with_protoype,
        # but due to with_prototype context overrides being compiled statically,
        # backreferences are not available.
        # Instead, only naively include the regexp context and hope the user
        # closes his regexp groups.
        #
        # Because extened mode `(?x)` would push its own context,
        # we match a block scalar beginning with this separately.
        #
        # Another option would be to pop on empty lines.
        - match: ^([ ]+)(?=.*\(\?[ims]*x[ixms]*(?:-[ims]+)?\))
        # This match is more accurate but doesn't match `match: ^(?x)`:
        # - match: ^([ ]+)(\()(\?[ims]*x[ixms]*(?:-[ims]+)?)(\))
        #   captures:
        #     2: keyword.control.group.regex
        #     3: storage.modifier.mode.regexp
        #     4: keyword.control.group.regex
          set:
            - meta_scope: source.regexp.oniguruma
            - match: ^(?!\1|\s*$)
              pop: true
            - include: regexp_extended
          with_prototype:
            - include: regexp_variable
        - match: ^([ ]+)(?!$)
          set:
            - meta_scope: source.regexp.oniguruma
            - match: ^(?!\1|\s*$)
              pop: true
            - include: regexp
          with_prototype:
            - include: regexp_variable
        - match: ^(?=\S)  # the block is empty
          pop: true
        - include: comment
        - include: yaml-tags-anchors
        - match: .+
          scope: invalid.illegal.expected-comment-or-newline.yaml

    - match: '{{block_key_lookahead_bol}}'
      pop: true

    - match: '(?!{{ns_plain_first_plain_out}})[^''"\s-].*'
      scope: invalid.illegal.expected-string.sublime-syntax
      pop: true

    - match: (?=\S)
      pop: true

  regexp:
    - include: Oniguruma RegExp.sublime-syntax

  regexp_extended:
    - meta_content_scope: source.regexp.oniguruma
    - include: Oniguruma RegExp.sublime-syntax#base-group-extended

  regexp_variable:
    - match: '(\{\{)([a-zA-Z_0-9]+)(\}\})'
      scope: meta.variable.sublime-syntax keyword.other.variable.sublime-syntax
      captures:
        1: punctuation.definition.variable.begin.sublime-syntax
        2: variable.other.sublime-syntax
        3: punctuation.definition.variable.end.sublime-syntax
      push: regexp_quantifier_pop

  regexp_quantifier_pop:
    - include: Oniguruma RegExp.sublime-syntax#quantifiers
    - match: ''
      pop: true

  yaml-block-sequence:
    - include: YAML.sublime-syntax#block-sequence

  yaml-tags-anchors:
    - include: YAML.sublime-syntax#property