rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/ini.rb

@@ -15,39 +15,39 @@ module Rouge
       identifier = /[\w\-.]+/
 
       state :basic do
-        rule /[;#].*?\n/, Comment
-        rule /\s+/, Text
-        rule /\\\n/, Str::Escape
+        rule %r/[;#].*?\n/, Comment
+        rule %r/\s+/, Text
+        rule %r/\\\n/, Str::Escape
       end
 
       state :root do
         mixin :basic
 
-        rule /(#{identifier})(\s*)(=)/ do
+        rule %r/(#{identifier})(\s*)(=)/ do
           groups Name::Property, Text, Punctuation
           push :value
         end
 
-        rule /\[.*?\]/, Name::Namespace
+        rule %r/\[.*?\]/, Name::Namespace
       end
 
       state :value do
-        rule /\n/, Text, :pop!
+        rule %r/\n/, Text, :pop!
         mixin :basic
-        rule /"/, Str, :dq
-        rule /'.*?'/, Str
+        rule %r/"/, Str, :dq
+        rule %r/'.*?'/, Str
         mixin :esc_str
-        rule /[^\\\n]+/, Str
+        rule %r/[^\\\n]+/, Str
       end
 
       state :dq do
-        rule /"/, Str, :pop!
+        rule %r/"/, Str, :pop!
         mixin :esc_str
-        rule /[^\\"]+/m, Str
+        rule %r/[^\\"]+/m, Str
       end
 
       state :esc_str do
-        rule /\\./m, Str::Escape
+        rule %r/\\./m, Str::Escape
       end
     end
   end

data/lib/rouge/lexers/io.rb

@@ -26,22 +26,22 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule %r(//.*?\n), Comment::Single
         rule %r(#.*?\n), Comment::Single
         rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
         rule %r(/[+]), Comment::Multiline, :nested_comment
 
-        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
 
         rule %r(:?:=), Keyword
-        rule /[()]/, Punctuation
+        rule %r/[()]/, Punctuation
 
         rule %r([-=;,*+><!/|^.%&\[\]{}]), Operator
 
-        rule /[A-Z]\w*/, Name::Class
+        rule %r/[A-Z]\w*/, Name::Class
 
-        rule /[a-z_]\w*/ do |m|
+        rule %r/[a-z_]\w*/ do |m|
           name = m[0]
 
           if self.class.constants.include? name
@@ -54,9 +54,9 @@ module Rouge
         end
 
         rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, Num::Float
-        rule /\d+/, Num::Integer
+        rule %r/\d+/, Num::Integer
 
-        rule /@@?/, Keyword
+        rule %r/@@?/, Keyword
       end
 
       state :nested_comment do

data/lib/rouge/lexers/irb.rb

@@ -41,25 +41,25 @@ module Rouge
 
       state :has_irb_output do
         rule %r(=>), Punctuation, :pop!
-        rule /.+?(\n|$)/, Generic::Output
+        rule %r/.+?(\n|$)/, Generic::Output
       end
 
       state :irb_error do
-        rule /.+?(\n|$)/, Generic::Error
+        rule %r/.+?(\n|$)/, Generic::Error
         mixin :has_irb_output
       end
 
       state :stdout do
-        rule /\w+?(Error|Exception):.+?(\n|$)/, Generic::Error, :irb_error
+        rule %r/\w+?(Error|Exception):.+?(\n|$)/, Generic::Error, :irb_error
         mixin :has_irb_output
       end
 
       prepend :root do
-        rule /#</, Keyword::Type, :irb_object
+        rule %r/#</, Keyword::Type, :irb_object
       end
 
       state :irb_object do
-        rule />/, Keyword::Type, :pop!
+        rule %r/>/, Keyword::Type, :pop!
         mixin :root
       end
     end

data/lib/rouge/lexers/java.rb

@@ -28,12 +28,12 @@ module Rouge
       class_name = /[A-Z][a-zA-Z0-9]*\b/
 
       state :root do
-        rule /[^\S\n]+/, Text
+        rule %r/[^\S\n]+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/\*.*?\*/)m, Comment::Multiline
         # keywords: go before method names to avoid lexing "throw new XYZ"
         # as a method signature
-        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
 
         rule %r(
           (\s*(?:[a-zA-Z_][a-zA-Z0-9_.\[\]<>]*\s+)+?) # return arguments
@@ -47,45 +47,45 @@ module Rouge
           token Operator, m[4]
         end
 
-        rule /@#{id}/, Name::Decorator
-        rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
-        rule /(?:#{types.join('|')})\b/, Keyword::Type
-        rule /package\b/, Keyword::Namespace
-        rule /(?:true|false|null)\b/, Keyword::Constant
-        rule /(?:class|interface)\b/, Keyword::Declaration, :class
-        rule /import\b/, Keyword::Namespace, :import
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
-        rule /(\.)(#{id})/ do
+        rule %r/@#{id}/, Name::Decorator
+        rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule %r/(?:#{types.join('|')})\b/, Keyword::Type
+        rule %r/package\b/, Keyword::Namespace
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/import\b/, Keyword::Namespace, :import
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
+        rule %r/(\.)(#{id})/ do
           groups Operator, Name::Attribute
         end
 
-        rule /#{id}:/, Name::Label
+        rule %r/#{id}:/, Name::Label
         rule const_name, Name::Constant
         rule class_name, Name::Class
-        rule /\$?#{id}/, Name
-        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule %r/\$?#{id}/, Name
+        rule %r/[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
 
         digit = /[0-9]_+[0-9]|[0-9]/
         bin_digit = /[01]_+[01]|[01]/
         oct_digit = /[0-7]_+[0-7]|[0-7]/
         hex_digit = /[0-9a-f]_+[0-9a-f]|[0-9a-f]/i
-        rule /#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
-        rule /0b#{bin_digit}+/i, Num::Bin
-        rule /0x#{hex_digit}+/i, Num::Hex
-        rule /0#{oct_digit}+/, Num::Oct
-        rule /#{digit}+L?/, Num::Integer
-        rule /\n/, Text
+        rule %r/#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
+        rule %r/0b#{bin_digit}+/i, Num::Bin
+        rule %r/0x#{hex_digit}+/i, Num::Hex
+        rule %r/0#{oct_digit}+/, Num::Oct
+        rule %r/#{digit}+L?/, Num::Integer
+        rule %r/\n/, Text
       end
 
       state :class do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule id, Name::Class, :pop!
       end
 
       state :import do
-        rule /\s+/m, Text
-        rule /[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+        rule %r/\s+/m, Text
+        rule %r/[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
       end
     end
   end

data/lib/rouge/lexers/javascript.rb

@@ -32,8 +32,8 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
-        rule /<!--/, Comment # really...?
+        rule %r/\s+/, Text
+        rule %r/<!--/, Comment # really...?
         rule %r(//.*?$), Comment::Single
         rule %r(/[*]), Comment::Multiline, :multiline_comment
       end
@@ -46,12 +46,12 @@ module Rouge
           goto :regex
         end
 
-        rule /[{]/ do
+        rule %r/[{]/ do
           token Punctuation
           goto :object
         end
 
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :regex do
@@ -62,38 +62,38 @@ module Rouge
 
         rule %r([^/]\n), Error, :pop!
 
-        rule /\n/, Error, :pop!
-        rule /\[\^/, Str::Escape, :regex_group
-        rule /\[/, Str::Escape, :regex_group
-        rule /\\./, Str::Escape
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
         rule %r{[(][?][:=<!]}, Str::Escape
-        rule /[{][\d,]+[}]/, Str::Escape
-        rule /[()?]/, Str::Escape
-        rule /./, Str::Regex
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :regex_end do
-        rule /[gim]+/, Str::Regex, :pop!
+        rule %r/[gim]+/, Str::Regex, :pop!
         rule(//) { pop! }
       end
 
       state :regex_group do
         # specially highlight / in a group to indicate that it doesn't
         # close the regex
-        rule /\//, Str::Escape
+        rule %r(/), Str::Escape
 
         rule %r([^/]\n) do
           token Error
           pop! 2
         end
 
-        rule /\]/, Str::Escape, :pop!
-        rule /\\./, Str::Escape
-        rule /./, Str::Regex
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :bad_regex do
-        rule /[^\n]+/, Error, :pop!
+        rule %r/[^\n]+/, Error, :pop!
       end
 
       def self.keywords
@@ -144,34 +144,34 @@ module Rouge
       id = self.id_regex
 
       state :root do
-        rule /\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule %r/\A\s*#!.*?\n/m, Comment::Preproc, :statement
         rule %r((?<=\n)(?=\s|/|<!--)), Text, :expr_start
         mixin :comments_and_whitespace
         rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
                | !== )x,
           Operator, :expr_start
         rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start
-        rule /[(\[,]/, Punctuation, :expr_start
-        rule /;/, Punctuation, :statement
-        rule /[)\].]/, Punctuation
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
 
-        rule /`/ do
+        rule %r/`/ do
           token Str::Double
           push :template_string
         end
 
-        rule /[?]/ do
+        rule %r/[?]/ do
           token Punctuation
           push :ternary
           push :expr_start
         end
 
-        rule /(\@)(\w+)?/ do
+        rule %r/(\@)(\w+)?/ do
           groups Punctuation, Name::Decorator
           push :expr_start
         end
 
-        rule /[{}]/, Punctuation, :statement
+        rule %r/[{}]/, Punctuation, :statement
 
         rule id do |m|
           if self.class.keywords.include? m[0]
@@ -191,41 +191,41 @@ module Rouge
           end
         end
 
-        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
-        rule /0x[0-9a-fA-F]+/i, Num::Hex
-        rule /0o[0-7][0-7_]*/i, Num::Oct
-        rule /0b[01][01_]*/i, Num::Bin
-        rule /[0-9]+/, Num::Integer
+        rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/[0-9]+/, Num::Integer
 
-        rule /"/, Str::Delimiter, :dq
-        rule /'/, Str::Delimiter, :sq
-        rule /:/, Punctuation
+        rule %r/"/, Str::Delimiter, :dq
+        rule %r/'/, Str::Delimiter, :sq
+        rule %r/:/, Punctuation
       end
 
       state :dq do
-        rule /\\[\\nrt"]?/, Str::Escape
-        rule /[^\\"]+/, Str::Double
-        rule /"/, Str::Delimiter, :pop!
+        rule %r/\\[\\nrt"]?/, Str::Escape
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/"/, Str::Delimiter, :pop!
       end
 
       state :sq do
-        rule /\\[\\nrt']?/, Str::Escape
-        rule /[^\\']+/, Str::Single
-        rule /'/, Str::Delimiter, :pop!
+        rule %r/\\[\\nrt']?/, Str::Escape
+        rule %r/[^\\']+/, Str::Single
+        rule %r/'/, Str::Delimiter, :pop!
       end
 
       # braced parts that aren't object literals
       state :statement do
-        rule /case\b/ do
+        rule %r/case\b/ do
           token Keyword
           goto :expr_start
         end
 
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
         end
 
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         mixin :expr_start
       end
@@ -234,28 +234,28 @@ module Rouge
       state :object do
         mixin :comments_and_whitespace
 
-        rule /[{]/ do
+        rule %r/[{]/ do
           token Punctuation
           push
         end
 
-        rule /[}]/ do
+        rule %r/[}]/ do
           token Punctuation
           goto :statement
         end
 
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Attribute, Text, Punctuation
           push :expr_start
         end
 
-        rule /:/, Punctuation
+        rule %r/:/, Punctuation
         mixin :root
       end
 
       # ternary expressions, where <id>: is not a label!
       state :ternary do
-        rule /:/ do
+        rule %r/:/ do
           token Punctuation
           goto :expr_start
         end
@@ -265,13 +265,13 @@ module Rouge
 
       # template strings
       state :template_string do
-        rule /\${/, Punctuation, :template_string_expr
-        rule /`/, Str::Double, :pop!
-        rule /(\\\\|\\[\$`]|[^\$`]|\$(?!{))*/, Str::Double
+        rule %r/\${/, Punctuation, :template_string_expr
+        rule %r/`/, Str::Double, :pop!
+        rule %r/(\\\\|\\[\$`]|[^\$`]|\$(?!{))*/, Str::Double
       end
 
       state :template_string_expr do
-        rule /}/, Punctuation, :pop!
+        rule %r/}/, Punctuation, :pop!
         mixin :root
       end
     end

data/lib/rouge/lexers/jinja.rb

@@ -37,16 +37,16 @@ module Rouge
 
       state :root do
         # Comments
-        rule /{#/, Comment, :comment
+        rule %r/{#/, Comment, :comment
 
         # Statements
-        rule /\{\%/ do
+        rule %r/\{\%/ do
           token Comment::Preproc
           push :statement
         end
 
         # Expressions
-        rule /\{\{/ do
+        rule %r/\{\{/ do
           token Comment::Preproc
           push :expression
         end
@@ -57,42 +57,42 @@ module Rouge
 
       state :filter do
         # Filters are called like variable|foo(arg1, ...)
-        rule /(\|)(\w+)/ do
+        rule %r/(\|)(\w+)/ do
           groups Operator, Name::Function
         end
       end
 
       state :function do
-        rule /(\w+)(\()/ do
+        rule %r/(\w+)(\()/ do
           groups Name::Function, Punctuation
         end
       end
 
       state :text do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
       end
 
       state :literal do
         # Strings
-        rule /"(\\.|.)*?"/, Str::Double
-        rule /'(\\.|.)*?'/, Str::Single
+        rule %r/"(\\.|.)*?"/, Str::Double
+        rule %r/'(\\.|.)*?'/, Str::Single
 
         # Numbers
-        rule /\d+(?=}\s)/, Num
+        rule %r/\d+(?=}\s)/, Num
 
         # Arithmetic operators (+, -, *, **, //, /)
         # TODO : implement modulo (%)
-        rule /(\+|\-|\*|\/\/?|\*\*?|=)/, Operator
+        rule %r/(\+|\-|\*|\/\/?|\*\*?|=)/, Operator
 
         # Comparisons operators (<=, <, >=, >, ==, ===, !=)
-        rule /(<=?|>=?|===?|!=)/, Operator
+        rule %r/(<=?|>=?|===?|!=)/, Operator
 
         # Punctuation (the comma, [], ())
-        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
       end
 
       state :comment do
@@ -101,23 +101,23 @@ module Rouge
       end
 
       state :expression do
-        rule /\w+\.?/m, Name::Variable
+        rule %r/\w+\.?/m, Name::Variable
 
         mixin :filter
         mixin :function
         mixin :literal
         mixin :text
 
-        rule /%}|}}/, Comment::Preproc, :pop!
+        rule %r/%}|}}/, Comment::Preproc, :pop!
       end
 
       state :statement do
-        rule /(raw|verbatim)(\s+)(\%\})/ do
+        rule %r/(raw|verbatim)(\s+)(\%\})/ do
           groups Keyword, Text, Comment::Preproc
           goto :raw
         end
 
-        rule /(\w+\.?)/ do |m|
+        rule %r/(\w+\.?)/ do |m|
           if self.class.keywords.include?(m[0])
             groups Keyword
           elsif self.class.pseudo_keywords.include?(m[0])
@@ -136,7 +136,7 @@ module Rouge
         mixin :literal
         mixin :text
 
-        rule /\%\}/, Comment::Preproc, :pop!
+        rule %r/\%\}/, Comment::Preproc, :pop!
       end
 
       state :raw do
@@ -145,7 +145,7 @@ module Rouge
           pop!
         end
 
-        rule /(.+?)/m, Text
+        rule %r/(.+?)/m, Text
       end
     end
   end