rouge 3.25.0 → 3.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35d2eb9627935d1f4e510d66263bddb55773667d8a441677019a377abaf3784e
-  data.tar.gz: 04370e4428e5f4c30a552d455bbf5655beeae8bf3ddc68db09ba0fbf76fee3e9
+  metadata.gz: a74c520254d1312e4a5343103e3d83b48c967025a77a01701c42820a5eb3c708
+  data.tar.gz: 2fb290b030a0d60910973c53398c0dd4b127d17c1b489c88105f0bddb3689f6e
 SHA512:
-  metadata.gz: fc847dd05c6d47cdbcc4296b60594faf8477b1c143e8f303c84a09bfbd88345baa5dbe19e4238ef6a37c79e59809616f649679070faf17f556838ce874cb95b9
-  data.tar.gz: 272f4948d1935e9e9c1eaae8e5230e5db42933dcf1e2130dad009d6d3e4c57fee656b4aead64d6933cadf836bd7d82287fbc8193032c1af7ebf21e53fc7fb403
+  metadata.gz: f499d28b76cd95fa2182d64809c4b6828c735a95c05c1b9af858ac6c1d0d17755fdafa90ae93f9d7fd27bd826fb4055cb8d3985d94b17172018ef408a397d8cf
+  data.tar.gz: 7fcd54cac21c2fb1b1cdc0825691ce812f42bc5d18cace205b281aaf87e7d8a75ee2dca544e92b9b193084605811f74151b00c51237850952cb22d4e4dde5db9

data/Gemfile

@@ -8,6 +8,7 @@ gem 'rake'
 
 gem 'minitest', '>= 5.0'
 gem 'minitest-power_assert'
+gem 'power_assert', '~> 1.2'
 
 gem 'parallel', '~> 1.13.0' if RUBY_VERSION < '2.2.0'
 gem 'rubocop', '~> 0.49.1'
@@ -36,5 +37,8 @@ group :development do
   else
     gem 'sinatra'
   end
+
+  # Ruby 3 no longer ships with a web server
+  gem 'puma' if RUBY_VERSION >= '3'
   gem 'shotgun'
 end

data/lib/rouge/demos/dafny

@@ -0,0 +1,16 @@
+module A {
+  const i: int := 56_78
+}
+
+method m(b: bool, s: string) {
+  var x: string;
+  var i: int;
+  if b then i := 1; else i := 2;
+  i := if b 1 else 2;
+  assert b;
+  assume b;
+  print s;
+  expect b;
+}
+
+function f(i: int): int { i + 1 }

data/lib/rouge/demos/fluent

@@ -0,0 +1,13 @@
+# Simple things are simple.
+hello-user = Hello, {$userName}!
+
+# Complex things are possible.
+shared-photos =
+    {$userName} {$photoCount ->
+        [one] added a new photo
+       *[other] added {$photoCount} new photos
+    } to {$userGender ->
+        [male] his stream
+        [female] her stream
+       *[other] their stream
+    }.

data/lib/rouge/demos/ocl

@@ -0,0 +1,4 @@
+context Compagnie::toEuros() : Collection(Real)
+body: self.employees->collect(each: Employee| each.salary/ 6.55957)
+-- OR
+body: self.employees->collect(salary) -> collect(x | x/6.55957)

data/lib/rouge/demos/rescript

@@ -0,0 +1,26 @@
+module Person = {
+  type t = Teacher | Director | Student(string)
+
+  let greeting = person =>
+    switch person {
+    | Teacher => "Hey Professor!"
+    | Director => "Hello Director."
+    | Student("Richard") => "Still here Ricky?"
+    | Student(other) => "Hey, " ++ other ++ "."
+    }
+}
+
+module Button = {
+  @react.component
+  let make = (~count: int, ~onClick) => {
+    let times = switch count {
+    | 1 => "once"
+    | 2 => "twice"
+    | n => Belt.Int.toString(n) ++ " times"
+    }
+
+    let msg = "Click me " ++ times
+
+    <button onClick> {msg->React.string} </button>
+  }
+}

data/lib/rouge/demos/stan

@@ -0,0 +1,13 @@
+data {
+  int<lower=0> N;
+  vector[N] x;
+  vector[N] y;
+}
+parameters {
+  real alpha;
+  real beta;
+  real<lower=0> sigma;
+}
+model {
+  y ~ normal(alpha + beta * x, sigma);
+}

