Polar.sublime-syntax

%YAML 1.2
---
name: Polar
scope: source.polar
file_extensions: [polar]
version: 2

contexts:
  main:
    - include: comment
    - include: rule
    - include: rule-type
    - include: inline-query
    - include: resource-block
    - include: test-block

  comment:
    - match: '#.*'
      scope: comment.line.number-sign.polar

  rule:
    - include: rule-functor
    - match: \bif\b
      scope: keyword.control.if.polar
      push:
        - include: term
        - match: ;
          pop: true
    - match: ;

  rule-functor:
    - match: ([a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z0-9_]+)*)\s*\(
      captures:
        1: support.function.rule
      push:
        - include: specializer
        - match: \,
          scope: punctuation.separator.sequence.list.polar
        - include: term
        - match: \)
          pop: true

  specializer:
    - match: "[a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z0-9_]+)*\\s*:\\s*([a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z0-9_]+)*)"
      captures:
        1: entity.name.type.resource

  rule-type:
    - match: \btype\b
      captures:
        1: keyword.other.type-decl
      push:
        - meta_scope: meta.rule-type.polar
        - include: rule-functor
        - match: ;
          pop: true

  inline-query:
    - match: \?=
      scope: meta.inline-query.polar
      captures:
        1: keyword.control
      push:
        - include: term
        - match: ;
          pop: true

  resource-block:
    - match: ((resource|actor)\s+([a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z0-9_]+)*)|(global))\s*\{
      captures:
        2: keyword.control
        3: entity.name.type
        4: keyword.control
      push:
        - meta_scope: meta.resource-block.polar
        - match: ;
          scope: punctuation.separator.sequence.declarations.polar
        - match: \{
          push:
            - meta_scope: meta.relation-declaration.polar
            - include: specializer
            - include: comment
            - match: \,
              scope: punctuation.separator.sequence.dict.polar
            - match: \}
              pop: true
        - include: term
        - match: \}
          pop: true

  test-block:
    - match: (test)\s+(\"[^\"]*\")\s*\{
      captures:
        1: keyword.control
        2: string.quoted.double
      push:
        - meta_scope: meta.test-block.polar
        - match: (setup)\s*\{
          captures:
            1: keyword.control
          push:
            - meta_scope: meta.test-setup.polar
            - include: rule
            - include: comment
            - match: \}
              pop: true
        - include: rule
        - match: \b(assert|assert_not)\b
          scope: keyword.other.polar
        - include: comment
        - match: \}
          pop: true

  term:
    - include: comment
    - include: string
    - include: number
    - include: keyword
    - include: operator
    - include: boolean
    - include: object-literal
    - match: \[
      push:
        - meta_scope: meta.bracket.list.polar
        - include: term
        - match: \,
          scope: punctuation.separator.sequence.list.polar
        - match: \]
          pop: true
    - match: \{
      push:
        - meta_scope: meta.bracket.dict.polar
        - include: term
        - match: \,
          scope: punctuation.separator.sequence.dict.polar
        - match: \}
          pop: true
    - match: \(
      push:
        - meta_scope: meta.parens.polar
        - include: term
        - match: \,
          scope: punctuation.separator.sequence.list.polar
        - match: \)
          pop: true

  string:
    - match: '"'
      push:
        - meta_scope: string.quoted.double.polar
        - match: \\.
          scope: constant.character.escape.polar
        - match: '"'
          pop: true

  number:
    - match: \b[+-]?\d+(?:(\.)\d+(?:e[+-]?\d+)?|(?:e[+-]?\d+))\b
      scope: constant.numeric.float.polar
    - match: \b(\+|\-)[\d]+\b
      scope: constant.numeric.integer.polar
    - match: \b[\d]+\b
      scope: constant.numeric.natural.polar

  boolean:
    - match: \b(true|false)\b
      scope: constant.language.boolean.polar

  keyword:
    - match: \b(cut|or|debug|print|in|forall|if|and|of|not|matches|type|on|global)\b
      scope: constant.character.polar

  operator:
    - match: (\+|\-|\*|\/|<|>|=|!)
      scope: keyword.control.polar

  object-literal:
    - match: ([a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z0-9_]+)*)\s*\{
      captures:
        0: constant.other.object-literal
        1: entity.name.type.resource
      push:
        - include: string
        - include: number
        - include: boolean
        - match: \}
          scope: constant.other.object-literal.polar
          pop: true