rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/q.rb

@@ -36,23 +36,23 @@ module Rouge
 
       state :root do
         # q allows a file to start with a shebang
-        rule /#!(.*?)$/, Comment::Preproc, :top
-        rule //, Text, :top
+        rule %r/#!(.*?)$/, Comment::Preproc, :top
+        rule %r//, Text, :top
       end
 
       state :top do
         # indented lines at the top of the file are ignored by q
-        rule /^[ \t\r]+.*$/, Comment::Special
-        rule /\n+/, Text
-        rule //, Text, :base
+        rule %r/^[ \t\r]+.*$/, Comment::Special
+        rule %r/\n+/, Text
+        rule %r//, Text, :base
       end
 
       state :base do
-        rule /\n+/m, Text
+        rule %r/\n+/m, Text
         rule(/^.\)/, Keyword::Declaration)
 
         # Identifiers, word operators, etc.
-        rule /#{identifier}/ do |m|
+        rule %r/#{identifier}/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
           elsif self.class.word_operators.include? m[0]
@@ -102,7 +102,7 @@ module Rouge
         rule(%r{(`:[:a-z0-9._\/]*|`(?:[a-z0-9.][:a-z0-9._]*)?)}i, Str::Symbol)
         rule(/(?:<=|>=|<>|::)|[?:$%&|@._#*^\-+~,!><=]:?/, Operator)
 
-        rule /[{}\[\]();]/, Punctuation
+        rule %r/[{}\[\]();]/, Punctuation
 
         # commands
         rule(/\\.*\n/, Text)
@@ -111,13 +111,13 @@ module Rouge
 
       state :string do
         rule(/"/, Str, :pop!)
-        rule /\\([\\nr]|[01][0-7]{2})/, Str::Escape
-        rule /[^\\"\n]+/, Str
-        rule /\\/, Str # stray backslash
+        rule %r/\\([\\nr]|[01][0-7]{2})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\/, Str # stray backslash
       end
 
       state :bottom do
-        rule /.*\z/m, Comment::Multiline
+        rule %r/.*\z/m, Comment::Multiline
       end
     end
   end

data/lib/rouge/lexers/qml.rb

@@ -17,57 +17,57 @@ module Rouge
       id_with_dots = /[$a-zA-Z_][a-zA-Z0-9_.]*/
 
       prepend :root do
-        rule /(#{id_with_dots})(\s*)({)/ do
+        rule %r/(#{id_with_dots})(\s*)({)/ do
           groups Keyword::Type, Text, Punctuation
           push :type_block
         end
-        rule /(#{id_with_dots})(\s+)(on)(\s+)(#{id_with_dots})(\s*)({)/ do
+        rule %r/(#{id_with_dots})(\s+)(on)(\s+)(#{id_with_dots})(\s*)({)/ do
           groups Keyword::Type, Text, Keyword, Text, Name::Label, Text, Punctuation
           push :type_block
         end
 
-        rule /[{]/, Punctuation, :push
+        rule %r/[{]/, Punctuation, :push
       end
 
       state :type_block do
-        rule /(id)(\s*)(:)(\s*)(#{id_with_dots})/ do
+        rule %r/(id)(\s*)(:)(\s*)(#{id_with_dots})/ do
           groups Name::Label, Text, Punctuation, Text, Keyword::Declaration
         end
 
-        rule /(#{id_with_dots})(\s*)(:)/ do
+        rule %r/(#{id_with_dots})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
           push :expr_start
         end
 
-        rule /(signal)(\s+)(#{id_with_dots})/ do
+        rule %r/(signal)(\s+)(#{id_with_dots})/ do
           groups Keyword::Declaration, Text, Name::Label
           push :signal
         end
 
-        rule /(property)(\s+)(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(:?)/ do
+        rule %r/(property)(\s+)(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(:?)/ do
           groups Keyword::Declaration, Text, Keyword::Type, Text, Name::Label, Text, Punctuation
           push :expr_start
         end
 
-        rule /[}]/, Punctuation, :pop!
+        rule %r/[}]/, Punctuation, :pop!
         mixin :root
       end
 
       state :signal do
         mixin :comments_and_whitespace
-        rule /\(/ do
+        rule %r/\(/ do
           token Punctuation
           goto :signal_args
         end
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :signal_args do
         mixin :comments_and_whitespace
-        rule /(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(,?)/ do
+        rule %r/(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(,?)/ do
           groups Keyword::Type, Text, Name, Text, Punctuation
         end
-        rule /\)/ , Punctuation, :pop!
+        rule %r/\)/ , Punctuation, :pop!
       end
     end
   end

data/lib/rouge/lexers/r.rb

@@ -49,27 +49,27 @@ module Rouge
       end
 
       state :root do
-        rule /#'.*?$/, Comment::Doc
-        rule /#.*?$/, Comment::Single
-        rule /\s+/m, Text::Whitespace
+        rule %r/#'.*?$/, Comment::Doc
+        rule %r/#.*?$/, Comment::Single
+        rule %r/\s+/m, Text::Whitespace
 
-        rule /`[^`]+?`/, Name
-        rule /'(\\.|.)*?'/m, Str::Single
-        rule /"(\\.|.)*?"/m, Str::Double
+        rule %r/`[^`]+?`/, Name
+        rule %r/'(\\.|.)*?'/m, Str::Single
+        rule %r/"(\\.|.)*?"/m, Str::Double
 
-        rule /%[^%]*?%/, Operator
+        rule %r/%[^%]*?%/, Operator
 
-        rule /0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?/, Num::Hex
-        rule /[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?[Li]?/,
+        rule %r/0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?/, Num::Hex
+        rule %r/[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?[Li]?/,
           Num
 
         # Only recognize built-in functions when they are actually used as a
         # function call, i.e. followed by an opening parenthesis.
         # `Name::Builtin` would be more logical, but is usually not
         # highlighted specifically; thus use `Name::Function`.
-        rule /\b(?<!.)(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
+        rule %r/\b(?<!.)(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
 
-        rule /[a-zA-Z.]([a-zA-Z_][\w.]*)?/ do |m|
+        rule %r/[a-zA-Z.]([a-zA-Z_][\w.]*)?/ do |m|
           if KEYWORDS.include? m[0]
             token Keyword
           elsif KEYWORD_CONSTANTS.include? m[0]
@@ -81,7 +81,7 @@ module Rouge
           end
         end
 
-        rule /[\[\]{}();,]/, Punctuation
+        rule %r/[\[\]{}();,]/, Punctuation
 
         rule %r([-<>?*+^/!=~$@:%&|]), Operator
       end

data/lib/rouge/lexers/racket.rb

@@ -487,39 +487,39 @@ module Rouge
 
       state :root do
         # comments
-        rule /;.*$/, Comment::Single
-        rule /\s+/m, Text
+        rule %r/;.*$/, Comment::Single
+        rule %r/\s+/m, Text
 
-        rule /[+-]inf[.][f0]/, Num::Float
-        rule /[+-]nan[.]0/, Num::Float
-        rule /[-]min[.]0/, Num::Float
-        rule /[+]max[.]0/, Num::Float
+        rule %r/[+-]inf[.][f0]/, Num::Float
+        rule %r/[+-]nan[.]0/, Num::Float
+        rule %r/[-]min[.]0/, Num::Float
+        rule %r/[+]max[.]0/, Num::Float
 
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+/, Num::Integer
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
 
-        rule /#:#{id}+/, Name::Tag  # keyword
+        rule %r/#:#{id}+/, Name::Tag  # keyword
 
-        rule /#b[01]+/, Num::Bin
-        rule /#o[0-7]+/, Num::Oct
-        rule /#d[0-9]+/, Num::Integer
-        rule /#x[0-9a-f]+/i, Num::Hex
-        rule /#[ei][\d.]+/, Num::Other
+        rule %r/#b[01]+/, Num::Bin
+        rule %r/#o[0-7]+/, Num::Oct
+        rule %r/#d[0-9]+/, Num::Integer
+        rule %r/#x[0-9a-f]+/i, Num::Hex
+        rule %r/#[ei][\d.]+/, Num::Other
 
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /['`]#{id}/i, Str::Symbol
-        rule /#\\([()\/'"._!\$%& ?=+-]{1}|[a-z0-9]+)/i,
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/['`]#{id}/i, Str::Symbol
+        rule %r/#\\([()\/'"._!\$%& ?=+-]{1}|[a-z0-9]+)/i,
           Str::Char
-        rule /#t|#f/, Name::Constant
-        rule /(?:'|#|`|,@|,|\.)/, Operator
+        rule %r/#t|#f/, Name::Constant
+        rule %r/(?:'|#|`|,@|,|\.)/, Operator
 
-        rule /(['#])(\s*)(\()/m do
+        rule %r/(['#])(\s*)(\()/m do
           groups Str::Symbol, Text, Punctuation
         end
 
         # () [] {} are all permitted as like pairs
-        rule /\(|\[|\{/, Punctuation, :command
-        rule /\)|\]|\}/, Punctuation
+        rule %r/\(|\[|\{/, Punctuation, :command
+        rule %r/\)|\]|\}/, Punctuation
 
         rule id, Name::Variable
       end

data/lib/rouge/lexers/ruby.rb

@@ -31,15 +31,15 @@ module Rouge
         rule %r(:(?:\*\*|[-+]@|[/\%&\|^`~]|\[\]=?|<<|>>|<=?>|<=?|===?)),
           Str::Symbol
 
-        rule /:'(\\\\|\\'|[^'])*'/, Str::Symbol
-        rule /:"/, Str::Symbol, :simple_sym
+        rule %r/:'(\\\\|\\'|[^'])*'/, Str::Symbol
+        rule %r/:"/, Str::Symbol, :simple_sym
       end
 
       state :sigil_strings do
         # %-sigiled strings
         # %(abc), %[abc], %<abc>, %.abc., %r.abc., etc
         delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
-        rule /%([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]
@@ -57,38 +57,40 @@ module Rouge
           token toktype
 
           push do
-            rule /\\[##{open}#{close}\\]/, Str::Escape
+            uniq_chars = "#{open}#{close}".squeeze
+            uniq_chars = '' if open == close && open == "\\#"
+            rule %r/\\[##{uniq_chars}\\]/, Str::Escape
             # nesting rules only with asymmetric delimiters
             if open != close
-              rule /#{open}/ do
+              rule %r/#{open}/ do
                 token toktype
                 push
               end
             end
-            rule /#{close}/, toktype, :pop!
+            rule %r/#{close}/, toktype, :pop!
 
             if interp
               mixin :string_intp_escaped
-              rule /#/, toktype
+              rule %r/#/, toktype
             else
-              rule /[\\#]/, toktype
+              rule %r/[\\#]/, toktype
             end
 
-            rule /[^##{open}#{close}\\]+/m, toktype
+            rule %r/[^##{uniq_chars}\\]+/m, toktype
           end
         end
       end
 
       state :strings do
         mixin :symbols
-        rule /\b[a-z_]\w*?[?!]?:\s+/, Str::Symbol, :expr_start
-        rule /'(\\\\|\\'|[^'])*'/, Str::Single
-        rule /"/, Str::Double, :simple_string
-        rule /(?<!\.)`/, Str::Backtick, :simple_backtick
+        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
       end
 
       state :regex_flags do
-        rule /[mixounse]*/, Str::Regex, :pop!
+        rule %r/[mixounse]*/, Str::Regex, :pop!
       end
 
       # double-quoted string and symbol
@@ -97,9 +99,9 @@ module Rouge
        [:backtick, Str::Backtick, '`']].each do |name, tok, fin|
         state :"simple_#{name}" do
           mixin :string_intp_escaped
-          rule /[^\\#{fin}#]+/m, tok
-          rule /[\\#]/, tok
-          rule /#{fin}/, tok, :pop!
+          rule %r/[^\\#{fin}#]+/m, tok
+          rule %r/[\\#]/, tok
+          rule %r/#{fin}/, tok, :pop!
         end
       end
 
@@ -151,38 +153,38 @@ module Rouge
 
       state :whitespace do
         mixin :inline_whitespace
-        rule /\n\s*/m, Text, :expr_start
-        rule /#.*$/, Comment::Single
+        rule %r/\n\s*/m, Text, :expr_start
+        rule %r/#.*$/, Comment::Single
 
         rule %r(=begin\b.*?\n=end\b)m, Comment::Multiline
       end
 
       state :inline_whitespace do
-        rule /[ \t\r]+/, Text
+        rule %r/[ \t\r]+/, Text
       end
 
       state :root do
         mixin :whitespace
-        rule /__END__/, Comment::Preproc, :end_part
+        rule %r/__END__/, Comment::Preproc, :end_part
 
-        rule /0_?[0-7]+(?:_[0-7]+)*/, Num::Oct
-        rule /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/, Num::Hex
-        rule /0b[01]+(?:_[01]+)*/, Num::Bin
-        rule /\d+\.\d+(e[\+\-]?\d+)?/, Num::Float
-        rule /[\d]+(?:_\d+)*/, Num::Integer
+        rule %r/0_?[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
 
         # names
-        rule /@@[a-z_]\w*/i, Name::Variable::Class
-        rule /@[a-z_]\w*/i, Name::Variable::Instance
-        rule /\$\w+/, Name::Variable::Global
+        rule %r/@@[a-z_]\w*/i, Name::Variable::Class
+        rule %r/@[a-z_]\w*/i, Name::Variable::Instance
+        rule %r/\$\w+/, Name::Variable::Global
         rule %r(\$[!@&`'+~=/\\,;.<>_*\$?:"]), Name::Variable::Global
-        rule /\$-[0adFiIlpvw]/, Name::Variable::Global
-        rule /::/, Operator
+        rule %r/\$-[0adFiIlpvw]/, Name::Variable::Global
+        rule %r/::/, Operator
 
         mixin :strings
 
-        rule /(?:#{keywords.join('|')})\b/, Keyword, :expr_start
-        rule /(?:#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo, :expr_start
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword, :expr_start
+        rule %r/(?:#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo, :expr_start
 
         rule %r(
           (module)
@@ -192,52 +194,52 @@ module Rouge
           groups Keyword, Text, Name::Namespace
         end
 
-        rule /(def\b)(\s*)/ do
+        rule %r/(def\b)(\s*)/ do
           groups Keyword, Text
           push :funcname
         end
 
-        rule /(class\b)(\s*)/ do
+        rule %r/(class\b)(\s*)/ do
           groups Keyword, Text
           push :classname
         end
 
-        rule /(?:#{builtins_q.join('|')})[?]/, Name::Builtin, :expr_start
-        rule /(?:#{builtins_b.join('|')})!/,  Name::Builtin, :expr_start
-        rule /(?<!\.)(?:#{builtins_g.join('|')})\b/,
+        rule %r/(?:#{builtins_q.join('|')})[?]/, Name::Builtin, :expr_start
+        rule %r/(?:#{builtins_b.join('|')})!/,  Name::Builtin, :expr_start
+        rule %r/(?<!\.)(?:#{builtins_g.join('|')})\b/,
           Name::Builtin, :method_call
 
         mixin :has_heredocs
 
         # `..` and `...` for ranges must have higher priority than `.`
         # Otherwise, they will be parsed as :method_call
-        rule /\.{2,3}/, Operator, :expr_start
+        rule %r/\.{2,3}/, Operator, :expr_start
 
-        rule /[A-Z][a-zA-Z0-9_]*/, Name::Constant, :method_call
-        rule /(\.|::)(\s*)([a-z_]\w*[!?]?|[*%&^`~+-\/\[<>=])/ do
+        rule %r/[A-Z][a-zA-Z0-9_]*/, Name::Constant, :method_call
+        rule %r/(\.|::)(\s*)([a-z_]\w*[!?]?|[*%&^`~+-\/\[<>=])/ do
           groups Punctuation, Text, Name::Function
           push :method_call
         end
 
-        rule /[a-zA-Z_]\w*[?!]/, Name, :expr_start
-        rule /[a-zA-Z_]\w*/, Name, :method_call
-        rule /\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\./,
+        rule %r/[a-zA-Z_]\w*[?!]/, Name, :expr_start
+        rule %r/[a-zA-Z_]\w*/, Name, :method_call
+        rule %r/\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\./,
           Operator, :expr_start
-        rule /[-+\/*%=<>&!^|~]=?/, Operator, :expr_start
+        rule %r/[-+\/*%=<>&!^|~]=?/, Operator, :expr_start
         rule(/[?]/) { token Punctuation; push :ternary; push :expr_start }
         rule %r<[\[({,:\\;/]>, Punctuation, :expr_start
         rule %r<[\])}]>, Punctuation
       end
 
       state :has_heredocs do
-        rule /(?<!\w)(<<[-~]?)(["`']?)([a-zA-Z_]\w*)(\2)/ do |m|
+        rule %r/(?<!\w)(<<[-~]?)(["`']?)([a-zA-Z_]\w*)(\2)/ do |m|
           token Operator, m[1]
           token Name::Constant, "#{m[2]}#{m[3]}#{m[4]}"
           @heredoc_queue << [['<<-', '<<~'].include?(m[1]), m[3]]
           push :heredoc_queue unless state? :heredoc_queue
         end
 
-        rule /(<<[-~]?)(["'])(\2)/ do |m|
+        rule %r/(<<[-~]?)(["'])(\2)/ do |m|
           token Operator, m[1]
           token Name::Constant, "#{m[2]}#{m[3]}#{m[4]}"
           @heredoc_queue << [['<<-', '<<~'].include?(m[1]), '']
@@ -246,7 +248,7 @@ module Rouge
       end
 
       state :heredoc_queue do
-        rule /(?=\n)/ do
+        rule %r/(?=\n)/ do
           goto :resolve_heredocs
         end
 
@@ -256,13 +258,13 @@ module Rouge
       state :resolve_heredocs do
         mixin :string_intp_escaped
 
-        rule /\n/, Str::Heredoc, :test_heredoc
-        rule /[#\\\n]/, Str::Heredoc
-        rule /[^#\\\n]+/, Str::Heredoc
+        rule %r/\n/, Str::Heredoc, :test_heredoc
+        rule %r/[#\\\n]/, Str::Heredoc
+        rule %r/[^#\\\n]+/, Str::Heredoc
       end
 
       state :test_heredoc do
-        rule /[^#\\\n]*$/ do |m|
+        rule %r/[^#\\\n]*$/ do |m|
           tolerant, heredoc_name = @heredoc_queue.first
           check = tolerant ? m[0].strip : m[0].rstrip
 
@@ -284,12 +286,12 @@ module Rouge
       end
 
       state :funcname do
-        rule /\s+/, Text
-        rule /\(/, Punctuation, :defexpr
+        rule %r/\s+/, Text
+        rule %r/\(/, Punctuation, :defexpr
         rule %r(
-          (?:([a-zA-Z_][\w_]*)(\.))?
+          (?:([a-zA-Z_]\w*)(\.))?
           (
-            [a-zA-Z_][\w_]*[!?]? |
+            [a-zA-Z_]\w*[!?]? |
             \*\*? | [-+]@? | [/%&\|^`~] | \[\]=? |
             <<? | >>? | <=>? | >= | ===?
           )
@@ -303,20 +305,20 @@ module Rouge
       end
 
       state :classname do
-        rule /\s+/, Text
-        rule /\(/ do
+        rule %r/\s+/, Text
+        rule %r/\(/ do
           token Punctuation
           push :defexpr
           push :expr_start
         end
 
         # class << expr
-        rule /<</ do
+        rule %r/<</ do
           token Operator
           goto :expr_start
         end
 
-        rule /[A-Z_]\w*/, Name::Class, :pop!
+        rule %r/[A-Z_]\w*/, Name::Class, :pop!
 
         rule(//) { pop! }
       end
@@ -328,11 +330,11 @@ module Rouge
       end
 
       state :defexpr do
-        rule /(\))(\.|::)?/ do
+        rule %r/(\))(\.|::)?/ do
           groups Punctuation, Operator
           pop!
         end
-        rule /\(/ do
+        rule %r/\(/ do
           token Punctuation
           push :defexpr
           push :expr_start
@@ -342,20 +344,20 @@ module Rouge
       end
 
       state :in_interp do
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
         mixin :root
       end
 
       state :string_intp do
-        rule /[#][{]/, Str::Interpol, :in_interp
-        rule /#(@@?|\$)[a-z_]\w*/i, Str::Interpol
+        rule %r/[#][{]/, Str::Interpol, :in_interp
+        rule %r/#(@@?|\$)[a-z_]\w*/i, Str::Interpol
       end
 
       state :string_intp_escaped do
         mixin :string_intp
-        rule /\\([\\abefnrstv#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})/,
+        rule %r/\\([\\abefnrstv#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})/,
           Str::Escape
-        rule /\\./, Str::Escape
+        rule %r/\\./, Str::Escape
       end
 
       state :method_call do
@@ -408,7 +410,7 @@ module Rouge
 
         # special case for using a single space.  Ruby demands that
         # these be in a single line, otherwise it would make no sense.
-        rule /(\s*)(%[rqswQWxiI]? \S* )/ do
+        rule %r/(\s*)(%[rqswQWxiI]? \S* )/ do
           groups Text, Str::Other
           pop!
         end
@@ -432,7 +434,7 @@ module Rouge
 
       state :end_part do
         # eat up the rest of the stream as Comment::Preproc
-        rule /.+/m, Comment::Preproc, :pop!
+        rule %r/.+/m, Comment::Preproc, :pop!
       end
     end
   end