data/lib/rouge/demos/stata

@@ -0,0 +1,14 @@
+* Run a series of linear regressions
+sysuse auto, clear
+foreach v of varlist mpg weight-turn {
+	regress price `v', robust
+}
+
+regress price i.foreign
+local num_obs = e(N)
+global myglobal = 4
+
+* Generate and manipulate variables
+generate newvar1 = "string"
+generate newvar2 = 34 - `num_obs'
+replace newvar2 = $myglobal

data/lib/rouge/formatter.rb

@@ -42,8 +42,8 @@ module Rouge
     end
 
     # Format a token stream.  Delegates to {#format}.
-    def self.format(tokens, *a, &b)
-      new(*a).format(tokens, &b)
+    def self.format(tokens, *args, **kwargs, &b)
+      new(*args, **kwargs).format(tokens, &b)
     end
 
     def initialize(opts={})

data/lib/rouge/lexers/c.rb

@@ -170,12 +170,22 @@ module Rouge
       end
 
       state :macro do
-        # NB: pop! goes back to :bol
-        rule %r/\n/, Comment::Preproc, :pop!
+        mixin :include
         rule %r([^/\n\\]+), Comment::Preproc
         rule %r/\\./m, Comment::Preproc
         mixin :inline_whitespace
         rule %r(/), Comment::Preproc
+        # NB: pop! goes back to :bol
+        rule %r/\n/, Comment::Preproc, :pop!
+      end
+
+      state :include do
+        rule %r/(include)(\s*)(<[^>]+>)([^\n]*)/ do
+          groups Comment::Preproc, Text, Comment::PreprocFile, Comment::Single
+        end
+        rule %r/(include)(\s*)("[^"]+")([^\n]*)/ do
+          groups Comment::Preproc, Text, Comment::PreprocFile, Comment::Single
+        end
       end
 
       state :if_0 do

data/lib/rouge/lexers/ceylon.rb

@@ -51,8 +51,8 @@ module Rouge
 
         rule %r("(\\\\|\\"|[^"])*"), Literal::String
         rule %r('\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'), Literal::String::Char
-        rule %r(".*``.*``.*"', String::Interpol
-        rule %r(\.)([a-z_]\w*)) do
+        rule %r("[^`]*``[^`]*``[^`]*"), Literal::String::Interpol
+        rule %r((\.)([a-z_]\w*)) do
           groups Operator, Name::Attribute
         end
         rule %r([a-zA-Z_]\w*:), Name::Label

data/lib/rouge/lexers/cmake.rb

@@ -22,6 +22,7 @@ module Rouge
       }
 
       BUILTIN_COMMANDS = Set.new %w[
+        add_compile_definitions
         add_compile_options
         add_custom_command
         add_custom_target
@@ -29,6 +30,7 @@ module Rouge
         add_dependencies
         add_executable
         add_library
+        add_link_options
         add_subdirectory
         add_test
         aux_source_directory
@@ -36,7 +38,9 @@ module Rouge
         build_command
         build_name
         cmake_host_system_information
+        cmake_language
         cmake_minimum_required
+        cmake_parse_arguments
         cmake_policy
         configure_file
         create_test_sourcelist
@@ -74,6 +78,7 @@ module Rouge
         include
         include_directories
         include_external_msproject
+        include_guard
         include_regular_expression
         install
         install_files
@@ -110,9 +115,14 @@ module Rouge
         subdir_depends
         subdirs
         target_compile_definitions
+        target_compile_features
         target_compile_options
         target_include_directories
+        target_link_directories
         target_link_libraries
+        target_link_options
+        target_precompile_headers
+        target_sources
         try_compile
         try_run
         unset

data/lib/rouge/lexers/console.rb

@@ -103,7 +103,7 @@ module Rouge
       end
 
       def line_regex
-        /(\\.|[^\\])*?(\n|$)/m
+        /(.*?)(\n|$)/
       end
 
       def output_lexer

data/lib/rouge/lexers/cpp.rb

@@ -22,12 +22,14 @@ module Rouge
 
       def self.keywords
         @keywords ||= super + Set.new(%w(
-          asm auto catch const_cast delete dynamic_cast explicit export friend
+          asm auto catch char8_t concept
+          consteval constexpr constinit const_cast co_await co_return co_yield
+          delete dynamic_cast explicit export friend
           mutable namespace new operator private protected public
-          reinterpret_cast restrict size_of static_cast this throw throws
+          reinterpret_cast requires restrict size_of static_cast this throw throws
           typeid typename using virtual final override
 
-          alignas alignof constexpr decltype noexcept static_assert
+          alignas alignof decltype noexcept static_assert
           thread_local try
         ))
       end
@@ -59,7 +61,7 @@ module Rouge
       prepend :statements do
         rule %r/(class|struct)\b/, Keyword, :classname
         rule %r/template\b/, Keyword, :template
-        rule %r/\d+(\.\d+)?(?:h|(?:min)|s|(?:ms)|(?:us)|(?:ns))/, Num::Other
+        rule %r/#{dq}(\.#{dq})?(?:y|d|h|(?:min)|s|(?:ms)|(?:us)|(?:ns)|i|(?:if)|(?:il))\b/, Num::Other
         rule %r((#{dq}[.]#{dq}?|[.]#{dq})(e[+-]?#{dq}[lu]*)?)i, Num::Float
         rule %r(#{dq}e[+-]?#{dq}[lu]*)i, Num::Float
         rule %r/0x\h('?\h)*[lu]*/i, Num::Hex
@@ -68,7 +70,7 @@ module Rouge
         rule %r/#{dq}[lu]*/i, Num::Integer
         rule %r/\bnullptr\b/, Name::Builtin
         rule %r/(?:u8|u|U|L)?R"([a-zA-Z0-9_{}\[\]#<>%:;.?*\+\-\/\^&|~!=,"']{,16})\(.*?\)\1"/m, Str
-        rule %r/::/, Operator
+        rule %r/(::|<=>)/, Operator
       end
 
       state :classname do

data/lib/rouge/lexers/crystal.rb

@@ -25,8 +25,7 @@ module Rouge
         )xi, Str::Symbol
 
         # special symbols
-        rule %r(:(?:\*\*|[-+]@|[/\%&\|^`~]|\[\]=?|<<|>>|<=?>|<=?|===?)),
-          Str::Symbol
+        rule %r(:(?:===|=?~|\[\][=?]?|\*\*=?|\/\/=?|[=^*/+-]=?|&[&*+-]?=?|\|\|?=?|![=~]?|%=?|<=>|<<?=?|>>?=?|\.\.\.?)), Str::Symbol
 
         rule %r/:'(\\\\|\\'|[^'])*'/, Str::Symbol
         rule %r/:"/, Str::Symbol, :simple_sym
@@ -36,7 +35,7 @@ module Rouge
         # %-sigiled strings
         # %(abc), %[abc], %<abc>, %.abc., %r.abc., etc
         delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
-        rule %r/%([rqswQWxiI])?([^\w\s])/ do |m|
+        rule %r/%([rqswQWxiI])?([^\w\s}])/ do |m|
           open = Regexp.escape(m[2])
           close = Regexp.escape(delimiter_map[m[2]] || m[2])
           interp = /[rQWxI]/ === m[1]
@@ -79,9 +78,11 @@ module Rouge
       state :strings do
         mixin :symbols
         rule %r/\b[a-z_]\w*?[?!]?:\s+/, Str::Symbol, :expr_start
-        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
         rule %r/"/, Str::Double, :simple_string
         rule %r/(?<!\.)`/, Str::Backtick, :simple_backtick
+        rule %r/(')(\\u[a-fA-F0-9]{4}|\\u\{[a-fA-F0-9]{1,6}\}|\\[abefnrtv])?(\\\\|\\'|[^'])*(')/ do
+          groups Str::Single, Str::Escape, Str::Single, Str::Single
+        end
       end
 
       state :regex_flags do
@@ -154,11 +155,13 @@ module Rouge
         mixin :whitespace
         rule %r/__END__/, Comment::Preproc, :end_part
 
-        rule %r/0_?[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule %r/0o[0-7]+(?:_[0-7]+)*/, Num::Oct
         rule %r/0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/, Num::Hex
         rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
-        rule %r/\d+\.\d+(e[\+\-]?\d+)?/, Num::Float
-        rule %r/[\d]+(?:_\d+)*/, Num::Integer
+        rule %r/\d+\.\d+(e[\+\-]?\d+)?(_f32)?/i, Num::Float
+        rule %r/\d+(e[\+\-]?\d+)/i, Num::Float
+        rule %r/\d+_f32/i, Num::Float
+        rule %r/[\d]+(?:_\d+)*(_[iu]\d+)?/, Num::Integer
 
         rule %r/@\[([^\]]+)\]/, Name::Decorator
 
@@ -183,7 +186,7 @@ module Rouge
           groups Keyword, Text, Name::Namespace
         end
 
-        rule %r/(def\b)(\s*)/ do
+        rule %r/(def|macro\b)(\s*)/ do
           groups Keyword, Text
           push :funcname
         end
@@ -212,8 +215,9 @@ module Rouge
 
         rule %r/[a-zA-Z_]\w*[?!]/, Name, :expr_start
         rule %r/[a-zA-Z_]\w*/, Name, :method_call
-        rule %r/\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\./,
+        rule %r/\*\*|\/\/|>=|<=|<=>|<<?|>>?|=~|={3}|!~|&&?|\|\||\./,
           Operator, :expr_start
+        rule %r/{%|%}/, Punctuation
         rule %r/[-+\/*%=<>&!^|~]=?/, Operator, :expr_start
         rule(/[?]/) { token Punctuation; push :ternary; push :expr_start }
         rule %r<[\[({,:\\;/]>, Punctuation, :expr_start
@@ -346,6 +350,7 @@ module Rouge
         mixin :string_intp
         rule %r/\\([\\abefnrstv#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})/,
           Str::Escape
+        rule %r/\\u([a-fA-F0-9]{4}|\{[^}]+\})/, Str::Escape
         rule %r/\\./, Str::Escape
       end
 

data/lib/rouge/lexers/cypher.rb

@@ -45,6 +45,7 @@ module Rouge
       state :root do
         rule %r/[\s]+/, Text
         rule %r(//.*?$), Comment::Single
+        rule %r(/\*), Comment::Multiline, :multiline_comments
 
         rule %r([*+\-<>=&|~%^]), Operator
         rule %r/[{}),;\[\]]/, Str::Symbol
@@ -103,6 +104,13 @@ module Rouge
         rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
         rule %r/`(\\\\|\\`|[^`])*`/, Str::Backtick
       end
+
+      state :multiline_comments do
+        rule %r(/[*]), Comment::Multiline, :multiline_comments
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^/*]+), Comment::Multiline
+        rule %r([/*]), Comment::Multiline
+      end
     end
   end
 end

data/lib/rouge/lexers/dafny.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dafny < RegexLexer
+      title "Dafny"
+      desc "The Dafny programming language (github.com/dafny-lang/dafny)"
+      tag "dafny"
+      filenames "*.dfy"
+      mimetypes "text/x-dafny"
+
+      keywords = %w(
+        abstract allocated assert assume
+        break by
+        calc case class codatatype const constructor
+        datatype decreases downto
+        else ensures exists expect export extends
+        false for forall fresh function
+        ghost greatest
+        if import include invariant iterator
+        label least lemma
+        match method modifies modify module
+        nameonly new newtype null
+        old opened
+        predicate print provides
+        reads refines requires return returns reveal reveals
+        static
+        then this to trait true twostate type
+        unchanged
+        var
+        while witness
+        yield yields
+      )
+
+      literals = %w{ true false null }
+
+      textOperators = %w{ as is in }
+
+      types = %w(bool char int real string nat
+                 array array? object object? ORDINAL
+                 seq set iset map imap multiset )
+
+      idstart = /[0-9a-zA-Z?]/
+      idchar = /[0-9a-zA-Z_'?]/
+      id = /#{idstart}#{idchar}*/
+
+      arrayType = /array(?:1[0-9]+|[2-9][0-9]*)\??(?!#{idchar})/
+      bvType = /bv(?:0|[1-9][0-9]*)(?!#{idchar})/
+
+      digit = /\d/
+      digits = /#{digit}+(?:_#{digit}+)*/
+      bin_digits = /[01]+(?:_[01]+)*/
+      hex_digit = /(?:[0-9a-fA-F])/
+      hex_digits = /#{hex_digit}+(?:_#{hex_digit}+)*/
+
+      cchar = /(?:[^\\'\n\r]|\\["'ntr\\0])/
+      schar = /(?:[^\\"\n\r]|\\["'ntr\\0])/
+      uchar = /(?:\\u#{hex_digit}{4})/
+
+      ## IMPORTANT: Rules are ordered, which allows later rules to be 
+      ## simpler than they would otherwise be
+      state :root do
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(//.*?$), Comment::Single
+        rule %r(\*/), Error          # should not have closing comment in :root
+                                     # is an improperly nested comment
+
+        rule %r/'#{cchar}'/, Str::Char           # standard or escape char
+        rule %r/'#{uchar}'/, Str::Char           # unicode char
+        rule %r/'[^'\n\r]*'/, Error              # bad any other enclosed char
+        rule %r/'[^'\n\r]*$/, Error              # bad unclosed char
+
+        rule %r/"(?:#{schar}|#{uchar})*"/, Str::Double        # valid string
+        rule %r/".*"/, Error                     # anything else that is closed
+        rule %r/".*$/, Error                     # bad unclosed string
+
+        rule %r/@"([^"]|"")*"/, Str::Other     # valid verbatim string
+        rule %r/@".*/m, Error             # anything else , multiline unclosed
+
+
+        rule %r/#{digits}\.#{digits}(?!#{idchar})/, Num::Float
+        rule %r/0b#{bin_digits}(?!#{idchar})/, Num::Bin
+        rule %r/0b#{idchar}*/, Error
+        rule %r/0x#{hex_digits}(?!#{idchar})/, Num::Hex
+        rule %r/0x#{idchar}*/, Error
+        rule %r/#{digits}(?!#{idchar})/, Num::Integer
+        rule %r/_(?!#{idchar})/, Name
+        rule %r/_[0-9_]+[_]?(?!#{idchar})/, Error
+        rule %r/[0-9_]+_(?!#{idchar})/, Error
+        rule %r/[0-9]#{idchar}+/, Error
+
+        rule %r/#{arrayType}/, Keyword::Type
+        rule %r/#{bvType}/, Keyword::Type
+
+        rule id do |m|
+          if types.include?(m[0])
+            token Keyword::Type
+          elsif literals.include?(m[0])
+            token Keyword::Constant
+          elsif textOperators.include?(m[0])
+            token Operator::Word
+          elsif keywords.include?(m[0])
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+
+        rule %r/\.\./, Operator
+        rule %r/[*!%&<>\|^+=:.\/-]/, Operator
+        rule %r/[\[\](){},;`]/, Punctuation
+
+        rule %r/[^\S\n]+/, Text
+        rule %r/\n/, Text
+        rule %r/./, Error # Catchall
+      end
+
+      state :comment do
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r([^*/]+), Comment::Multiline
+        rule %r(.), Comment::Multiline
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/dart.rb

@@ -5,25 +5,25 @@ module Rouge
   module Lexers
     class Dart < RegexLexer
       title "Dart"
-      desc "The Dart programming language (dartlang.com)"
+      desc "The Dart programming language (dart.dev)"
 
       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
+        as assert await break case catch continue default do else finally for
+        if in is new rethrow return super switch this throw try while with yield
       )
 
       declarations = %w(
-        abstract dynamic const external extends factory final get implements
-        native operator set static typedef var
+        abstract async dynamic const covariant external extends factory final get
+        implements late native on operator required set static sync typedef var
       )
 
-      types = %w(bool double Dynamic enum int num Object Set String void)
+      types = %w(bool Comparable double Dynamic enum Function int List Map Never Null num Object Pattern Set String Symbol Type Uri void)
 
-      imports = %w(import export library part\s*of part source)
+      imports = %w(import deferred export library part\s*of part source)
 
       id = /[a-zA-Z_]\w*/
 
@@ -53,7 +53,7 @@ module Rouge
         rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
         rule %r/(?:#{types.join('|')})\b/, Keyword::Type
         rule %r/(?:true|false|null)\b/, Keyword::Constant
-        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/(?:class|interface|mixin)\b/, Keyword::Declaration, :class
         rule %r/(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
         rule %r/(\.)(#{id})/ do
           groups Operator, Name::Attribute

data/lib/rouge/lexers/eex.rb

@@ -7,9 +7,9 @@ module Rouge
       desc "Embedded Elixir"
 
       tag 'eex'
-      aliases 'leex'
+      aliases 'leex', 'heex'
 
-      filenames '*.eex', '*.leex'
+      filenames '*.eex', '*.leex', '*.heex'
 
       def initialize(opts={})
         @elixir_lexer = Elixir.new(opts)

data/lib/rouge/lexers/factor.rb

@@ -243,8 +243,8 @@ module Rouge
         end
 
         # strings
-        rule %r/"""\s+.*?\s+"""/, Str
-        rule %r/"(\\.|[^\\])*?"/, Str
+        rule %r/"(?:\\\\|\\"|[^"])*"/, Str
+        rule %r/\S+"\s+(?:\\\\|\\"|[^"])*"/, Str
         rule %r/(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, Str::Char
 
         # comments

data/lib/rouge/lexers/fluent.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Fluent < RegexLexer
+      title 'Fluent'
+      desc 'Fluent localization files'
+      tag 'fluent'
+      aliases 'ftl'
+      filenames '*.ftl'
+
+      state :root do
+        rule %r{( *)(\=)( *)} do
+          groups Text::Whitespace, Punctuation, Text::Whitespace
+          push :template
+        end
+
+        rule %r{(?:\s*\n)+}m, Text::Whitespace
+        rule %r{\#{1,3}(?: .*)?$}, Comment::Single
+        rule %r{[a-zA-Z][a-zA-Z0-9_-]*}, Name::Constant
+        rule %r{\-[a-zA-Z][a-zA-Z0-9_-]*}, Name::Entity
+        rule %r{\s*\.[a-zA-Z][a-zA-Z0-9_-]*}, Name::Attribute
+        rule %r{\s+(?=[^\s\.])}, Text::Whitespace, :template
+      end
+
+      state :template do
+        rule %r{\n}m, Text::Whitespace, :pop!
+        rule %r{[^\{\n\}\*]+}, Text
+        rule %r{\{}, Punctuation, :placeable
+        rule %r{(?=\})}, Punctuation, :pop!
+      end
+
+      state :placeable do
+        rule %r{\s+}m, Text::Whitespace
+        rule %r{\{}, Punctuation, :placeable
+        rule %r{\}}, Punctuation, :pop!
+        rule %r{\$[a-zA-Z][a-zA-Z0-9_-]*}, Name::Variable
+        rule %r{\-[a-zA-Z][a-zA-Z0-9_-]*}, Name::Entity
+        rule %r{\.[a-zA-Z][a-zA-Z0-9_-]*}, Name::Attribute
+        rule %r{[A-Z]+}, Name::Builtin
+        rule %r{[a-zA-Z][a-zA-Z0-9_-]*}, Name::Constant
+        rule %r{[\(\),\:]}, Punctuation
+        rule %r{->}, Punctuation
+        rule %r{\*}, Punctuation::Indicator
+        rule %r{\-?\d+\.\d+?}, Literal::Number::Float
+        rule %r{\-?\d+}, Literal::Number::Integer
+        rule %r{"}, Str::Double, :string
+
+        rule %r{(\[)(\-?\d+\.\d+)(\])} do
+          groups Punctuation, Literal::Number::Float, Punctuation
+          push :template
+        end
+
+        rule %r{(\[)(\-?\d+)(\])} do
+          groups Punctuation, Literal::Number::Integer, Punctuation
+          push :template
+        end
+
+        rule %r{(\[)([a-zA-Z][a-zA-Z0-9_-]+)(\])} do
+          groups Punctuation, Str::Symbol, Punctuation
+          push :template
+        end
+      end
+
+      state :string do
+        rule %r{\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{6}}, Str::Escape
+        rule %r{\\.}, Str::Escape
+        rule %r{[^\"\\]}, Str::Double
+        rule %r{"}, Str::Double, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/ghc_core.rb

@@ -17,7 +17,7 @@ module Rouge
         rule %r/^=====.*=====$/, Generic::Heading
         # timestamps
         rule %r/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ UTC$/, Comment::Single
-        rule %r/^Result size of .+\s*.*}/, Comment::Multiline
+        rule %r/^Result size of .+\n.+{[^}]*}/, Comment::Multiline
         rule %r/--.*$/, Comment::Single
 
         rule %r/\[/, Comment::Special, :annotation

data/lib/rouge/lexers/hcl.rb

@@ -5,6 +5,7 @@ module Rouge
   module Lexers
     class Hcl < RegexLexer
       tag 'hcl'
+      filenames '*.hcl', '*.nomad'
 
       title 'Hashicorp Configuration Language'
       desc 'Hashicorp Configuration Language, used by Terraform and other Hashicorp tools'