base-syntax.yml

# This file is shared and exists so that we don't repeat ourselves in
# liquid.yml and liquid-injection.yml. Our build tool will merge these
# into the other files.
repository:
  core:
    patterns:
      - include: '#raw_tag'
      - include: '#doc_tag'
      - include: '#comment_block'
      - include: '#style_codefence'
      - include: '#stylesheet_codefence'
      - include: '#json_codefence'
      - include: '#javascript_codefence'
      - include: '#object'
      - include: '#tag'
      - include: text.html.basic

  injection:
    patterns:
      - include: '#raw_tag'
      - include: '#comment_block'
      - include: '#object'
      - include: '#tag_injection'

  raw_tag:
    begin: '{%-?\s*(raw)\s*-?%}'
    end: '{%-?\s*(endraw)\s*-?%}'
    beginCaptures:
      1: { name: entity.name.tag.liquid }
    endCaptures:
      1: { name: entity.name.tag.liquid }
    name: meta.entity.tag.raw.liquid
    contentName: string.unquoted.liquid
    patterns:
      - match: '(.(?!{%-?\s*endraw\s*-?%}))*.'

  doc_tag:
    begin: '{%-?\s*(doc)\s*-?%}'
    end: '{%-?\s*(enddoc)\s*-?%}'
    name: meta.block.doc.liquid
    contentName: comment.block.documentation.liquid
    beginCaptures:
      0: { name: meta.tag.liquid }
      1: { name: entity.name.tag.doc.liquid }
    endCaptures:
      0: { name: meta.tag.liquid }
      1: { name: entity.name.tag.doc.liquid }
    patterns:
      - include: '#liquid_doc_description_tag'
      - include: '#liquid_doc_param_tag'
      - include: '#liquid_doc_example_tag'
      - include: '#liquid_doc_fallback_tag'

  liquid_doc_description_tag:
    begin: '(@description)\b\s*'
    beginCaptures:
      0: { "name": comment.block.documentation.liquid }
      1: { "name": storage.type.class.liquid }
    end: '(?=@|{%-?\s*enddoc\s*-?%})'
    patterns:
      - match: '[^@]+'
        name: string.quoted.single.liquid

  liquid_doc_param_tag:
    match: '(@param)\s+(?:({[^}]*}?)\s+)?(\[?[a-zA-Z_][\w-]*\]?)?(?:\s+(.*))?'
    captures:
      1: { name: storage.type.class.liquid }
      2: { name: entity.name.type.instance.liquid }
      3: { name: variable.other.liquid }
      4: { name: string.quoted.single.liquid }

  liquid_doc_example_tag:
    begin: '(@example)\b\s*'
    beginCaptures:
      0: { name: comment.block.documentation.liquid }
      1: { name: storage.type.class.liquid }
    end: '(?=@|{%-?\s*enddoc\s*-?%})'
    contentName: meta.embedded.block.liquid
    patterns:
      - include: '#core'

  liquid_doc_fallback_tag:
    match: '(@\w+)\b'
    captures:
      1: { name: comment.block.liquid }

  comment_block:
    begin: '{%-?\s*comment\s*-?%}'
    end: '{%-?\s*endcomment\s*-?%}'
    name: comment.block.liquid
    patterns:
      # Liquid supports nested comment blocks. So an {% endcomment %}
      # inside a {% comment %} block is valid so long as it is paired.
      #
      # When this happens, we want to create a nested comment block
      # context. Hence why we have this recursive rule here.
      #
      # For more details:
      # https://github.com/shopify/liquid-tm-grammar/issues/4
      - include: '#comment_block'
      - match: '(.(?!{%-?\s*(comment|endcomment)\s*-?%}))*.'

  style_codefence:
    begin: '({%-?)\s*(style)\s*(-?%})'
    end: '({%-?)\s*(endstyle)\s*(-?%})'
    beginCaptures:
      0: { name: meta.tag.metadata.style.start.liquid }
      1: { name: punctuation.definition.tag.begin.liquid }
      2: { name: entity.name.tag.style.liquid }
      3: { name: punctuation.definition.tag.begin.liquid }
    endCaptures:
      0: { name: meta.tag.metadata.style.end.liquid }
      1: { name: punctuation.definition.tag.end.liquid }
      2: { name: entity.name.tag.style.liquid }
      3: { name: punctuation.definition.tag.end.liquid }
    name: meta.block.style.liquid
    contentName: meta.embedded.block.css
    patterns:
      - include: source.css

  stylesheet_codefence:
    begin: '({%-?)\s*(stylesheet)\s*(-?%})'
    end: '({%-?)\s*(endstylesheet)\s*(-?%})'
    beginCaptures:
      0: { name: meta.tag.metadata.style.start.liquid }
      1: { name: punctuation.definition.tag.begin.liquid }
      2: { name: entity.name.tag.style.liquid }
      3: { name: punctuation.definition.tag.begin.liquid }
    endCaptures:
      0: { name: meta.tag.metadata.style.end.liquid }
      1: { name: punctuation.definition.tag.end.liquid }
      2: { name: entity.name.tag.style.liquid }
      3: { name: punctuation.definition.tag.end.liquid }
    name: meta.block.style.liquid
    contentName: meta.embedded.block.css
    patterns:
      - include: source.css

  json_codefence:
    begin: '({%-?)\s*(schema)\s*(-?%})'
    end: '({%-?)\s*(endschema)\s*(-?%})'
    beginCaptures:
      0: { name: meta.tag.metadata.schema.start.liquid }
      1: { name: punctuation.definition.tag.begin.liquid }
      2: { name: entity.name.tag.schema.liquid }
      3: { name: punctuation.definition.tag.begin.liquid }
    endCaptures:
      0: { name: meta.tag.metadata.schema.end.liquid }
      1: { name: punctuation.definition.tag.end.liquid }
      2: { name: entity.name.tag.schema.liquid }
      3: { name: punctuation.definition.tag.end.liquid }
    name: meta.block.schema.liquid
    contentName: meta.embedded.block.json
    patterns:
      - include: source.json

  javascript_codefence:
    begin: '({%-?)\s*(javascript)\s*(-?%})'
    end: '({%-?)\s*(endjavascript)\s*(-?%})'
    beginCaptures:
      0: { name: meta.tag.metadata.javascript.start.liquid }
      1: { name: punctuation.definition.tag.begin.liquid }
      2: { name: entity.name.tag.javascript.liquid }
      3: { name: punctuation.definition.tag.begin.liquid }
    endCaptures:
      0: { name: meta.tag.metadata.javascript.end.liquid }
      1: { name: punctuation.definition.tag.end.liquid }
      2: { name: entity.name.tag.javascript.liquid }
      3: { name: punctuation.definition.tag.end.liquid }
    name: meta.block.javascript.liquid
    contentName: meta.embedded.block.js
    patterns:
      - include: source.js

  tag:
    begin: '<%= ABSURD_COMMENT_RAW_BACKTRACK %>{%-?'
    end: '-?%}'
    name: meta.tag.liquid
    beginCaptures:
      0: { name: punctuation.definition.tag.begin.liquid }
    endCaptures:
      0: { name: punctuation.definition.tag.end.liquid }
    patterns:
      - include: '#tag_body'

  tag_injection:
    # Here the begin makes sure we're not closing the tag because
    # otherwise our parent syntax would never close. Since The injection
    # would think that endstyle/endjavascript was part of the
    # injection
    begin: '<%= ABSURD_COMMENT_RAW_BACKTRACK %>{%-?(?!-?\s*(endstyle|endjavascript|endcomment|endraw))'
    end: '-?%}'
    name: meta.tag.liquid
    beginCaptures:
      0: { name: punctuation.definition.tag.end.liquid }
    endCaptures:
      0: { name: punctuation.definition.tag.end.liquid }
    patterns:
      - include: '#tag_body'

  tag_body:
    patterns:
      - include: '#tag_liquid'
      - include: '#tag_assign'
      - include: '#tag_comment_inline'
      - include: '#tag_case'
      - include: '#tag_conditional'
      - include: '#tag_for'
      - include: '#tag_paginate'
      - include: '#tag_render'
      - include: '#tag_tablerow'
      - include: '#tag_expression'

  tag_liquid:
    name: meta.entity.tag.liquid.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(liquid)\b'
    beginCaptures:
      1: { name: keyword.control.liquid.liquid }
    end: '(?=%})'
    patterns:
      - include: '#tag_comment_block_liquid'
      - include: '#tag_comment_inline_liquid'
      - include: '#tag_assign_liquid'
      - include: '#tag_case_liquid'
      - include: '#tag_conditional_liquid'
      - include: '#tag_for_liquid'
      - include: '#tag_paginate_liquid'
      - include: '#tag_render_liquid'
      - include: '#tag_tablerow_liquid'
      - include: '#tag_expression_liquid'

  tag_comment_block_liquid:
    name: comment.block.liquid
    begin: '(?:^\s*)(comment)\b'
    end: '(?:^\s*)(endcomment)\b'
    patterns:
      # Liquid supports nested comment blocks. So an endcomment
      # inside a comment block is valid so long as it is paired.
      #
      # When this happens, we want to create a nested comment block
      # context. Hence why we have this recursive rule here.
      #
      # For more details:
      # https://github.com/shopify/liquid-tm-grammar/issues/9
      - include: '#tag_comment_block_liquid'
      - match: '(?:^\s*)(?!(comment|endcomment)).*'

  tag_comment_inline:
    name: comment.line.number-sign.liquid
    begin: '#'
    end: '(?=%})'

  tag_comment_inline_liquid:
    name: comment.line.number-sign.liquid
    begin: '(?:^\s*)#.*'
    end: '$'

  tag_tablerow:
    name: meta.entity.tag.tablerow.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(tablerow)\b'
    beginCaptures:
      1: { name: keyword.control.tablerow.liquid }
    end: '(?=%})'
    patterns:
      - include: '#tag_tablerow_body'

  tag_tablerow_liquid:
    name: meta.entity.tag.tablerow.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(tablerow)\b'
    beginCaptures:
      1: { name: keyword.control.tablerow.liquid }
    end: '$'
    patterns:
      - include: '#tag_tablerow_body'

  tag_tablerow_body:
    patterns:
      - match: '\b(in)\b'
        name: keyword.control.liquid
      - match: '\b(cols|offset|limit):'
        name: keyword.control.liquid
      - include: '#value_expression'

  tag_for:
    name: meta.entity.tag.for.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(for)\b'
    beginCaptures:
      1: { name: keyword.control.for.liquid }
    end: '(?=%})'
    patterns:
      - include: '#tag_for_body'

  tag_for_liquid:
    name: meta.entity.tag.for.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(for)\b'
    beginCaptures:
      1: { name: keyword.control.for.liquid }
    end: '$'
    patterns:
      - include: '#tag_for_body'

  tag_for_body:
    patterns:
      - match: '\b(in|reversed)\b'
        name: keyword.control.liquid
      - match: '\b(offset|limit):'
        name: keyword.control.liquid
      - include: '#value_expression'

  tag_assign:
    name: meta.entity.tag.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(assign|echo)\b'
    beginCaptures:
      1: { name: entity.name.tag.liquid }
    end: '(?=%})'
    patterns:
      - include: '#filter'
      - include: '#attribute'
      - include: '#value_expression'

  tag_assign_liquid:
    name: meta.entity.tag.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(assign|echo)\b'
    beginCaptures:
      1: { name: entity.name.tag.liquid }
    end: '$'
    patterns:
      - include: '#filter'
      - include: '#attribute_liquid'
      - include: '#value_expression'

  tag_render:
    name: meta.entity.tag.render.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(render)\b'
    beginCaptures:
      1: { name: entity.name.tag.render.liquid }
    end: '(?=%})'
    patterns:
      - include: '#tag_render_special_keywords'
      - include: '#attribute'
      - include: '#value_expression'

  tag_render_liquid:
    name: meta.entity.tag.render.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(render)\b'
    beginCaptures:
      1: { name: entity.name.tag.render.liquid }
    end: '$'
    patterns:
      - include: '#tag_render_special_keywords'
      - include: '#attribute_liquid'
      - include: '#value_expression'

  tag_render_special_keywords:
    match: '\b(with|as|for)\b'
    name: keyword.control.other.liquid

  tag_paginate:
    name: meta.entity.tag.paginate.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(paginate)\b'
    beginCaptures:
      1: { name: keyword.control.paginate.liquid }
    end: '(?=%})'
    patterns:
      - include: '#tag_paginate_body'

  tag_paginate_liquid:
    name: meta.entity.tag.paginate.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(paginate)\b'
    beginCaptures:
      1: { name: keyword.control.paginate.liquid }
    end: '$'
    patterns:
      - include: '#tag_paginate_body'

  tag_paginate_body:
    patterns:
      - match: '\b(by)\b'
        name: keyword.control.liquid
      - include: '#value_expression'

  tag_conditional:
    name: meta.entity.tag.conditional.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(if|elsif|unless)\b'
    beginCaptures:
      1: { name: keyword.control.conditional.liquid }
    end: '(?=%})'
    patterns:
      - include: '#value_expression'

  tag_conditional_liquid:
    name: meta.entity.tag.conditional.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(if|elsif|unless)\b'
    beginCaptures:
      1: { name: keyword.control.conditional.liquid }
    end: '$'
    patterns:
      - include: '#value_expression'

  tag_case:
    name: meta.entity.tag.case.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(case|when)\b'
    beginCaptures:
      1: { name: keyword.control.case.liquid }
    end: '(?=%})'
    patterns:
      - include: '#value_expression'

  tag_case_liquid:
    name: meta.entity.tag.case.liquid
    begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(case|when)\b'
    beginCaptures:
      1: { name: keyword.control.case.liquid }
    end: '$'
    patterns:
      - include: '#value_expression'

  tag_expression_without_arguments:
    patterns:
      # The ugly regex at the beginning is to check if you start with
      # {%, {%- or the start of the line but without capturing the
      # result.
      - match: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(endunless|endif)\b'
        captures:
          1: { name: keyword.control.conditional.liquid }
      - match: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(endfor|endtablerow|endpaginate)\b'
        captures:
          1: { name: keyword.control.loop.liquid }
      - match: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(endcase)\b'
        captures:
          1: { name: keyword.control.case.liquid }
      - match: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(<%= ANY_BLOCK_OPEN_TAG %>)\b'
        captures:
          1: { name: keyword.control.other.liquid }
      - match: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(<%= ANY_BLOCK_END_TAG %>)\b'
        captures:
          1: { name: keyword.control.other.liquid }
      - match: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(else|break|continue)\b'
        captures:
          1: { name: keyword.control.other.liquid }

  tag_expression:
    patterns:
      - include: '#tag_expression_without_arguments'
      - begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(\w+)'
        beginCaptures:
          1: { name: entity.name.tag.liquid }
        end: '(?=%})'
        name: meta.entity.tag.liquid
        patterns:
          - include: '#value_expression'

  tag_expression_liquid:
    patterns:
      - include: '#tag_expression_without_arguments'
      - begin: '(?:(?:(?<={%)|(?<={%-)|^)\s*)(\w+)'
        beginCaptures:
          1: { name: entity.name.tag.liquid }
        end: '$'
        name: meta.entity.tag.liquid
        patterns:
          - include: '#value_expression'

  object:
    begin: '<%= ABSURD_COMMENT_RAW_BACKTRACK %>{{-?'
    end: '-?}}'
    name: meta.object.liquid
    beginCaptures:
      0: { name: punctuation.definition.tag.begin.liquid }
    endCaptures:
      0: { name: punctuation.definition.tag.end.liquid }
    patterns:
      - include: '#filter'
      - include: '#attribute'
      - include: '#value_expression'

  # Parens without .. in the middle are not supported in conditions
  invalid_range:
    match: '\((.(?!\.\.))+\)'
    name: invalid.illegal.range.liquid

  range:
    begin: '\('
    end: '\)'
    name: meta.range.liquid
    beginCaptures:
      0: { name: punctuation.section.parens.begin.liquid }
    endCaptures:
      0: { name: punctuation.section.parens.end.liquid }
    patterns:
      - match: '\.\.'
        name: 'punctuation.range.liquid'
      - include: '#variable_lookup'
      - include: '#number'

  number:
    match: '((-|\+)\s*)?[0-9]+(\.[0-9]+)?'
    name: constant.numeric.liquid

  string:
    patterns:
      - include: '#string_single'
      - include: '#string_double'

  string_double:
    begin: '"'
    end: '"'
    name: string.quoted.double.liquid

  string_single:
    begin: "'"
    end: "'"
    name: string.quoted.single.liquid

  operator:
    match: '(?:(?<=\s)|\b)(<%= ANY_OPERATOR %>)(?:(?=\s)|\b)'
    captures:
      1: { name: keyword.operator.expression.liquid }

  language_constant:
    match: '\b(false|true|nil|blank)\b|empty(?!\?)'
    name: constant.language.liquid

  attribute:
    begin: '\w+:'
    end: '(?=,|%}|}}|\|)'
    beginCaptures:
      0: { name: 'entity.other.attribute-name.liquid' }
    patterns:
      - include: '#value_expression'

  attribute_liquid:
    begin: '\w+:'
    end: '(?=,|\|)|$'
    beginCaptures:
      0: { name: 'entity.other.attribute-name.liquid' }
    patterns:
      - include: '#value_expression'

  filter:
    # filter with args (e.g. "at_most" in `| at_most: 1` )
    match: '\|\s*((?![\.0-9])[a-zA-Z0-9_-]+\:?)\s*'
    captures:
      1: { name: support.function.liquid }

  value_expression:
    patterns:
        # TODO ???
      - match: '(\[)(\|)(?=[^\]]*)(?=\])'
        captures:
          '2': { name: invalid.illegal.filter.liquid }
          '3': { name: invalid.illegal.filter.liquid }

        # TODO ???
      - match: '(?<=\s)(\+|\-|\/|\*)(?=\s)'
        name: invalid.illegal.filter.liquid

      - include: '#language_constant'
      - include: '#operator'
      - include: '#invalid_range'
      - include: '#range'
      - include: '#number'
      - include: '#string'
      - include: '#variable_lookup'

  variable_lookup:
    patterns:
        # Stuff provided by the language has its own colour
      - match: \b(<%= ANY_GLOBAL_OBJECT %>)\b
        name: variable.language.liquid

        # a parameter name following a colon. e.g. "var" in `product: var`
      - match: '((?<=\w\:\s)\w+)'
        name: variable.parameter.liquid

        # square brackets accessor
      - begin: (?<=\w)\[
        beginCaptures:
          0: { name: punctuation.section.brackets.begin.liquid }
        end: \]
        endCaptures:
          0: { name: punctuation.section.brackets.end.liquid }
        name: meta.brackets.liquid
        patterns:
          - include: '#string'

        # what follows the dot in a variable
      - match: (?<=(\w|\])\.)([-\w]+\??)
        name: variable.other.member.liquid

        # the literal dot
      - match: (?<=\w)\.(?=\w)
        name: punctuation.accessor.liquid

        # the beginning of the variable
      - match: (?i)[a-z_](\w|(?:-(?!\}\})))*
        name: variable.other.liquid