rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/terraform.rb

@@ -38,34 +38,34 @@ module Rouge
       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
@@ -77,12 +77,12 @@ module Rouge
 
       state :expression do
         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

@@ -19,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 |m|
           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

@@ -11,25 +11,25 @@ module Rouge
       filenames '*.toml'
       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 %r/(?<!=)\s*\[[\S]+\]/, Name::Namespace
 
-        rule /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
+        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
@@ -37,31 +37,31 @@ module Rouge
       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, :dq
         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!
         mixin :esc_str
-        rule /[^\\"]+/, 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
     end
   end

data/lib/rouge/lexers/tulip.rb

@@ -19,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 }
@@ -97,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

data/lib/rouge/lexers/turtle.rb

@@ -7,57 +7,54 @@ module Rouge
       title "Turtle/TriG"
       desc "Terse RDF Triple Language, TriG"
       tag 'turtle'
-      filenames *%w(*.ttl *.trig)
-      mimetypes *%w(
-        text/turtle
-        application/trig
-      )
+      filenames '*.ttl', '*.trig'
+      mimetypes 'text/turtle', 'application/trig'
 
       state :root do
-        rule /@base\b/, Keyword::Declaration
-        rule /@prefix\b/, Keyword::Declaration
-        rule /true\b/, Keyword::Constant
-        rule /false\b/, Keyword::Constant
+        rule %r/@base\b/, Keyword::Declaration
+        rule %r/@prefix\b/, Keyword::Declaration
+        rule %r/true\b/, Keyword::Constant
+        rule %r/false\b/, Keyword::Constant
 
-        rule /""".*?"""/m, Literal::String
-        rule /"([^"\\]|\\.)*"/, Literal::String
-        rule /'''.*?'''/m, Literal::String
-        rule /'([^'\\]|\\.)*'/, Literal::String
+        rule %r/""".*?"""/m, Literal::String
+        rule %r/"([^"\\]|\\.)*"/, Literal::String
+        rule %r/'''.*?'''/m, Literal::String
+        rule %r/'([^'\\]|\\.)*'/, Literal::String
 
-        rule /#.*$/, Comment::Single
+        rule %r/#.*$/, Comment::Single
 
-        rule /@[^\s,.; ]+/, Name::Attribute
+        rule %r/@[^\s,.;]+/, Name::Attribute
 
-        rule /[+-]?[0-9]+\.[0-9]*E[+-]?[0-9]+/, Literal::Number::Float
-        rule /[+-]?\.[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
-        rule /[+-]?[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?[0-9]+\.[0-9]*E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?\.[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
 
-        rule /[+-]?[0-9]*\.[0-9]+?/, Literal::Number::Float
+        rule %r/[+-]?[0-9]*\.[0-9]+?/, Literal::Number::Float
 
-        rule /[+-]?[0-9]+/, Literal::Number::Integer
+        rule %r/[+-]?[0-9]+/, Literal::Number::Integer
 
-        rule /\./, Punctuation
-        rule /,/, Punctuation
-        rule /;/, Punctuation
-        rule /\(/, Punctuation
-        rule /\)/, Punctuation
-        rule /\{/, Punctuation
-        rule /\}/, Punctuation
-        rule /\[/, Punctuation
-        rule /\]/, Punctuation
-        rule /\^\^/, Punctuation
+        rule %r/\./, Punctuation
+        rule %r/,/, Punctuation
+        rule %r/;/, Punctuation
+        rule %r/\(/, Punctuation
+        rule %r/\)/, Punctuation
+        rule %r/\{/, Punctuation
+        rule %r/\}/, Punctuation
+        rule %r/\[/, Punctuation
+        rule %r/\]/, Punctuation
+        rule %r/\^\^/, Punctuation
 
-        rule /<[^>]*>/, Name::Label
+        rule %r/<[^>]*>/, Name::Label
 
-        rule /base\b/i, Keyword::Declaration
-        rule /prefix\b/i, Keyword::Declaration
-        rule /GRAPH\b/, Keyword
-        rule /a\b/, Keyword
+        rule %r/base\b/i, Keyword::Declaration
+        rule %r/prefix\b/i, Keyword::Declaration
+        rule %r/GRAPH\b/, Keyword
+        rule %r/a\b/, Keyword
 
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
 
-        rule /[^:;<>#\@"\(\).\[\]\{\} ]+:/, Name::Namespace
-        rule /[^:;<>#\@"\(\).\[\]\{\} ]+/, Name
+        rule %r/[^:;<>#\@"\(\).\[\]\{\} ]+:/, Name::Namespace
+        rule %r/[^:;<>#\@"\(\).\[\]\{\} ]+/, Name
       end
     end
   end

data/lib/rouge/lexers/vala.rb

@@ -29,7 +29,7 @@ module Rouge
       )
 
       state :whitespace do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/[*].*?[*]/)m, Comment::Multiline
       end
@@ -37,30 +37,30 @@ module Rouge
       state :root do
         mixin :whitespace
 
-        rule /^\s*\[.*?\]/, Name::Attribute
+        rule %r/^\s*\[.*?\]/, Name::Attribute
 
-        rule /(<\[)\s*(#{id}:)?/, Keyword
-        rule /\]>/, Keyword
+        rule %r/(<\[)\s*(#{id}:)?/, Keyword
+        rule %r/\]>/, Keyword
 
-        rule /[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
-        rule /@"(\\.|.)*?"/, Str
-        rule /"(\\.|.)*?["\n]/, Str
-        rule /'(\\.|.)'/, Str::Char
-        rule /0x[0-9a-f]+[lu]?/i, Num
+        rule %r/[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule %r/@"(\\.|.)*?"/, Str
+        rule %r/"(\\.|.)*?["\n]/, Str
+        rule %r/'(\\.|.)'/, Str::Char
+        rule %r/0x[0-9a-f]+[lu]?/i, Num
         rule %r(
           [0-9]
           ([.][0-9]*)? # decimal
           (e[+-][0-9]+)? # exponent
           [fldu]? # type
         )ix, Num
-        rule /\b(#{keywords.join('|')})\b/, Keyword
-        rule /\b(#{keywords_type.join('|')})\b/, Keyword::Type
-        rule /class|struct/, Keyword, :class
-        rule /namespace|using/, Keyword, :namespace
-        rule /#{id}(?=\s*[(])/, Name::Function
+        rule %r/\b(#{keywords.join('|')})\b/, Keyword
+        rule %r/\b(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule %r/class|struct/, Keyword, :class
+        rule %r/namespace|using/, Keyword, :namespace
+        rule %r/#{id}(?=\s*[(])/, Name::Function
         rule id, Name
 
-        rule /#.*/, Comment::Preproc
+        rule %r/#.*/, Comment::Preproc
       end
 
       state :class do
@@ -70,8 +70,8 @@ module Rouge
 
       state :namespace do
         mixin :whitespace
-        rule /(?=[(])/, Text, :pop!
-        rule /(#{id}|[.])+/, Name::Namespace, :pop!
+        rule %r/(?=[(])/, Text, :pop!
+        rule %r/(#{id}|[.])+/, Name::Namespace, :pop!
       end
     end
   end