rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/terraform.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'hcl.rb'
+
+    class Terraform < Hcl
+      title "Terraform"
+      desc "Terraform HCL Interpolations"
+
+      tag 'terraform'
+      aliases 'tf'
+      filenames '*.tf'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          terraform module provider variable resource data provisioner output
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          var local
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w()
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      def self.builtins
+        @builtins ||= %w()
+      end
+
+      prepend :hash do
+        rule %r/[.,()*]/, Punctuation
+      end
+
+      prepend :array do
+        rule %r/[.,()*]/, Punctuation
+      end
+
+      state :strings do
+        rule %r/\\./, Str::Escape
+        rule %r/\$\{/ do
+          token Keyword
+          push :interpolation
+        end
+      end
+
+      state :dq do
+        rule %r/[^\\"\$]+/, Str::Double
+        mixin :strings
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        rule %r/[^\\'\$]+/, Str::Single
+        mixin :strings
+        rule %r/'/, Str::Single, :pop!
+      end
+
+      state :heredoc do
+        rule %r/\n/, Str::Heredoc, :heredoc_nl
+        rule %r/[^$\n]+/, Str::Heredoc
+        rule %r/[$]/, Str::Heredoc
+        mixin :strings
+      end
+
+      state :interpolation do
+        rule %r/\}/ do
+          token Keyword
+          pop!
+        end
+
+        mixin :expression
+      end
+
+      state :regexps do
+        rule %r/"\// do
+          token Str::Delimiter
+          goto :regexp_inner
+        end
+      end
+
+      state :regexp_inner do
+        rule %r/[^"\/\\]+/, Str::Regex
+        rule %r/\\./, Str::Regex
+        rule %r/\/"/, Str::Delimiter, :pop!
+        rule %r/["\/]/, Str::Regex
+      end
+
+      id = /[$a-z_\-][a-z0-9_\-]*/io
+
+      state :expression do
+        mixin :regexps
+        mixin :primitives
+        rule %r/\s+/, Text
+
+        rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | == | != )x, Operator
+        rule %r([-<>+*%&|\^/!=?:]=?), Operator
+        rule %r/[(\[,]/, Punctuation
+        rule %r/[)\].]/, Punctuation
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/tex.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -18,50 +19,50 @@ module Rouge
       command = /\\([a-z]+|\s+|.)/i
 
       state :general do
-        rule /%.*$/, Comment
-        rule /[{}&_^]/, Punctuation
+        rule %r/%.*$/, Comment
+        rule %r/[{}&_^]/, Punctuation
       end
 
       state :root do
-        rule /\\\[/, Punctuation, :displaymath
-        rule /\\\(/, Punctuation, :inlinemath
-        rule /\$\$/, Punctuation, :displaymath
-        rule /\$/, Punctuation, :inlinemath
-        rule /\\(begin|end)\{.*?\}/, Name::Tag
+        rule %r/\\\[/, Punctuation, :displaymath
+        rule %r/\\\(/, Punctuation, :inlinemath
+        rule %r/\$\$/, Punctuation, :displaymath
+        rule %r/\$/, Punctuation, :inlinemath
+        rule %r/\\(begin|end)\{.*?\}/, Name::Tag
 
-        rule /(\\verb)\b(\S)(.*?)(\2)/ do |m|
+        rule %r/(\\verb)\b(\S)(.*?)(\2)/ do
           groups Name::Builtin, Keyword::Pseudo, Str::Other, Keyword::Pseudo
         end
 
         rule command, Keyword, :command
         mixin :general
-        rule /[^\\$%&_^{}]+/, Text
+        rule %r/[^\\$%&_^{}]+/, Text
       end
 
       state :math do
         rule command, Name::Variable
         mixin :general
-        rule /[0-9]+/, Num
-        rule /[-=!+*\/()\[\]]/, Operator
-        rule /[^=!+*\/()\[\]\\$%&_^{}0-9-]+/, Name::Builtin
+        rule %r/[0-9]+/, Num
+        rule %r/[-=!+*\/()\[\]]/, Operator
+        rule %r/[^=!+*\/()\[\]\\$%&_^{}0-9-]+/, Name::Builtin
       end
 
       state :inlinemath do
-        rule /\\\)/, Punctuation, :pop!
-        rule /\$/, Punctuation, :pop!
+        rule %r/\\\)/, Punctuation, :pop!
+        rule %r/\$/, Punctuation, :pop!
         mixin :math
       end
 
       state :displaymath do
-        rule /\\\]/, Punctuation, :pop!
-        rule /\$\$/, Punctuation, :pop!
-        rule /\$/, Name::Builtin
+        rule %r/\\\]/, Punctuation, :pop!
+        rule %r/\$\$/, Punctuation, :pop!
+        rule %r/\$/, Name::Builtin
         mixin :math
       end
 
       state :command do
-        rule /\[.*?\]/, Name::Attribute
-        rule /\*/, Keyword
+        rule %r/\[.*?\]/, Name::Attribute
+        rule %r/\*/, Keyword
         rule(//) { pop! }
       end
     end

data/lib/rouge/lexers/toml.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -7,60 +8,98 @@ module Rouge
       desc 'the TOML configuration format (https://github.com/mojombo/toml)'
       tag 'toml'
 
-      filenames '*.toml'
+      filenames '*.toml', 'Pipfile'
       mimetypes 'text/x-toml'
 
-      identifier = /[\w.\S]+/
+      identifier = /\S+/
 
       state :basic do
-        rule /\s+/, Text
-        rule /#.*?$/, Comment
-        rule /(true|false)/, Keyword::Constant
-        rule /(?<!=)\s*\[[\w\d\S]+\]/, Name::Namespace
+        rule %r/\s+/, Text
+        rule %r/#.*?$/, Comment
+        rule %r/(true|false)/, Keyword::Constant
 
-        rule /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
+        rule %r/(\S+)(\s*)(=)(\s*)(\{)/ do |m|
+          groups Name::Namespace, Text, Operator, Text, Punctuation
+          push :inline
+        end
+
+        rule %r/(?<!=)\s*\[[\S]+\]/, Name::Namespace
+
+        rule %r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
 
-        rule /(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, Num::Float
-        rule /\d+[eE][+-]?[0-9]+j?/, Num::Float
-        rule /\-?\d+/, Num::Integer
+        rule %r/(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, Num::Float
+        rule %r/\d+[eE][+-]?[0-9]+j?/, Num::Float
+        rule %r/\-?\d+/, Num::Integer
       end
 
       state :root do
         mixin :basic
 
-        rule /(#{identifier})(\s*)(=)/ do
+        rule %r/(#{identifier})(\s*)(=)/ do
           groups Name::Property, Text, Punctuation
           push :value
         end
-
       end
 
       state :value do
-        rule /\n/, Text, :pop!
+        rule %r/\n/, Text, :pop!
         mixin :content
       end
 
       state :content do
         mixin :basic
-        rule /"/, Str, :dq
+        rule %r/"""/, Str, :mdq
+        rule %r/"/, Str, :dq
+        rule %r/'''/, Str, :msq
+        rule %r/'/, Str, :sq
         mixin :esc_str
-        rule /\,/, Punctuation
-        rule /\[/, Punctuation, :array
+        rule %r/\,/, Punctuation
+        rule %r/\[/, Punctuation, :array
       end
 
       state :dq do
-        rule /"/, Str, :pop!
+        rule %r/"/, Str, :pop!
+        rule %r/\n/, Error, :pop!
         mixin :esc_str
-        rule /[^\\"]+/, Str
+        rule %r/[^\\"\n]+/, Str
+      end
+
+      state :mdq do
+        rule %r/"""/, Str, :pop!
+        mixin :esc_str
+        rule %r/[^\\"]+/, Str
+        rule %r/"+/, Str
+      end
+
+      state :sq do
+        rule %r/'/, Str, :pop!
+        rule %r/\n/, Error, :pop!
+        rule %r/[^'\n]+/, Str
+      end
+
+      state :msq do
+        rule %r/'''/, Str, :pop!
+        rule %r/[^']+/, Str
+        rule %r/'+/, Str
       end
 
       state :esc_str do
-        rule /\\[0t\tn\n "\\ r]/, Str::Escape
+        rule %r/\\[0t\tn\n "\\r]/, Str::Escape
       end
 
       state :array do
         mixin :content
-        rule /\]/, Punctuation, :pop!
+        rule %r/\]/, Punctuation, :pop!
+      end
+
+      state :inline do
+        mixin :content
+
+        rule %r/(#{identifier})(\s*)(=)/ do
+          groups Name::Property, Text, Punctuation
+        end
+
+        rule %r/\}/, Punctuation, :pop!
       end
     end
   end

data/lib/rouge/lexers/tsx.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers

data/lib/rouge/lexers/ttcn3.rb

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class TTCN3 < RegexLexer
+      title "TTCN3"
+      desc "The TTCN3 programming language (ttcn-3.org)"
+
+      tag 'ttcn3'
+      filenames '*.ttcn', '*.ttcn3'
+      mimetypes 'text/x-ttcn3', 'text/x-ttcn'
+
+      def self.keywords
+        @keywords ||= %w(
+          module import group type port component signature external
+          execute const template function altstep testcase var timer if
+          else select case for while do label goto start stop return
+          break int2char int2unichar int2bit int2enum int2hex int2oct
+          int2str int2float float2int char2int char2oct unichar2int
+          unichar2oct bit2int bit2hex bit2oct bit2str hex2int hex2bit
+          hex2oct hex2str oct2int oct2bit oct2hex oct2str oct2char
+          oct2unichar str2int str2hex str2oct str2float enum2int
+          any2unistr lengthof sizeof ispresent ischosen isvalue isbound
+          istemplatekind regexp substr replace encvalue decvalue
+          encvalue_unichar decvalue_unichar encvalue_o decvalue_o
+          get_stringencoding remove_bom rnd hostid send receive
+          setverdict
+        )
+      end
+
+      def self.reserved
+        @reserved ||= %w(
+          all alt apply assert at configuration conjunct const control
+          delta deterministic disjunct duration fail finished fuzzy from
+          history implies inconc inv lazy mod mode notinv now omit
+          onentry onexit par pass prev realtime seq setstate static
+          stepsize stream timestamp until values wait
+        )
+      end
+
+      def self.types
+        @types ||= %w(
+          anytype address boolean bitstring charstring hexstring octetstring
+          component enumerated float integer port record set of union universal
+        )
+      end
+
+      # optional comment or whitespace
+      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+      id = /[a-zA-Z_]\w*/
+      digit = /\d_+\d|\d/
+      bin_digit = /[01]_+[01]|[01]/
+      oct_digit = /[0-7]_+[0-7]|[0-7]/
+      hex_digit = /\h_+\h|\h/
+
+      state :statements do
+        rule %r/\n+/m, Text
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
+
+        rule %r(//(\\.|.)*?$), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+
+        rule %r/"/, Str, :string
+        rule %r/'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
+        
+        rule %r/#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/i, Num::Float
+        rule %r/'#{bin_digit}+'B/i, Num::Bin
+        rule %r/'#{hex_digit}+'H/i, Num::Hex
+        rule %r/'#{oct_digit}+'O/i, Num::Oct
+        rule %r/#{digit}+/i, Num::Integer
+
+        rule %r([~!%^&*+:=\|?<>/-]), Operator
+        rule %r/[()\[\]{},.;:]/, Punctuation
+
+        rule %r/(?:true|false|null)\b/, Name::Builtin
+
+        rule id do |m|
+          name = m[0]
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.class.types.include? name
+            token Keyword::Type
+          elsif self.class.reserved.include? name
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+      end
+
+      state :root do
+        rule %r/module\b/, Keyword::Declaration, :module
+        rule %r/import\b/, Keyword::Namespace, :import
+
+        mixin :statements
+      end
+
+      state :string do
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\\n/, Str
+        rule %r/\\/, Str # stray backslash
+      end
+
+      state :module do
+        rule %r/\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r/\s+/m, Text
+        rule %r/[\w.]+\*?/, Name::Namespace, :pop!
+      end
+    end
+  end
+end