rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/rust.rb

@@ -62,51 +62,51 @@ module Rouge
 
       state :start_line do
         mixin :whitespace
-        rule /\s+/, Text
-        rule /#\[/ do
+        rule %r/\s+/, Text
+        rule %r/#\[/ do
           token Name::Decorator; push :attribute
         end
         rule(//) { pop! }
-        rule /#\s[^\n]*/, Comment::Preproc
+        rule %r/#\s[^\n]*/, Comment::Preproc
       end
 
       state :attribute do
         mixin :whitespace
         mixin :has_literals
-        rule /[(,)=]/, Name::Decorator
-        rule /\]/, Name::Decorator, :pop!
+        rule %r/[(,)=]/, Name::Decorator
+        rule %r/\]/, Name::Decorator, :pop!
         rule id, Name::Decorator
       end
 
       state :whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//[^\n]*), Comment
         rule %r(/[*].*?[*]/)m, Comment::Multiline
       end
 
       state :root do
-        rule /\n/, Text, :start_line
+        rule %r/\n/, Text, :start_line
         mixin :whitespace
-        rule /\b(?:#{Rust.keywords.join('|')})\b/, Keyword
+        rule %r/\b(?:#{Rust.keywords.join('|')})\b/, Keyword
         mixin :has_literals
 
         rule %r([=-]>), Keyword
         rule %r(<->), Keyword
-        rule /[()\[\]{}|,:;]/, Punctuation
-        rule /[*!@~&+%^<>=-\?]|\.{2,3}/, Operator
+        rule %r/[()\[\]{}|,:;]/, Punctuation
+        rule %r/[*!@~&+%^<>=\?-]|\.{2,3}/, Operator
 
-        rule /([.]\s*)?#{id}(?=\s*[(])/m, Name::Function
-        rule /[.]\s*#{id}/, Name::Property
-        rule /(#{id})(::)/m do
+        rule %r/([.]\s*)?#{id}(?=\s*[(])/m, Name::Function
+        rule %r/[.]\s*#{id}/, Name::Property
+        rule %r/(#{id})(::)/m do
           groups Name::Namespace, Punctuation
         end
 
         # macros
-        rule /\bmacro_rules!/, Name::Decorator, :macro_rules
-        rule /#{id}!/, Name::Decorator, :macro
+        rule %r/\bmacro_rules!/, Name::Decorator, :macro_rules
+        rule %r/#{id}!/, Name::Decorator, :macro
 
-        rule /'#{id}/, Name::Variable
-        rule /#{id}/ do |m|
+        rule %r/'#{id}/, Name::Variable
+        rule %r/#{id}/ do |m|
           name = m[0]
           if self.class.builtins.include? name
             token Name::Builtin
@@ -119,13 +119,13 @@ module Rouge
       state :macro do
         mixin :has_literals
 
-        rule /[\[{(]/ do |m|
+        rule %r/[\[{(]/ do |m|
           @macro_delims[delim_map[m[0]]] += 1
           puts "    macro_delims: #{@macro_delims.inspect}" if @debug
           token Punctuation
         end
 
-        rule /[\]})]/ do |m|
+        rule %r/[\]})]/ do |m|
           @macro_delims[m[0]] -= 1
           puts "    macro_delims: #{@macro_delims.inspect}" if @debug
           pop! if macro_closed?
@@ -133,29 +133,29 @@ module Rouge
         end
 
         # same as the rule in root, but don't push another macro state
-        rule /#{id}!/, Name::Decorator
+        rule %r/#{id}!/, Name::Decorator
         mixin :root
 
         # No syntax errors in macros
-        rule /./, Text
+        rule %r/./, Text
       end
 
       state :macro_rules do
-        rule /[$]#{id}(:#{id})?/, Name::Variable
-        rule /[$]/, Name::Variable
+        rule %r/[$]#{id}(:#{id})?/, Name::Variable
+        rule %r/[$]/, Name::Variable
 
         mixin :macro
       end
 
       state :has_literals do
         # constants
-        rule /\b(?:true|false|nil)\b/, Keyword::Constant
+        rule %r/\b(?:true|false|nil)\b/, Keyword::Constant
         # characters
         rule %r(
           ' (?: #{escapes} | [^\\] ) '
         )x, Str::Char
 
-        rule /"/, Str, :string
+        rule %r/"/, Str, :string
 
         # numbers
         dot = /[.][0-9_]+/
@@ -172,17 +172,17 @@ module Rouge
 
         rule %r(
           ( 0b[10_]+
-          | 0x[0-9a-fA-F-]+
-          | [0-9]+
+          | 0x[0-9a-fA-F_]+
+          | [0-9_]+
           ) (u#{size}?|i#{size})?
         )x, Num::Integer
 
       end
 
       state :string do
-        rule /"/, Str, :pop!
+        rule %r/"/, Str, :pop!
         rule escapes, Str::Escape
-        rule /%%/, Str::Interpol
+        rule %r/%%/, Str::Interpol
         rule %r(
           %
           ( [0-9]+ [$] )?  # Parameter
@@ -191,7 +191,7 @@ module Rouge
           ( [.] [0-9]+ )?  # Precision
           [bcdfiostuxX?]   # Type
         )x, Str::Interpol
-        rule /[^%"\\]+/m, Str
+        rule %r/[^%"\\]+/m, Str
       end
     end
   end

data/lib/rouge/lexers/sass.rb

@@ -18,7 +18,7 @@ module Rouge
       id = /[\w-]+/
 
       state :root do
-        rule /[ \t]*\n/, Text
+        rule %r/[ \t]*\n/, Text
         rule(/[ \t]*/) { |m| token Text; indentation(m[0]) }
       end
 
@@ -34,14 +34,14 @@ module Rouge
           pop!; starts_block :multi_comment
         end
 
-        rule /@import\b/, Keyword, :import
+        rule %r/@import\b/, Keyword, :import
 
         mixin :content_common
 
         rule %r(=#{id}), Name::Function, :value
         rule %r([+]#{id}), Name::Decorator, :value
 
-        rule /:/, Name::Attribute, :old_style_attr
+        rule %r/:/, Name::Attribute, :old_style_attr
 
         rule(/(?=[^\[\n]+?:([^a-z]|$))/) { push :attribute }
 
@@ -49,17 +49,17 @@ module Rouge
       end
 
       state :single_comment do
-        rule /.*?$/, Comment::Single, :pop!
+        rule %r/.*?$/, Comment::Single, :pop!
       end
 
       state :multi_comment do
-        rule /.*?\n/, Comment::Multiline, :pop!
+        rule %r/.*?\n/, Comment::Multiline, :pop!
       end
 
       state :import do
-        rule /[ \t]+/, Text
-        rule /\S+/, Str
-        rule /\n/, Text, :pop!
+        rule %r/[ \t]+/, Text
+        rule %r/\S+/, Str
+        rule %r/\n/, Text, :pop!
       end
 
       state :old_style_attr do

data/lib/rouge/lexers/sass/common.rb

@@ -8,30 +8,30 @@ module Rouge
       id = /[\w-]+/
 
       state :content_common do
-        rule /@for\b/, Keyword, :for
-        rule /@(debug|warn|if|each|while|else|return|media)/, Keyword, :value
+        rule %r/@for\b/, Keyword, :for
+        rule %r/@(debug|warn|if|each|while|else|return|media)/, Keyword, :value
 
-        rule /(@mixin)(\s+)(#{id})/ do
+        rule %r/(@mixin)(\s+)(#{id})/ do
           groups Keyword, Text, Name::Function
           push :value
         end
 
-        rule /(@function)(\s+)(#{id})/ do
+        rule %r/(@function)(\s+)(#{id})/ do
           groups Keyword, Text, Name::Function
           push :value
         end
 
-        rule /@extend\b/, Keyword, :selector
+        rule %r/@extend\b/, Keyword, :selector
 
-        rule /(@include)(\s+)(#{id})/ do
+        rule %r/(@include)(\s+)(#{id})/ do
           groups Keyword, Text, Name::Decorator
           push :value
         end
 
-        rule /@#{id}/, Keyword, :selector
+        rule %r/@#{id}/, Keyword, :selector
 
         # $variable: assignment
-        rule /([$]#{id})([ \t]*)(:)/ do
+        rule %r/([$]#{id})([ \t]*)(:)/ do
           groups Name::Variable, Text, Punctuation
           push :value
         end
@@ -39,26 +39,26 @@ module Rouge
 
       state :value do
         mixin :end_section
-        rule /[ \t]+/, Text
-        rule /[$]#{id}/, Name::Variable
-        rule /url[(]/, Str::Other, :string_url
-        rule /#{id}(?=\s*[(])/, Name::Function
-        rule /%#{id}/, Name::Decorator
+        rule %r/[ \t]+/, Text
+        rule %r/[$]#{id}/, Name::Variable
+        rule %r/url[(]/, Str::Other, :string_url
+        rule %r/#{id}(?=\s*[(])/, Name::Function
+        rule %r/%#{id}/, Name::Decorator
 
         # named literals
-        rule /(true|false)\b/, Name::Builtin::Pseudo
-        rule /(and|or|not)\b/, Operator::Word
+        rule %r/(true|false)\b/, Name::Builtin::Pseudo
+        rule %r/(and|or|not)\b/, Operator::Word
 
         # colors and numbers
-        rule /#[a-z0-9]{1,6}/i, Num::Hex
-        rule /-?\d+(%|[a-z]+)?/, Num
-        rule /-?\d*\.\d+(%|[a-z]+)?/, Num::Integer
+        rule %r/#[a-z0-9]{1,6}/i, Num::Hex
+        rule %r/-?\d+(%|[a-z]+)?/, Num
+        rule %r/-?\d*\.\d+(%|[a-z]+)?/, Num::Integer
 
         mixin :has_strings
         mixin :has_interp
 
-        rule /[~^*!&%<>\|+=@:,.\/?-]+/, Operator
-        rule /[\[\]()]+/, Punctuation
+        rule %r/[~^*!&%<>\|+=@:,.\/?-]+/, Operator
+        rule %r/[\[\]()]+/, Punctuation
         rule %r(/[*]), Comment::Multiline, :inline_comment
         rule %r(//[^\n]*), Comment::Single
 
@@ -75,16 +75,16 @@ module Rouge
       end
 
       state :has_interp do
-        rule /[#][{]/, Str::Interpol, :interpolation
+        rule %r/[#][{]/, Str::Interpol, :interpolation
       end
 
       state :has_strings do
-        rule /"/, Str::Double, :dq
-        rule /'/, Str::Single, :sq
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
       end
 
       state :interpolation do
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
         mixin :value
       end
 
@@ -93,31 +93,31 @@ module Rouge
 
         mixin :has_strings
         mixin :has_interp
-        rule /[ \t]+/, Text
-        rule /:/, Name::Decorator, :pseudo_class
-        rule /[.]/, Name::Class, :class
-        rule /#/, Name::Namespace, :id
-        rule /%/, Name::Variable, :placeholder
+        rule %r/[ \t]+/, Text
+        rule %r/:/, Name::Decorator, :pseudo_class
+        rule %r/[.]/, Name::Class, :class
+        rule %r/#/, Name::Namespace, :id
+        rule %r/%/, Name::Variable, :placeholder
         rule id, Name::Tag
-        rule /&/, Keyword
-        rule /[~^*!&\[\]()<>\|+=@:;,.\/?-]/, Operator
+        rule %r/&/, Keyword
+        rule %r/[~^*!&\[\]()<>\|+=@:;,.\/?-]/, Operator
       end
 
       state :dq do
-        rule /"/, Str::Double, :pop!
+        rule %r/"/, Str::Double, :pop!
         mixin :has_interp
-        rule /(\\.|#(?![{])|[^\n"#])+/, Str::Double
+        rule %r/(\\.|#(?![{])|[^\n"#])+/, Str::Double
       end
 
       state :sq do
-        rule /'/, Str::Single, :pop!
+        rule %r/'/, Str::Single, :pop!
         mixin :has_interp
-        rule /(\\.|#(?![{])|[^\n'#])+/, Str::Single
+        rule %r/(\\.|#(?![{])|[^\n'#])+/, Str::Single
       end
 
       state :string_url do
-        rule /[)]/, Str::Other, :pop!
-        rule /(\\.|#(?![{])|[^\n)#])+/, Str::Other
+        rule %r/[)]/, Str::Other, :pop!
+        rule %r/(\\.|#(?![{])|[^\n)#])+/, Str::Other
         mixin :has_interp
       end
 
@@ -147,7 +147,7 @@ module Rouge
       end
 
       state :for do
-        rule /(from|to|through)/, Operator::Word
+        rule %r/(from|to|through)/, Operator::Word
         mixin :value
       end
 
@@ -165,14 +165,14 @@ module Rouge
       state :attribute do
         mixin :attr_common
 
-        rule /([ \t]*)(:)/ do
+        rule %r/([ \t]*)(:)/ do
           groups Text, Punctuation
           push :value
         end
       end
 
       state :inline_comment do
-        rule /(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, Comment::Multiline
+        rule %r/(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, Comment::Multiline
         mixin :has_interp
         rule %r([*]/), Comment::Multiline, :pop!
       end

data/lib/rouge/lexers/scala.rb

@@ -36,41 +36,41 @@ module Rouge
       )
 
       state :root do
-        rule /(class|trait|object)(\s+)/ do
+        rule %r/(class|trait|object)(\s+)/ do
           groups Keyword, Text
           push :class
         end
-        rule /'#{idrest}[^']/, Str::Symbol
-        rule /[^\S\n]+/, Text
+        rule %r/'#{idrest}[^']/, Str::Symbol
+        rule %r/[^\S\n]+/, Text
 
         rule %r(//.*?\n), Comment::Single
         rule %r(/\*), Comment::Multiline, :comment
 
-        rule /@#{idrest}/, Name::Decorator
+        rule %r/@#{idrest}/, Name::Decorator
 
-        rule /(def)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+        rule %r/(def)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
           groups Keyword, Text, Name::Function, Text
         end
 
-        rule /(val)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+        rule %r/(val)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
           groups Keyword, Text, Name::Variable, Text
         end
 
-        rule /(this)(\n*)(\.)(#{idrest})/ do
+        rule %r/(this)(\n*)(\.)(#{idrest})/ do
           groups Keyword, Text, Operator, Name::Property
         end
 
-        rule /(#{idrest}|_)(\n*)(\.)(#{idrest})/ do
+        rule %r/(#{idrest}|_)(\n*)(\.)(#{idrest})/ do
           groups Name::Variable, Text, Operator, Name::Property
         end
 
-        rule /#{upper}#{idrest}\b/, Name::Class
+        rule %r/#{upper}#{idrest}\b/, Name::Class
 
-        rule /(#{idrest})(#{whitespace}*)(\()/ do
+        rule %r/(#{idrest})(#{whitespace}*)(\()/ do
           groups Name::Function, Text, Operator
         end
 
-        rule /(\.)(#{idrest})/ do
+        rule %r/(\.)(#{idrest})/ do
           groups Operator, Name::Property
         end
 
@@ -78,80 +78,80 @@ module Rouge
           (#{keywords.join("|")})\b|
           (<[%:-]|=>|>:|[#=@_\u21D2\u2190])(\b|(?=\s)|$)
         )x, Keyword
-        rule /:(?!#{op})/, Keyword, :type        
-        rule /(true|false|null)\b/, Keyword::Constant
-        rule /(import|package)(\s+)/ do
+        rule %r/:(?!#{op})/, Keyword, :type        
+        rule %r/(true|false|null)\b/, Keyword::Constant
+        rule %r/(import|package)(\s+)/ do
           groups Keyword, Text
           push :import
         end
 
-        rule /(type)(\s+)/ do
+        rule %r/(type)(\s+)/ do
           groups Keyword, Text
           push :type
         end
 
-        rule /""".*?"""(?!")/m, Str
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'/, Str::Char
+        rule %r/""".*?"""(?!")/m, Str
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'/, Str::Char
 
         rule idrest, Name
-        rule /`[^`]+`/, Name
+        rule %r/`[^`]+`/, Name
 
-        rule /\[/, Operator, :typeparam
-        rule /[\(\)\{\};,.#]/, Operator
-        rule /#{op}+/, Operator
+        rule %r/\[/, Operator, :typeparam
+        rule %r/[\(\)\{\};,.#]/, Operator
+        rule %r/#{op}+/, Operator
 
-        rule /([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?/, Num::Float
-        rule /([0-9][0-9]*[fFdD])/, Num::Float
-        rule /0x[0-9a-fA-F]+/, Num::Hex
-        rule /[0-9]+L?/, Num::Integer
-        rule /\n/, Text
+        rule %r/([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?/, Num::Float
+        rule %r/([0-9][0-9]*[fFdD])/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/[0-9]+L?/, Num::Integer
+        rule %r/\n/, Text
       end
 
       state :class do
-        rule /(#{idrest}|#{op}+|`[^`]+`)(\s*)(\[)/ do
+        rule %r/(#{idrest}|#{op}+|`[^`]+`)(\s*)(\[)/ do
           groups Name::Class, Text, Operator
           push :typeparam
         end
 
-        rule /\s+/, Text
-        rule /{/, Operator, :pop!
-        rule /\(/, Operator, :pop!
+        rule %r/\s+/, Text
+        rule %r/{/, Operator, :pop!
+        rule %r/\(/, Operator, :pop!
         rule %r(//.*?\n), Comment::Single, :pop!
         rule %r(#{idrest}|#{op}+|`[^`]+`), Name::Class, :pop!
       end
 
       state :type do
-        rule /\s+/, Text
-        rule /<[%:]|>:|[#_\u21D2]|forSome|type/, Keyword
-        rule /([,\);}]|=>|=)(\s*)/ do
+        rule %r/\s+/, Text
+        rule %r/<[%:]|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule %r/([,\);}]|=>|=)(\s*)/ do
           groups Operator, Text
           pop!
         end
-        rule /[\(\{]/, Operator, :type
+        rule %r/[\(\{]/, Operator, :type
 
         typechunk = /(?:#{idrest}|#{op}+\`[^`]+`)/
-        rule /(#{typechunk}(?:\.#{typechunk})*)(\s*)(\[)/ do
+        rule %r/(#{typechunk}(?:\.#{typechunk})*)(\s*)(\[)/ do
           groups Keyword::Type, Text, Operator
           pop!
           push :typeparam
         end
 
-        rule /(#{typechunk}(?:\.#{typechunk})*)(\s*)$/ do
+        rule %r/(#{typechunk}(?:\.#{typechunk})*)(\s*)$/ do
           groups Keyword::Type, Text
           pop!
         end
 
         rule %r(//.*?\n), Comment::Single, :pop!
-        rule /\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
+        rule %r/\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
       end
 
       state :typeparam do
-        rule /[\s,]+/, Text
-        rule /<[%:]|=>|>:|[#_\u21D2]|forSome|type/, Keyword
-        rule /([\]\)\}])/, Operator, :pop!
-        rule /[\(\[\{]/, Operator, :typeparam
-        rule /\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
+        rule %r/[\s,]+/, Text
+        rule %r/<[%:]|=>|>:|[#_\u21D2]|forSome|type/, Keyword
+        rule %r/([\]\)\}])/, Operator, :pop!
+        rule %r/[\(\[\{]/, Operator, :typeparam
+        rule %r/\.|#{idrest}|#{op}+|`[^`]+`/, Keyword::Type
       end
 
       state :comment do