rouge 3.2.0 → 3.18.0

data/lib/rouge/lexers/terraform.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -36,35 +37,43 @@ module Rouge
         @builtins ||= %w()
       end
 
+      prepend :hash do
+        rule %r/[.,()*]/, Punctuation
+      end
+
+      prepend :array do
+        rule %r/[.,()*]/, Punctuation
+      end
+
       state :strings do
-        rule /\\./, Str::Escape
-        rule /\$\{/ do
+        rule %r/\\./, Str::Escape
+        rule %r/\$\{/ do
           token Keyword
           push :interpolation
         end
       end
 
       state :dq do
-        rule /[^\\"\$]+/, Str::Double
+        rule %r/[^\\"\$]+/, Str::Double
         mixin :strings
-        rule /"/, Str::Double, :pop!
+        rule %r/"/, Str::Double, :pop!
       end
 
       state :sq do
-        rule /[^\\'\$]+/, Str::Single
+        rule %r/[^\\'\$]+/, Str::Single
         mixin :strings
-        rule /'/, Str::Single, :pop!
+        rule %r/'/, Str::Single, :pop!
       end
 
       state :heredoc do
-        rule /\n/, Str::Heredoc, :heredoc_nl
-        rule /[^$\n\$]+/, Str::Heredoc
-        rule /[$]/, Str::Heredoc
+        rule %r/\n/, Str::Heredoc, :heredoc_nl
+        rule %r/[^$\n]+/, Str::Heredoc
+        rule %r/[$]/, Str::Heredoc
         mixin :strings
       end
 
       state :interpolation do
-        rule /\}/ do
+        rule %r/\}/ do
           token Keyword
           pop!
         end
@@ -72,16 +81,31 @@ module Rouge
         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 /\s+/, Text
+        rule %r/\s+/, Text
 
         rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | == | != )x, Operator
         rule %r([-<>+*%&|\^/!=?:]=?), Operator
-        rule /[(\[,]/, Punctuation
-        rule /[)\].]/, Punctuation
+        rule %r/[(\[,]/, Punctuation
+        rule %r/[)\].]/, Punctuation
 
         rule id do |m|
           if self.class.keywords.include? m[0]

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

data/lib/rouge/lexers/tulip.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     class Tulip < RegexLexer
@@ -17,77 +19,77 @@ module Rouge
       upper_id = /[A-Z][\w-]*/
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
-        rule /#.*?$/, Comment
+        rule %r/\s+/, Text
+        rule %r/#.*?$/, Comment
       end
 
       state :root do
         mixin :comments_and_whitespace
 
-        rule /@#{id}/, Keyword
+        rule %r/@#{id}/, Keyword
 
 
-        rule /(\\#{id})([{])/ do
+        rule %r/(\\#{id})([{])/ do
           groups Name::Function, Str
           push :nested_string
         end
 
-        rule /([+]#{id})([{])/ do
+        rule %r/([+]#{id})([{])/ do
           groups Name::Decorator, Str
           push :nested_string
         end
 
-        rule /\\#{id}/, Name::Function
-        rule /[+]#{id}/, Name::Decorator
+        rule %r/\\#{id}/, Name::Function
+        rule %r/[+]#{id}/, Name::Decorator
 
-        rule /"[{]/, Str, :dqi
-        rule /"/, Str, :dq
+        rule %r/"[{]/, Str, :dqi
+        rule %r/"/, Str, :dq
 
-        rule /'{/, Str, :nested_string
-        rule /'#{id}/, Str
+        rule %r/'{/, Str, :nested_string
+        rule %r/'#{id}/, Str
 
-        rule /[.]#{id}/, Name::Tag
-        rule /[$]#{id}?/, Name::Variable
-        rule /-#{id}:?/, Name::Label
-        rule /%#{id}/, Name::Function
-        rule /`#{id}/, Operator::Word
+        rule %r/[.]#{id}/, Name::Tag
+        rule %r/[$]#{id}?/, Name::Variable
+        rule %r/-#{id}:?/, Name::Label
+        rule %r/%#{id}/, Name::Function
+        rule %r/`#{id}/, Operator::Word
 
-        rule /[?~%._>,!\[\]:{}()=;\/-]/, Punctuation
+        rule %r/[?~%._>,!\[\]:{}()=;\/-]/, Punctuation
 
-        rule /[0-9]+([.][0-9]+)?/, Num
+        rule %r/[0-9]+([.][0-9]+)?/, Num
 
-        rule /#{id}/, Name
+        rule %r/#{id}/, Name
 
-        rule /</, Comment::Preproc, :angle_brackets
+        rule %r/</, Comment::Preproc, :angle_brackets
       end
 
       state :dq do
-        rule /[^\\"]+/, Str
-        rule /"/, Str, :pop!
-        rule /\\./, Str::Escape
+        rule %r/[^\\"]+/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/\\./, Str::Escape
       end
 
       state :dqi do
-        rule /[$][(]/, Str::Interpol, :interp_root
-        rule /[{]/, Str, :dqi
-        rule /[}]/, Str, :pop!
-        rule /[^{}$]+/, Str
-        rule /./, Str
+        rule %r/[$][(]/, Str::Interpol, :interp_root
+        rule %r/[{]/, Str, :dqi
+        rule %r/[}]/, Str, :pop!
+        rule %r/[^{}$]+/, Str
+        rule %r/./, Str
       end
 
       state :interp_root do
-        rule /[)]/, Str::Interpol, :pop!
+        rule %r/[)]/, Str::Interpol, :pop!
         mixin :interp
       end
 
       state :interp do
-        rule /[(]/, Punctuation, :interp
-        rule /[)]/, Punctuation, :pop!
+        rule %r/[(]/, Punctuation, :interp
+        rule %r/[)]/, Punctuation, :pop!
         mixin :root
       end
 
       state :nested_string do
-        rule /\\./, Str::Escape
+        rule %r/\\./, Str::Escape
         rule(/{/) { token Str; push :nested_string }
         rule(/}/) { token Str; pop! }
         rule(/[^{}\\]+/) { token Str }
@@ -95,10 +97,10 @@ module Rouge
 
       state :angle_brackets do
         mixin :comments_and_whitespace
-        rule />/, Comment::Preproc, :pop!
-        rule /[*:]/, Punctuation
-        rule /#{upper_id}/, Keyword::Type
-        rule /#{id}/, Name::Variable
+        rule %r/>/, Comment::Preproc, :pop!
+        rule %r/[*:]/, Punctuation
+        rule %r/#{upper_id}/, Keyword::Type
+        rule %r/#{id}/, Name::Variable
       end
     end
   end