rouge-alda 3.3.0

data/lib/rouge/lexers/css.rb

@@ -0,0 +1,274 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class CSS < RegexLexer
+      title "CSS"
+      desc "Cascading Style Sheets, used to style web pages"
+
+      tag 'css'
+      filenames '*.css'
+      mimetypes 'text/css'
+
+      identifier = /[a-zA-Z0-9_-]+/
+      number = /-?(?:[0-9]+(\.[0-9]+)?|\.[0-9]+)/
+
+      def self.attributes
+        @attributes ||= Set.new %w(
+          align-content align-items align-self alignment-adjust
+          alignment-baseline all anchor-point animation
+          animation-delay animation-direction animation-duration
+          animation-fill-mode animation-iteration-count animation-name
+          animation-play-state animation-timing-function appearance
+          azimuth backface-visibility background background-attachment
+          background-clip background-color background-image
+          background-origin background-position background-repeat
+          background-size baseline-shift binding bleed bookmark-label
+          bookmark-level bookmark-state bookmark-target border
+          border-bottom border-bottom-color border-bottom-left-radius
+          border-bottom-right-radius border-bottom-style
+          border-bottom-width border-collapse border-color
+          border-image border-image-outset border-image-repeat
+          border-image-slice border-image-source border-image-width
+          border-left border-left-color border-left-style
+          border-left-width border-radius border-right
+          border-right-color border-right-style border-right-width
+          border-spacing border-style border-top border-top-color
+          border-top-left-radius border-top-right-radius
+          border-top-style border-top-width border-width bottom
+          box-align box-decoration-break box-direction box-flex
+          box-flex-group box-lines box-ordinal-group box-orient
+          box-pack box-shadow box-sizing break-after break-before
+          break-inside caption-side clear clip clip-path
+          clip-rule color color-profile columns column-count
+          column-fill column-gap column-rule column-rule-color
+          column-rule-style column-rule-width column-span
+          column-width content counter-increment counter-reset
+          crop cue cue-after cue-before cursor direction display
+          dominant-baseline drop-initial-after-adjust
+          drop-initial-after-align drop-initial-before-adjust
+          drop-initial-before-align drop-initial-size
+          drop-initial-value elevation empty-cells filter fit
+          fit-position flex flex-basis flex-direction flex-flow
+          flex-grow flex-shrink flex-wrap float float-offset
+          font font-family font-feature-settings
+          font-kerning font-language-override font-size
+          font-size-adjust font-stretch font-style font-synthesis
+          font-variant font-variant-alternates font-variant-caps
+          font-variant-east-asian font-variant-ligatures
+          font-variant-numeric font-variant-position font-weight
+          grid-cell grid-column grid-column-align grid-column-sizing
+          grid-column-span grid-columns grid-flow grid-row
+          grid-row-align grid-row-sizing grid-row-span
+          grid-rows grid-template hanging-punctuation height
+          hyphenate-after hyphenate-before hyphenate-character
+          hyphenate-lines hyphenate-resource hyphens icon
+          image-orientation image-rendering image-resolution
+          ime-mode inline-box-align justify-content
+          left letter-spacing line-break line-height
+          line-stacking line-stacking-ruby line-stacking-shift
+          line-stacking-strategy list-style list-style-image
+          list-style-position list-style-type margin
+          margin-bottom margin-left margin-right margin-top
+          mark marker-offset marks mark-after mark-before
+          marquee-direction marquee-loop marquee-play-count
+          marquee-speed marquee-style mask max-height max-width
+          min-height min-width move-to nav-down
+          nav-index nav-left nav-right nav-up object-fit
+          object-position opacity order orphans outline
+          outline-color outline-offset outline-style
+          outline-width overflow overflow-style overflow-wrap
+          overflow-x overflow-y padding padding-bottom
+          padding-left padding-right padding-top
+          page page-break-after page-break-before
+          page-break-inside page-policy pause pause-after
+          pause-before perspective perspective-origin
+          phonemes pitch pitch-range play-during pointer-events
+          position presentation-level punctuation-trim quotes
+          rendering-intent resize rest rest-after rest-before
+          richness right rotation rotation-point ruby-align
+          ruby-overhang ruby-position ruby-span size speak
+          speak-as speak-header speak-numeral speak-punctuation
+          speech-rate src stress string-set
+          tab-size table-layout target target-name
+          target-new target-position text-align
+          text-align-last text-combine-horizontal
+          text-decoration text-decoration-color
+          text-decoration-line text-decoration-skip
+          text-decoration-style text-emphasis
+          text-emphasis-color text-emphasis-position
+          text-emphasis-style text-height text-indent
+          text-justify text-orientation text-outline
+          text-overflow text-rendering text-shadow
+          text-space-collapse text-transform
+          text-underline-position text-wrap top
+          transform transform-origin transform-style
+          transition transition-delay transition-duration
+          transition-property transition-timing-function
+          unicode-bidi vertical-align
+          visibility voice-balance voice-duration
+          voice-family voice-pitch voice-pitch-range
+          voice-range voice-rate voice-stress voice-volume
+          volume white-space widows width word-break
+          word-spacing word-wrap writing-mode z-index
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          above absolute always armenian aural auto avoid left bottom
+          baseline behind below bidi-override blink block bold bolder
+          both bottom capitalize center center-left center-right circle
+          cjk-ideographic close-quote collapse condensed continuous crop
+          cross crosshair cursive dashed decimal decimal-leading-zero
+          default digits disc dotted double e-resize embed expanded
+          extra-condensed extra-expanded fantasy far-left far-right fast
+          faster fixed georgian groove hebrew help hidden hide high higher
+          hiragana hiragana-iroha icon inherit inline inline-table inset
+          inside invert italic justify katakana katakana-iroha landscape
+          large larger left left-side leftwards level lighter line-through
+          list-item loud low lower lower-alpha lower-greek lower-roman
+          lowercase ltr medium message-box middle mix monospace n-resize
+          narrower ne-resize no-close-quote no-open-quote no-repeat none
+          normal nowrap nw-resize oblique once open-quote outset outside
+          overline pointer portrait px relative repeat repeat-x repeat-y
+          rgb ridge right right-side rightwards s-resize sans-serif scroll
+          se-resize semi-condensed semi-expanded separate serif show
+          silent slow slower small-caps small-caption smaller soft solid
+          spell-out square static status-bar super sw-resize table-caption
+          table-cell table-column table-column-group table-footer-group
+          table-header-group table-row table-row-group text text-bottom
+          text-top thick thin top transparent ultra-condensed
+          ultra-expanded underline upper-alpha upper-latin upper-roman
+          uppercase url visible w-resize wait wider x-fast x-high x-large
+          x-loud x-low x-small x-soft xx-large xx-small yes
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          indigo gold firebrick indianred yellow darkolivegreen
+          darkseagreen mediumvioletred mediumorchid chartreuse
+          mediumslateblue black springgreen crimson lightsalmon brown
+          turquoise olivedrab cyan silver skyblue gray darkturquoise
+          goldenrod darkgreen darkviolet darkgray lightpink teal
+          darkmagenta lightgoldenrodyellow lavender yellowgreen thistle
+          violet navy orchid blue ghostwhite honeydew cornflowerblue
+          darkblue darkkhaki mediumpurple cornsilk red bisque slategray
+          darkcyan khaki wheat deepskyblue darkred steelblue aliceblue
+          gainsboro mediumturquoise floralwhite coral purple lightgrey
+          lightcyan darksalmon beige azure lightsteelblue oldlace
+          greenyellow royalblue lightseagreen mistyrose sienna lightcoral
+          orangered navajowhite lime palegreen burlywood seashell
+          mediumspringgreen fuchsia papayawhip blanchedalmond peru
+          aquamarine white darkslategray ivory dodgerblue lemonchiffon
+          chocolate orange forestgreen slateblue olive mintcream
+          antiquewhite darkorange cadetblue moccasin limegreen saddlebrown
+          darkslateblue lightskyblue deeppink plum aqua darkgoldenrod
+          maroon sandybrown magenta tan rosybrown pink lightblue
+          palevioletred mediumseagreen dimgray powderblue seagreen snow
+          mediumblue midnightblue paleturquoise palegoldenrod whitesmoke
+          darkorchid salmon lightslategray lawngreen lightgreen tomato
+          hotpink lightyellow lavenderblush linen mediumaquamarine green
+          blueviolet peachpuff
+        )
+      end
+
+      # source: http://www.w3.org/TR/CSS21/syndata.html#vendor-keyword-history
+      def self.vendor_prefixes
+        @vendor_prefixes ||= Set.new %w(
+          -ah- -atsc- -hp- -khtml- -moz- -ms- -o- -rim- -ro- -tc- -wap-
+          -webkit- -xv- mso- prince-
+        )
+      end
+
+      state :root do
+        mixin :basics
+        rule /{/, Punctuation, :stanza
+        rule /:[:]?#{identifier}/, Name::Decorator
+        rule /\.#{identifier}/, Name::Class
+        rule /##{identifier}/, Name::Function
+        rule /@#{identifier}/, Keyword, :at_rule
+        rule identifier, Name::Tag
+        rule %r([~^*!%&\[\]()<>|+=@:;,./?-]), Operator
+        rule /"(\\\\|\\"|[^"])*"/, Str::Single
+        rule /'(\\\\|\\'|[^'])*'/, Str::Double
+      end
+
+      state :value do
+        mixin :basics
+        rule /url\(.*?\)/, Str::Other
+        rule /#[0-9a-f]{1,6}/i, Num # colors
+        rule /#{number}(?:%|(?:em|px|pt|pc|in|mm|cm|ex|rem|ch|vw|vh|vmin|vmax|dpi|dpcm|dppx|deg|grad|rad|turn|s|ms|Hz|kHz)\b)?/, Num
+        rule /[\[\]():\/.,]/, Punctuation
+        rule /"(\\\\|\\"|[^"])*"/, Str::Single
+        rule /'(\\\\|\\'|[^'])*'/, Str::Double
+        rule(identifier) do |m|
+          if self.class.constants.include? m[0]
+            token Name::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+      end
+
+      state :at_rule do
+        rule /{(?=\s*#{identifier}\s*:)/m, Punctuation, :at_stanza
+        rule /{/, Punctuation, :at_body
+        rule /;/, Punctuation, :pop!
+        mixin :value
+      end
+
+      state :at_body do
+        mixin :at_content
+        mixin :root
+      end
+
+      state :at_stanza do
+        mixin :at_content
+        mixin :stanza
+      end
+
+      state :at_content do
+        rule /}/ do
+          token Punctuation
+          pop! 2
+        end
+      end
+
+      state :basics do
+        rule /\s+/m, Text
+        rule %r(/\*(?:.*?)\*/)m, Comment
+      end
+
+      state :stanza do
+        mixin :basics
+        rule /}/, Punctuation, :pop!
+        rule /(#{identifier})(\s*)(:)/m do |m|
+          name_tok = if self.class.attributes.include? m[1]
+            Name::Label
+          elsif self.class.vendor_prefixes.any? { |p| m[1].start_with?(p) }
+            Name::Label
+          else
+            Name::Property
+          end
+
+          groups name_tok, Text, Punctuation
+
+          push :stanza_value
+        end
+      end
+
+      state :stanza_value do
+        rule /;/, Punctuation, :pop!
+        rule(/(?=})/) { pop! }
+        rule /!\s*important\b/, Comment::Preproc
+        rule /^@.*?$/, Comment::Preproc
+        mixin :value
+      end
+    end
+  end
+end

data/lib/rouge/lexers/d.rb

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class D < RegexLexer
+      tag 'd'
+      aliases 'dlang'
+      filenames '*.d', '*.di'
+      mimetypes 'application/x-dsrc', 'text/x-dsrc'
+
+      title "D"
+      desc 'The D programming language(dlang.org)'
+
+      keywords = %w(
+        abstract alias align asm assert auto body
+        break case cast catch class const continue
+        debug default delegate delete deprecated do else
+        enum export extern finally final foreach_reverse
+        foreach for function goto if immutable import
+        interface invariant inout in is lazy mixin
+        module new nothrow out override package pragma
+        private protected public pure ref return scope
+        shared static struct super switch synchronized
+        template this throw try typedef typeid typeof
+        union unittest version volatile while with
+        __gshared __traits __vector __parameters
+      )
+
+      keywords_type = %w(
+        bool byte cdouble cent cfloat char creal
+        dchar double float idouble ifloat int ireal
+        long real short ubyte ucent uint ulong
+        ushort void wchar
+      )
+
+      keywords_pseudo = %w(
+        __FILE__ __MODULE__ __LINE__ __FUNCTION__ __PRETTY_FUNCTION__
+         __DATE__ __EOF__ __TIME__ __TIMESTAMP__ __VENDOR__
+        __VERSION__
+      )
+
+      state :whitespace do
+        rule /\n/m, Text
+        rule /\s+/m, Text
+      end
+
+      state :root do
+        mixin :whitespace
+        # Comments
+        rule %r(//(.*?)\n), Comment::Single
+        rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :nested_comment
+        # Keywords
+        rule /(#{keywords.join('|')})\b/, Keyword
+        rule /(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule /(false|true|null)\b/, Keyword::Constant
+        rule /(#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo
+        rule /macro\b/, Keyword::Reserved
+        rule /(string|wstring|dstring|size_t|ptrdiff_t)\b/, Name::Builtin
+        # Literals
+        # HexFloat
+        rule /0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
+        # DecimalFloat
+        rule /[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
+        rule /\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
+        # IntegerLiteral
+        # Binary
+        rule /0[Bb][01_]+/, Num::Bin
+        # Octal
+        # TODO: 0[0-7] isn't supported use octal![0-7] instead
+        rule /0[0-7_]+/, Num::Oct
+        # Hexadecimal
+        rule /0[xX][0-9a-fA-F_]+/, Num::Hex
+        # Decimal
+        rule /(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
+        # CharacterLiteral
+        rule /'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'/, Str::Char
+        # StringLiteral
+        # WysiwygString
+        rule /r"[^"]*"[cwd]?/, Str
+        # Alternate WysiwygString
+        rule /`[^`]*`[cwd]?/, Str
+        # DoubleQuotedString
+        rule /"(\\\\|\\"|[^"])*"[cwd]?/, Str
+        # EscapeSequence
+        rule /\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)/, Str
+        # HexString
+        rule /x"[0-9a-fA-F_\s]*"[cwd]?/, Str
+        # DelimitedString
+        rule /q"\[/, Str, :delimited_bracket
+        rule /q"\(/, Str, :delimited_parenthesis
+        rule /q"</, Str, :delimited_angle
+        rule /q"\{/, Str, :delimited_curly
+        rule /q"([a-zA-Z_]\w*)\n.*?\n\1"/, Str
+        rule /q"(.).*?\1"/, Str
+        # TokenString
+        rule /q\{/, Str, :token_string
+        # Attributes
+        rule /@([a-zA-Z_]\w*)?/, Name::Decorator
+        # Tokens
+        rule %r`(~=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>=|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)|[/.&|\-+<>!()\[\]{}?,;:$=*%^~]`, Punctuation
+        # Identifier
+        rule /[a-zA-Z_]\w*/, Name
+        # Line
+        rule /#line\s.*\n/, Comment::Special
+      end
+
+      state :nested_comment do
+        rule %r([^+/]+), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :push
+        rule %r(\+/), Comment::Multiline, :pop!
+        rule %r([+/]), Comment::Multiline
+      end
+
+      state :token_string do
+        rule /\{/, Punctuation, :token_string_nest
+        rule /\}/, Str, :pop!
+        mixin :root
+      end
+
+      state :token_string_nest do
+        rule /\{/, Punctuation, :push
+        rule /\}/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :delimited_bracket do
+        rule /[^\[\]]+/, Str
+        rule /\[/, Str, :delimited_inside_bracket
+        rule /\]"/, Str, :pop!
+      end
+
+      state :delimited_inside_bracket do
+        rule /[^\[\]]+/, Str
+        rule /\[/, Str, :push
+        rule /\]/, Str, :pop!
+      end
+
+      state :delimited_parenthesis do
+        rule /[^()]+/, Str
+        rule /\(/, Str, :delimited_inside_parenthesis
+        rule /\)"/, Str, :pop!
+      end
+
+      state :delimited_inside_parenthesis do
+        rule /[^()]+/, Str
+        rule /\(/, Str, :push
+        rule /\)/, Str, :pop!
+      end
+
+      state :delimited_angle do
+        rule /[^<>]+/, Str
+        rule /</, Str, :delimited_inside_angle
+        rule />"/, Str, :pop!
+      end
+
+      state :delimited_inside_angle do
+        rule /[^<>]+/, Str
+        rule /</, Str, :push
+        rule />/, Str, :pop!
+      end
+
+      state :delimited_curly do
+        rule /[^{}]+/, Str
+        rule /\{/, Str, :delimited_inside_curly
+        rule /\}"/, Str, :pop!
+      end
+
+      state :delimited_inside_curly do
+        rule /[^{}]+/, Str
+        rule /\{/, Str, :push
+        rule /\}/, Str, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/dart.rb

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dart < RegexLexer
+      title "Dart"
+      desc "The Dart programming language (dartlang.com)"
+
+      tag 'dart'
+      filenames '*.dart'
+      mimetypes 'text/x-dart'
+
+      keywords = %w(
+        as assert break case catch continue default do else finally for
+        if in is new rethrow return super switch this throw try while with
+      )
+
+      declarations = %w(
+        abstract dynamic const external extends factory final get implements
+        native operator set static typedef var
+      )
+
+      types = %w(bool double Dynamic enum int num Object Set String void)
+
+      imports = %w(import export library part\s*of part source)
+
+      id = /[a-zA-Z_]\w*/
+
+      state :root do
+        rule %r(^
+          (\s*(?:[a-zA-Z_][a-zA-Z\d_.\[\]]*\s+)+?) # return arguments
+          ([a-zA-Z_][\w]*)                          # method name
+          (\s*)(\()                                 # signature start
+        )mx do |m|
+          # TODO: do this better, this shouldn't need a delegation
+          delegate Dart, m[1]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Punctuation, m[4]
+        end
+
+        rule /\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule /"/, Str, :dqs
+        rule /'/, Str, :sqs
+        rule /r"[^"]*"/, Str::Other
+        rule /r'[^']*'/, Str::Other
+        rule /##{id}*/i, Str::Symbol
+        rule /@#{id}/, Name::Decorator
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule /(?:#{types.join('|')})\b/, Keyword::Type
+        rule /(?:true|false|null)\b/, Keyword::Constant
+        rule /(?:class|interface)\b/, Keyword::Declaration, :class
+        rule /(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
+        rule /(\.)(#{id})/ do
+          groups Operator, Name::Attribute
+        end
+
+        rule /#{id}:/, Name::Label
+        rule /\$?#{id}/, Name
+        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule /\d*\.\d+([eE]\-?\d+)?/, Num::Float
+        rule /0x[\da-fA-F]+/, Num::Hex
+        rule /\d+L?/, Num::Integer
+        rule /\n/, Text
+      end
+
+      state :class do
+        rule /\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :dqs do
+        rule /"/, Str, :pop!
+        rule /[^\\\$"]+/, Str
+        mixin :string
+      end
+
+      state :sqs do
+        rule /'/, Str, :pop!
+        rule /[^\\\$']+/, Str
+        mixin :string
+      end
+
+      state :import do
+        rule /;/, Operator, :pop!
+        rule /(?:show|hide)\b/, Keyword::Declaration
+        mixin :root
+      end
+
+      state :string do
+        mixin :interpolation
+        rule /\\[nrt\"\'\\]/, Str::Escape
+      end
+
+      state :interpolation do
+        rule /\$#{id}/, Str::Interpol
+        rule /\$\{[^\}]+\}/, Str::Interpol
+      end
+    end
+  end
+end

data/lib/rouge/lexers/diff.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Diff < RegexLexer
+      title 'diff'
+      desc 'Lexes unified diffs or patches'
+
+      tag 'diff'
+      aliases 'patch', 'udiff'
+      filenames '*.diff', '*.patch'
+      mimetypes 'text/x-diff', 'text/x-patch'
+
+      def self.detect?(text)
+        return true if text.start_with?('Index: ')
+        return true if text =~ %r(\Adiff[^\n]*?\ba/[^\n]*\bb/)
+        return true if text =~ /(---|[+][+][+]).*?\n(---|[+][+][+])/
+      end
+
+      state :root do
+        rule(/^ .*$\n?/, Text)
+        rule(/^---$\n?/, Text)
+        rule(/^\+.*$\n?/, Generic::Inserted)
+        rule(/^-+.*$\n?/, Generic::Deleted)
+        rule(/^!.*$\n?/, Generic::Strong)
+        rule(/^@.*$\n?/, Generic::Subheading)
+        rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
+        rule(/^=.*$\n?/, Generic::Heading)
+        rule(/.*$\n?/, Text)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/digdag.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'set'
+module Rouge
+  module Lexers
+    load_lexer 'yaml.rb'
+
+    class Digdag < YAML
+      title 'digdag'
+      desc 'A simple, open source, multi-cloud workflow engine (https://www.digdag.io/)'
+      tag 'digdag'
+      filenames '*.dig'
+
+      mimetypes 'application/x-digdag'
+
+      # http://docs.digdag.io/operators.html
+      # as of digdag v0.9.10
+      KEYWORD_PATTERN = Regexp.union(%w(
+        call
+        require
+        loop
+        for_each
+        if
+        fail
+        echo
+
+        td
+        td_run
+        td_ddl
+        td_load
+        td_for_each
+        td_wait
+        td_wait_table
+        td_partial_delete
+        td_table_export
+
+        pg
+
+        mail
+        http
+        s3_wait
+        redshift
+        redshift_load
+        redshift_unload
+        emr
+
+        gcs_wait
+        bq
+        bq_ddl
+        bq_extract
+        bq_load
+
+        sh
+        py
+        rb
+        embulk
+      ).map { |name| "#{name}>"} + %w(
+        _do
+        _parallel
+      ))
+
+      prepend :block_nodes do
+        rule /(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
+          groups Keyword::Reserved, Punctuation::Indicator
+          set_indent m[0], :implicit => true
+        end
+      end
+    end
+  end
+end