rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/digdag.rb

@@ -60,7 +60,7 @@ module Rouge
       ))
 
       prepend :block_nodes do
-        rule /(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
+        rule %r/(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
           groups Keyword::Reserved, Punctuation::Indicator
           set_indent m[0], :implicit => true
         end

data/lib/rouge/lexers/docker.rb

@@ -18,32 +18,32 @@ module Rouge
       start { @shell = Shell.new(@options) }
 
       state :root do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /^(ONBUILD)(\s+)(#{KEYWORDS})(.*)/io do |m|
+        rule %r/^(ONBUILD)(\s+)(#{KEYWORDS})(.*)/io do |m|
           groups Keyword, Text::Whitespace, Keyword, Str
         end
 
-        rule /^(#{KEYWORDS})\b(.*)/io do |m|
+        rule %r/^(#{KEYWORDS})\b(.*)/io do |m|
           groups Keyword, Str
         end
 
-        rule /#.*?$/, Comment
+        rule %r/#.*?$/, Comment
 
-        rule /^(ONBUILD\s+)?RUN(\s+)/i do
+        rule %r/^(ONBUILD\s+)?RUN(\s+)/i do
           token Keyword
           push :run
           @shell.reset!
         end
 
-        rule /\w+/, Text
-        rule /[^\w]+/, Text
-        rule /./, Text
+        rule %r/\w+/, Text
+        rule %r/[^\w]+/, Text
+        rule %r/./, Text
       end
 
       state :run do
-        rule /\n/, Text, :pop!
-        rule /\\./m, Str::Escape
+        rule %r/\n/, Text, :pop!
+        rule %r/\\./m, Str::Escape
         rule(/(\\.|[^\n\\])+/) { delegate @shell }
       end
     end

data/lib/rouge/lexers/dot.rb

@@ -16,33 +16,33 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(#.*?\n), Comment::Single
         rule %r(//.*?\n), Comment::Single
         rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
       end
 
       state :html do
-        rule /[^<>]+/ do
+        rule %r/[^<>]+/ do
           delegate @html
         end
-        rule /<.+?>/m do
+        rule %r/<.+?>/m do
           delegate @html
         end
-        rule />/, Punctuation, :pop!
+        rule %r/>/, Punctuation, :pop!
       end
 
       state :ID do
-        rule /([a-zA-Z][a-zA-Z_0-9]*)(\s*)(=)/ do |m|
+        rule %r/([a-zA-Z][a-zA-Z_0-9]*)(\s*)(=)/ do |m|
           token Name, m[1]
           token Text, m[2]
           token Punctuation, m[3]
         end
-        rule /[a-zA-Z][a-zA-Z_0-9]*/, Name::Variable
-        rule /([0-9]+)?\.[0-9]+/, Num::Float
-        rule /[0-9]+/, Num::Integer
-        rule /"(\\"|[^"])*"/, Str::Double
-        rule /</ do
+        rule %r/[a-zA-Z][a-zA-Z_0-9]*/, Name::Variable
+        rule %r/([0-9]+)?\.[0-9]+/, Num::Float
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\"|[^"])*"/, Str::Double
+        rule %r/</ do
           token Punctuation
           @html.reset!
           push :html
@@ -52,16 +52,16 @@ module Rouge
       state :a_list do
         mixin :comments_and_whitespace
         mixin :ID
-        rule /[=;,]/, Punctuation
-        rule /\]/, Operator, :pop!
+        rule %r/[=;,]/, Punctuation
+        rule %r/\]/, Operator, :pop!
       end
 
       state :root do
         mixin :comments_and_whitespace
-        rule /\b(strict|graph|digraph|subgraph|node|edge)\b/i, Keyword
-        rule /[{};:=]/, Punctuation
-        rule /-[->]/, Operator
-        rule /\[/, Operator, :a_list
+        rule %r/\b(strict|graph|digraph|subgraph|node|edge)\b/i, Keyword
+        rule %r/[{};:=]/, Punctuation
+        rule %r/-[->]/, Operator
+        rule %r/\[/, Operator, :a_list
         mixin :ID
       end
     end

data/lib/rouge/lexers/eiffel.rb

@@ -27,37 +27,37 @@ module Rouge
       SimpleString = /(?:[^"%\b\f\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)+?/
 
       state :root do
-        rule /"\[/, Str::Other, :aligned_verbatim_string
-        rule /"\{/, Str::Other, :non_aligned_verbatim_string
-        rule /"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
-        rule /--.*/, Comment::Single
-        rule /'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
+        rule %r/"\[/, Str::Other, :aligned_verbatim_string
+        rule %r/"\{/, Str::Other, :non_aligned_verbatim_string
+        rule %r/"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
+        rule %r/--.*/, Comment::Single
+        rule %r/'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
 
-        rule /(?:#{LanguageKeywords.join('|')})\b/, Keyword
-        rule /(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
-        rule /(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
+        rule %r/(?:#{LanguageKeywords.join('|')})\b/, Keyword
+        rule %r/(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
+        rule %r/(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
 
-        rule  /\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
-        rule /\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
-        rule /\b0[bB][01](?:_*[01])*\b/, Num::Bin
-        rule /\d(?:_*\d)*/, Num::Integer
-        rule /(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
+        rule %r/\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
+        rule %r/\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
+        rule %r/\b0[bB][01](?:_*[01])*\b/, Num::Bin
+        rule %r/\d(?:_*\d)*/, Num::Integer
+        rule %r/(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
 
-        rule /:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
-        rule /\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
+        rule %r/:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
+        rule %r/\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
 
-        rule /[A-Z][\dA-Z_]*/, Name::Class
-        rule /[A-Za-z][\dA-Za-z_]*/, Name
-        rule /\s+/, Text
+        rule %r/[A-Z][\dA-Z_]*/, Name::Class
+        rule %r/[A-Za-z][\dA-Za-z_]*/, Name
+        rule %r/\s+/, Text
       end
 
       state :aligned_verbatim_string do
-        rule /]"/, Str::Other, :pop!
+        rule %r/]"/, Str::Other, :pop!
         rule SimpleString, Str::Other
       end
 
       state :non_aligned_verbatim_string do
-        rule /}"/, Str::Other, :pop!
+        rule %r/}"/, Str::Other, :pop!
         rule SimpleString, Str::Other
       end
     end

data/lib/rouge/lexers/elixir.rb

@@ -17,27 +17,27 @@ module Rouge
       mimetypes 'text/x-elixir', 'application/x-elixir'
 
       state :root do
-        rule /\s+/m, Text
-        rule /#.*$/, Comment::Single
+        rule %r/\s+/m, Text
+        rule %r/#.*$/, Comment::Single
         rule %r{\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|
              defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|
              defexception|defguardp?|defstruct|exit|raise|throw|after|rescue|catch|else)\b(?![?!])|
              (?<!\.)\b(do|\-\>)\b}x, Keyword
-        rule /\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, Keyword::Namespace
-        rule /(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
+        rule %r/\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, Keyword::Namespace
+        rule %r/(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
         rule %r{%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|
-             <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s\t])\?|
-             (?<=[\s\t])!+|&(&&?|(?!\d))|\|\||\^|\*|\+|\-|/|
+             <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s])\?|
+             (?<=[\s])!+|&(&&?|(?!\d))|\|\||\^|\*|\+|\-|/|
              \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.|~~~}x, Operator
         rule %r{(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|
              <=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|
              \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, Str::Symbol
-        rule /:"/, Str::Symbol, :interpoling_symbol
-        rule /\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
-        rule /\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
-        rule /[a-zA-Z_!][\w_]*[!\?]?/, Name
+        rule %r/:"/, Str::Symbol, :interpoling_symbol
+        rule %r/\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
+        rule %r/\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
+        rule %r/[a-zA-Z_!]\w*[!\?]?/, Name
         rule %r{::|[%(){};,/\|:\\\[\]]}, Punctuation
-        rule /@[a-zA-Z_]\w*|&\d/, Name::Variable
+        rule %r/@[a-zA-Z_]\w*|&\d/, Name::Variable
         rule %r{\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])
              (_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b}x, Num
 
@@ -46,37 +46,37 @@ module Rouge
       end
 
       state :strings do
-        rule /(%[A-Ba-z])?"""(?:.|\n)*?"""/, Str::Doc
-        rule /'''(?:.|\n)*?'''/, Str::Doc
-        rule /"/, Str::Doc, :dqs
-        rule /'.*?'/, Str::Single
+        rule %r/(%[A-Ba-z])?"""(?:.|\n)*?"""/, Str::Doc
+        rule %r/'''(?:.|\n)*?'''/, Str::Doc
+        rule %r/"/, Str::Doc, :dqs
+        rule %r/'.*?'/, Str::Single
         rule %r{(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b[^x0MC])|(\\[MC]-)+\w|[^\s\\])}, Str::Other
 
       end
 
       state :dqs do
-        rule /"/, Str::Double, :pop!
+        rule %r/"/, Str::Double, :pop!
         mixin :enddoublestr
       end
 
       state :interpoling do
-        rule /#\{/, Str::Interpol, :interpoling_string
+        rule %r/#\{/, Str::Interpol, :interpoling_string
       end
 
       state :interpoling_string do
-        rule /\}/, Str::Interpol, :pop!
+        rule %r/\}/, Str::Interpol, :pop!
         mixin :root
       end
 
       state :interpoling_symbol do
-        rule /"/, Str::Symbol, :pop!
+        rule %r/"/, Str::Symbol, :pop!
         mixin :interpoling
-        rule /[^#"]+/, Str::Symbol
+        rule %r/[^#"]+/, Str::Symbol
       end
 
       state :enddoublestr do
         mixin :interpoling
-        rule /[^#"]+/, Str::Double
+        rule %r/[^#"]+/, Str::Double
       end
 
       state :sigil_strings do
@@ -86,7 +86,7 @@ module Rouge
         delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
         # Match a-z for custom sigils too
         sigil_opens = Regexp.union(delimiter_map.keys + %w(| / ' "))
-        rule /~([A-Za-z])?(#{sigil_opens})/ do |m|
+        rule %r/~([A-Za-z])?(#{sigil_opens})/ do |m|
           open = Regexp.escape(m[2])
           close = Regexp.escape(delimiter_map[m[2]] || m[2])
           interp = /[SRCW]/ === m[1]
@@ -108,26 +108,27 @@ module Rouge
           token toktype
 
           push do
-            rule /#{close}/, toktype, :pop!
+            rule %r/#{close}/, toktype, :pop!
 
             if interp
               mixin :interpoling
-              rule /#/, toktype
+              rule %r/#/, toktype
             else
-              rule /[\\#]/, toktype
+              rule %r/[\\#]/, toktype
             end
 
-            rule /[^##{open}#{close}\\]+/m, toktype
+            uniq_chars = "#{open}#{close}".squeeze
+            rule %r/[^##{uniq_chars}\\]+/m, toktype
           end
         end
       end
 
       state :regex_flags do
-        rule /[fgimrsux]*/, Str::Regex, :pop!
+        rule %r/[fgimrsux]*/, Str::Regex, :pop!
       end
 
       state :list_flags do
-        rule /[csa]?/, Str::Other, :pop!
+        rule %r/[csa]?/, Str::Other, :pop!
       end
     end
   end

data/lib/rouge/lexers/elm.rb

@@ -23,66 +23,66 @@ module Rouge
 
       state :root do
         # Whitespaces
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         # Single line comments
-        rule /--.*/, Comment::Single
+        rule %r/--.*/, Comment::Single
         # Multiline comments
-        rule /{-/, Comment::Multiline, :multiline_comment
+        rule %r/{-/, Comment::Multiline, :multiline_comment
 
         # Keywords
-        rule /\b(#{keywords.join('|')})\b/, Keyword
+        rule %r/\b(#{keywords.join('|')})\b/, Keyword
 
         # Variable or a function
-        rule /[a-z][\w]*/, Name
+        rule %r/[a-z]\w*/, Name
         # Underscore is a name for a variable, when it won't be used later
-        rule /_/, Name
+        rule %r/_/, Name
         # Type
-        rule /[A-Z][\w]*/, Keyword::Type        
+        rule %r/[A-Z]\w*/, Keyword::Type
 
         # Two symbol operators: -> :: // .. && || ++ |> <| << >> == /= <= >=
-        rule /(->|::|\/\/|\.\.|&&|\|\||\+\+|\|>|<\||>>|<<|==|\/=|<=|>=)/, Operator
+        rule %r/(->|::|\/\/|\.\.|&&|\|\||\+\+|\|>|<\||>>|<<|==|\/=|<=|>=)/, Operator
         # One symbol operators: + - / * % = < > ^ | !
-        rule /[+-\/*%=<>^\|!]/, Operator
+        rule %r/[+-\/*%=<>^\|!]/, Operator
         # Lambda operator
-        rule /\\/, Operator
+        rule %r/\\/, Operator
         # Not standard Elm operators, but these symbols can be used for custom inflix operators. We need to highlight them as operators as well.
-        rule /[@\#$&~?]/, Operator
+        rule %r/[@\#$&~?]/, Operator
 
         # Single, double quotes, and triple double quotes
-        rule /"""/, Str, :multiline_string
-        rule /'(\\.|.)'/, Str::Char        
-        rule /"/, Str, :double_quote
+        rule %r/"""/, Str, :multiline_string
+        rule %r/'(\\.|.)'/, Str::Char        
+        rule %r/"/, Str, :double_quote
 
         # Numbers
-        rule /0x[\da-f]+/i, Num::Hex
-        rule /\d+e[+-]?\d+/i, Num::Float
-        rule /\d+\.\d+(e[+-]?\d+)?/i, Num::Float
-        rule /\d+/, Num::Integer
+        rule %r/0x[\da-f]+/i, Num::Hex
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/\d+\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule %r/\d+/, Num::Integer
 
         # Punctuation: [ ] ( ) , ; ` { } :
-        rule /[\[\](),;`{}:]/, Punctuation
+        rule %r/[\[\](),;`{}:]/, Punctuation
       end
 
       # Multiline and nested commenting
       state :multiline_comment do
-        rule /-}/, Comment::Multiline, :pop!
-        rule /{-/, Comment::Multiline, :multiline_comment
-        rule /[^-{}]+/, Comment::Multiline
-        rule /[-{}]/, Comment::Multiline
+        rule %r/-}/, Comment::Multiline, :pop!
+        rule %r/{-/, Comment::Multiline, :multiline_comment
+        rule %r/[^-{}]+/, Comment::Multiline
+        rule %r/[-{}]/, Comment::Multiline
       end
 
       # Double quotes
       state :double_quote do
-        rule /[^\\"]+/, Str::Double
-        rule /\\"/, Str::Escape
-        rule /"/, Str::Double, :pop!
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/\\"/, Str::Escape
+        rule %r/"/, Str::Double, :pop!
       end
 
       # Multiple line string with tripple double quotes, e.g. """ multi """
       state :multiline_string do
-        rule /\s*"""/, Str, :pop!
-        rule /.*/, Str
-        rule /\s*/, Str
+        rule %r/\s*"""/, Str, :pop!
+        rule %r/.*/, Str
+        rule %r/\s*/, Str
       end
 
     end

data/lib/rouge/lexers/erb.rb

@@ -27,24 +27,24 @@ module Rouge
       close = /%%>|-%>|%>/
 
       state :root do
-        rule /<%#/, Comment, :comment
+        rule %r/<%#/, Comment, :comment
 
         rule open, Comment::Preproc, :ruby
 
-        rule /.+?(?=#{open})|.+/m do
+        rule %r/.+?(?=#{open})|.+/m do
           delegate parent
         end
       end
 
       state :comment do
         rule close, Comment, :pop!
-        rule /.+?(?=#{close})|.+/m, Comment
+        rule %r/.+?(?=#{close})|.+/m, Comment
       end
 
       state :ruby do
         rule close, Comment::Preproc, :pop!
 
-        rule /.+?(?=#{close})|.+/m do
+        rule %r/.+?(?=#{close})|.+/m do
           delegate @ruby_lexer
         end
       end

data/lib/rouge/lexers/factor.rb

@@ -167,35 +167,35 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
 
-        rule /(:|::|MACRO:|MEMO:|GENERIC:|HELP:)(\s+)(\S+)/m do
+        rule %r/(:|::|MACRO:|MEMO:|GENERIC:|HELP:)(\s+)(\S+)/m do
           groups Keyword, Text, Name::Function
         end
 
-        rule /(M:|HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)/m do
+        rule %r/(M:|HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)/m do
           groups Keyword, Text, Name::Class, Text, Name::Function
         end
 
-        rule /\((?=\s)/, Name::Function, :stack_effect
-        rule /;(?=\s)/, Keyword
+        rule %r/\((?=\s)/, Name::Function, :stack_effect
+        rule %r/;(?=\s)/, Keyword
 
-        rule /(USING:)((?:\s|\\\s)+)/m do
+        rule %r/(USING:)((?:\s|\\\s)+)/m do
           groups Keyword::Namespace, Text
           push :import
         end
 
-        rule /(IN:|USE:|UNUSE:|QUALIFIED:|QUALIFIED-WITH:)(\s+)(\S+)/m do
+        rule %r/(IN:|USE:|UNUSE:|QUALIFIED:|QUALIFIED-WITH:)(\s+)(\S+)/m do
           groups Keyword::Namespace, Text, Name::Namespace
         end
 
-        rule /(FROM:|EXCLUDE:)(\s+)(\S+)(\s+)(=>)/m do
+        rule %r/(FROM:|EXCLUDE:)(\s+)(\S+)(\s+)(=>)/m do
           groups Keyword::Namespace, Text, Name::Namespace, Text, Punctuation
         end
 
-        rule /(?:ALIAS|DEFER|FORGET|POSTPONE):/, Keyword::Namespace
+        rule %r/(?:ALIAS|DEFER|FORGET|POSTPONE):/, Keyword::Namespace
 
-        rule /(TUPLE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
+        rule %r/(TUPLE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
           groups(
             Keyword, Text,
             Name::Class, Text,
@@ -205,16 +205,16 @@ module Rouge
           push :slots
         end
 
-        rule /(TUPLE:)(\s+)(\S+)/m do
+        rule %r/(TUPLE:)(\s+)(\S+)/m do
           groups Keyword, Text, Name::Class
           push :slots
         end
 
-        rule /(UNION:|INTERSECTION:)(\s+)(\S+)/m do
+        rule %r/(UNION:|INTERSECTION:)(\s+)(\S+)/m do
           groups Keyword, Text, Name::Class
         end
 
-        rule /(PREDICATE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
+        rule %r/(PREDICATE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
           groups(
             Keyword, Text,
             Name::Class, Text,
@@ -223,7 +223,7 @@ module Rouge
           )
         end
 
-        rule /(C:)(\s+)(\S+)(\s+)(\S+)/m do
+        rule %r/(C:)(\s+)(\S+)(\s+)(\S+)/m do
           groups(
             Keyword, Text,
             Name::Function, Text,
@@ -236,38 +236,38 @@ module Rouge
            |ALIEN|TYPEDEF|FUNCTION|STRUCT):
         )x, Keyword
 
-        rule /(?:<PRIVATE|PRIVATE>)/, Keyword::Namespace
+        rule %r/(?:<PRIVATE|PRIVATE>)/, Keyword::Namespace
 
-        rule /(MAIN:)(\s+)(\S+)/ do
+        rule %r/(MAIN:)(\s+)(\S+)/ do
           groups Keyword::Namespace, Text, Name::Function
         end
 
         # strings
-        rule /"""\s+.*?\s+"""/, Str
-        rule /"(\\.|[^\\])*?"/, Str
-        rule /(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, Str::Char
+        rule %r/"""\s+.*?\s+"""/, Str
+        rule %r/"(\\.|[^\\])*?"/, Str
+        rule %r/(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, Str::Char
 
         # comments
-        rule /!\s+.*$/, Comment
-        rule /#!\s+.*$/, Comment
+        rule %r/!\s+.*$/, Comment
+        rule %r/#!\s+.*$/, Comment
 
         # booleans
-        rule /[tf](?=\s)/, Name::Constant
+        rule %r/[tf](?=\s)/, Name::Constant
 
         # numbers
-        rule /-?\d+\.\d+(?=\s)/, Num::Float
-        rule /-?\d+(?=\s)/, Num::Integer
+        rule %r/-?\d+\.\d+(?=\s)/, Num::Float
+        rule %r/-?\d+(?=\s)/, Num::Integer
 
-        rule /HEX:\s+[a-fA-F\d]+(?=\s)/m, Num::Hex
-        rule /BIN:\s+[01]+(?=\s)/, Num::Bin
-        rule /OCT:\s+[0-7]+(?=\s)/, Num::Oct
+        rule %r/HEX:\s+[a-fA-F\d]+(?=\s)/m, Num::Hex
+        rule %r/BIN:\s+[01]+(?=\s)/, Num::Bin
+        rule %r/OCT:\s+[0-7]+(?=\s)/, Num::Oct
 
         rule %r([-+/*=<>^](?=\s)), Operator
 
-        rule /(?:deprecated|final|foldable|flushable|inline|recursive)(?=\s)/,
+        rule %r/(?:deprecated|final|foldable|flushable|inline|recursive)(?=\s)/,
           Keyword
 
-        rule /\S+/ do |m|
+        rule %r/\S+/ do |m|
           name = m[0]
 
           if self.class.builtins.values.any? { |b| b.include? name }
@@ -279,24 +279,24 @@ module Rouge
       end
 
       state :stack_effect do
-        rule /\s+/, Text
-        rule /\(/, Name::Function, :stack_effect
-        rule /\)/, Name::Function, :pop!
+        rule %r/\s+/, Text
+        rule %r/\(/, Name::Function, :stack_effect
+        rule %r/\)/, Name::Function, :pop!
 
-        rule /--/, Name::Function
-        rule /\S+/, Name::Variable
+        rule %r/--/, Name::Function
+        rule %r/\S+/, Name::Variable
       end
 
       state :slots do
-        rule /\s+/, Text
-        rule /;(?=\s)/, Keyword, :pop!
-        rule /\S+/, Name::Variable
+        rule %r/\s+/, Text
+        rule %r/;(?=\s)/, Keyword, :pop!
+        rule %r/\S+/, Name::Variable
       end
 
       state :import do
-        rule /;(?=\s)/, Keyword, :pop!
-        rule /\s+/, Text
-        rule /\S+/, Name::Namespace
+        rule %r/;(?=\s)/, Keyword, :pop!
+        rule %r/\s+/, Text
+        rule %r/\S+/, Name::Namespace
       end
     end
   end