rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/slim.rb

@@ -45,22 +45,22 @@ module Rouge
       start { ruby.reset!; html.reset! }
 
       state :root do
-        rule /\s*\n/, Text
+        rule %r/\s*\n/, Text
         rule(/\s*/) { |m| token Text; indentation(m[0]) }
       end
 
       state :content do
         mixin :css
 
-        rule /\/#{dot}*/, Comment, :indented_block
+        rule %r/\/#{dot}*/, Comment, :indented_block
 
-        rule /(doctype)(\s+)(.*)/ do
+        rule %r/(doctype)(\s+)(.*)/ do
           groups Name::Namespace, Text::Whitespace, Text
           pop!
         end
 
         # filters, shamelessly ripped from HAML
-        rule /(\w*):\s*\n/ do |m|
+        rule %r/(\w*):\s*\n/ do |m|
           token Name::Decorator
           pop!
           starts_block :filter_block
@@ -81,29 +81,29 @@ module Rouge
           goto :plain_block
         end
 
-        rule /-|==|=/, Punctuation, :ruby_line
+        rule %r/-|==|=/, Punctuation, :ruby_line
 
         # Dynamic tags
-        rule /(\*)(#{ruby_chars}+\(.*?\))/ do |m|
+        rule %r/(\*)(#{ruby_chars}+\(.*?\))/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
           push :tag
         end
 
-        rule /(\*)(#{ruby_chars}+)/ do |m|
+        rule %r/(\*)(#{ruby_chars}+)/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
           push :tag
         end
 
-        #rule /<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
+        #rule %r/<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
         rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
           delegate html, m[1]
           pop!
         end
 
         # Ordinary slim tags
-        rule /\w+/, Name::Tag, :tag
+        rule %r/\w+/, Name::Tag, :tag
 
       end
 
@@ -113,24 +113,24 @@ module Rouge
         mixin :interpolation
 
         # Whitespace control
-        rule /[<>]/, Punctuation
+        rule %r/[<>]/, Punctuation
 
         # Trim whitespace
-        rule /\s+?/, Text::Whitespace
+        rule %r/\s+?/, Text::Whitespace
 
         # Splats, these two might be mergable?
-        rule /(\*)(#{ruby_chars}+)/ do |m|
+        rule %r/(\*)(#{ruby_chars}+)/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
         end
 
-        rule /(\*)(\{#{dot}+?\})/ do |m|
+        rule %r/(\*)(\{#{dot}+?\})/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
         end
 
         # Attributes
-        rule /([\w\-]+)(\s*)(\=)/ do |m|
+        rule %r/([\w\-]+)(\s*)(\=)/ do |m|
           token Name::Attribute, m[1]
           token Text::Whitespace, m[2]
           token Punctuation, m[3]
@@ -138,7 +138,7 @@ module Rouge
         end
 
         # Ruby value
-        rule /(\=)(#{dot}+)/ do |m|
+        rule %r/(\=)(#{dot}+)/ do |m|
           token Punctuation, m[1]
           #token Keyword::Constant, m[2]
           delegate ruby, m[2]
@@ -147,9 +147,9 @@ module Rouge
         # HTML Entities
         rule(/&\S*?;/, Name::Entity)
 
-        rule /#{dot}+?/, Text
+        rule %r/#{dot}+?/, Text
 
-        rule /\s*\n/, Text::Whitespace, :pop!
+        rule %r/\s*\n/, Text::Whitespace, :pop!
       end
 
       state :css do
@@ -165,7 +165,7 @@ module Rouge
         rule(/(#{ruby_chars}+\(.*?\))/) { |m| delegate ruby, m[1]; pop! }
         rule(/(#{ruby_chars}+)/) { |m| delegate ruby, m[1]; pop! }
 
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
       end
 
       state :ruby_line do
@@ -173,12 +173,12 @@ module Rouge
         mixin :indented_block
 
         rule(/[,\\]\s*\n/) { delegate ruby }
-        rule /[ ]\|[ \t]*\n/, Str::Escape
+        rule %r/[ ]\|[ \t]*\n/, Str::Escape
         rule(/.*?(?=([,\\]$| \|)?[ \t]*$)/) { delegate ruby }
       end
 
       state :filter_block do
-        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule %r/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
           if @filter_lexer
             delegate @filter_lexer
           else
@@ -200,18 +200,18 @@ module Rouge
         # HTML Entities
         rule(/&\S*?;/, Name::Entity)
 
-        #rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
-        rule /#{dot}+?/, Text
+        #rule %r/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule %r/#{dot}+?/, Text
 
         mixin :indented_block
       end
 
       state :interpolation do
-        rule /#[{]/, Str::Interpol, :ruby_interp
+        rule %r/#[{]/, Str::Interpol, :ruby_interp
       end
 
       state :ruby_interp do
-        rule /[}]/, Str::Interpol, :pop!
+        rule %r/[}]/, Str::Interpol, :pop!
         mixin :ruby_interp_inner
       end
 

data/lib/rouge/lexers/smalltalk.rb

@@ -15,29 +15,29 @@ module Rouge
       ops = %r([-+*/\\~<>=|&!?,@%])
 
       state :root do
-        rule /(<)(\w+:)(.*?)(>)/ do
+        rule %r/(<)(\w+:)(.*?)(>)/ do
           groups Punctuation, Keyword, Text, Punctuation
         end
 
         # mixin :squeak_fileout
         mixin :whitespaces
         mixin :method_definition
-        rule /([|])([\w\s]*)([|])/ do
+        rule %r/([|])([\w\s]*)([|])/ do
           groups Punctuation, Name::Variable, Punctuation
         end
         mixin :objects
-        rule /\^|:=|_/, Operator
+        rule %r/\^|:=|_/, Operator
 
-        rule /[)}\]]/, Punctuation, :after_object
-        rule /[({\[!]/, Punctuation
+        rule %r/[)}\]]/, Punctuation, :after_object
+        rule %r/[({\[!]/, Punctuation
       end
 
       state :method_definition do
-        rule /([a-z]\w*:)(\s*)(\w+)/i do
+        rule %r/([a-z]\w*:)(\s*)(\w+)/i do
           groups Name::Function, Text, Name::Variable
         end
 
-        rule /^(\s*)(\b[a-z]\w*\b)(\s*)$/i do
+        rule %r/^(\s*)(\b[a-z]\w*\b)(\s*)$/i do
           groups Text, Name::Function, Text
         end
 
@@ -48,27 +48,27 @@ module Rouge
 
       state :block_variables do
         mixin :whitespaces
-        rule /(:)(\s*)(\w+)/ do
+        rule %r/(:)(\s*)(\w+)/ do
           groups Operator, Text, Name::Variable
         end
 
-        rule /[|]/, Punctuation, :pop!
+        rule %r/[|]/, Punctuation, :pop!
 
         rule(//) { pop! }
       end
 
       state :literals do
-        rule /'(''|.)*?'/m, Str, :after_object
-        rule /[$]./, Str::Char, :after_object
-        rule /#[(]/, Str::Symbol, :parenth
-        rule /(\d+r)?-?\d+(\.\d+)?(e-?\d+)?/,
+        rule %r/'(''|.)*?'/m, Str, :after_object
+        rule %r/[$]./, Str::Char, :after_object
+        rule %r/#[(]/, Str::Symbol, :parenth
+        rule %r/(\d+r)?-?\d+(\.\d+)?(e-?\d+)?/,
           Num, :after_object
-        rule /#("[^"]*"|#{ops}+|[\w:]+)/,
+        rule %r/#("[^"]*"|#{ops}+|[\w:]+)/,
           Str::Symbol, :after_object
       end
 
       state :parenth do
-        rule /[)]/ do
+        rule %r/[)]/ do
           token Str::Symbol
           goto :after_object
         end
@@ -77,39 +77,39 @@ module Rouge
       end
 
       state :inner_parenth do
-        rule /#[(]/, Str::Symbol, :inner_parenth
-        rule /[)]/, Str::Symbol, :pop!
+        rule %r/#[(]/, Str::Symbol, :inner_parenth
+        rule %r/[)]/, Str::Symbol, :pop!
         mixin :whitespaces
         mixin :literals
-        rule /(#{ops}|[\w:])+/, Str::Symbol
+        rule %r/(#{ops}|[\w:])+/, Str::Symbol
       end
 
       state :whitespaces do
-        rule /! !$/, Keyword # squeak chunk delimiter
-        rule /\s+/m, Text
-        rule /".*?"/m, Comment
+        rule %r/! !$/, Keyword # squeak chunk delimiter
+        rule %r/\s+/m, Text
+        rule %r/".*?"/m, Comment
       end
 
       state :objects do
-        rule /\[/, Punctuation, :block_variables
-        rule /(self|super|true|false|nil|thisContext)\b/,
+        rule %r/\[/, Punctuation, :block_variables
+        rule %r/(self|super|true|false|nil|thisContext)\b/,
           Name::Builtin::Pseudo, :after_object
-        rule /[A-Z]\w*(?!:)\b/, Name::Class, :after_object
-        rule /[a-z]\w*(?!:)\b/, Name::Variable, :after_object
+        rule %r/[A-Z]\w*(?!:)\b/, Name::Class, :after_object
+        rule %r/[a-z]\w*(?!:)\b/, Name::Variable, :after_object
         mixin :literals
       end
 
       state :after_object do
         mixin :whitespaces
-        rule /(ifTrue|ifFalse|whileTrue|whileFalse|timesRepeat):/,
+        rule %r/(ifTrue|ifFalse|whileTrue|whileFalse|timesRepeat):/,
           Name::Builtin, :pop!
-        rule /new(?!:)\b/, Name::Builtin
-        rule /:=|_/, Operator, :pop!
-        rule /[a-z]+\w*:/i, Name::Function, :pop!
-        rule /[a-z]+\w*/i, Name::Function
-        rule /#{ops}+/, Name::Function, :pop!
-        rule /[.]/, Punctuation, :pop!
-        rule /;/, Punctuation
+        rule %r/new(?!:)\b/, Name::Builtin
+        rule %r/:=|_/, Operator, :pop!
+        rule %r/[a-z]+\w*:/i, Name::Function, :pop!
+        rule %r/[a-z]+\w*/i, Name::Function
+        rule %r/#{ops}+/, Name::Function, :pop!
+        rule %r/[.]/, Punctuation, :pop!
+        rule %r/;/, Punctuation
         rule(//) { pop! }
       end
     end

data/lib/rouge/lexers/smarty.rb

@@ -33,9 +33,9 @@ module Rouge
         rule(/\{\s+/) { delegate parent }
 
         # block comments
-        rule /\{\*.*?\*\}/m, Comment
+        rule %r/\{\*.*?\*\}/m, Comment
 
-        rule /\{\/?(?![\s*])/ do
+        rule %r/\{\/?(?![\s*])/ do
           token Keyword
           push :smarty
         end
@@ -53,21 +53,21 @@ module Rouge
 
       state :smarty do
         # allow nested tags
-        rule /\{\/?(?![\s*])/ do
+        rule %r/\{\/?(?![\s*])/ do
           token Keyword
           push :smarty
         end
 
-        rule /}/, Keyword, :pop!
-        rule /\s+/m, Text
+        rule %r/}/, Keyword, :pop!
+        rule %r/\s+/m, Text
         rule %r([~!%^&*()+=|\[\]:;,.<>/@?-]), Operator
-        rule /#[a-zA-Z_]\w*#/, Name::Variable
-        rule /\$[a-zA-Z_]\w*(\.\w+)*/, Name::Variable
-        rule /(true|false|null)\b/, Keyword::Constant
-	rule /[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?/, Num
-	rule /"(\\.|.)*?"/, Str::Double
-        rule /'(\\.|.)*?'/, Str::Single
-	rule /([a-zA-Z_]\w*)/ do |m|
+        rule %r/#[a-zA-Z_]\w*#/, Name::Variable
+        rule %r/\$[a-zA-Z_]\w*(\.\w+)*/, Name::Variable
+        rule %r/(true|false|null)\b/, Keyword::Constant
+	rule %r/[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?/, Num
+	rule %r/"(\\.|.)*?"/, Str::Double
+        rule %r/'(\\.|.)*?'/, Str::Single
+	rule %r/([a-zA-Z_]\w*)/ do |m|
 	  if self.class.builtins.include? m[0]
 	    token Name::Builtin
 	  else

data/lib/rouge/lexers/sml.rb

@@ -30,25 +30,25 @@ module Rouge
       symbol = %r([!%&$#/:<=>?@\\~`^|*+-]+)
 
       state :whitespace do
-        rule /\s+/m, Text
-        rule /[(][*]/, Comment, :comment
+        rule %r/\s+/m, Text
+        rule %r/[(][*]/, Comment, :comment
       end
 
       state :delimiters do
-        rule /[(\[{]/, Punctuation, :main
-        rule /[)\]}]/, Punctuation, :pop!
+        rule %r/[(\[{]/, Punctuation, :main
+        rule %r/[)\]}]/, Punctuation, :pop!
 
-        rule /\b(let|if|local)\b(?!')/ do
+        rule %r/\b(let|if|local)\b(?!')/ do
           token Keyword::Reserved
           push; push
         end
 
-        rule /\b(struct|sig|while)\b(?!')/ do
+        rule %r/\b(struct|sig|while)\b(?!')/ do
           token Keyword::Reserved
           push
         end
 
-        rule /\b(do|else|end|in|then)\b(?!')/, Keyword::Reserved, :pop!
+        rule %r/\b(do|else|end|in|then)\b(?!')/, Keyword::Reserved, :pop!
       end
 
       def token_for_id_with_dot(id)
@@ -78,28 +78,28 @@ module Rouge
       end
 
       state :core do
-        rule /[()\[\]{},;_]|[.][.][.]/, Punctuation
-        rule /#"/, Str::Char, :char
-        rule /"/, Str::Double, :string
-        rule /~?0x[0-9a-fA-F]+/, Num::Hex
-        rule /0wx[0-9a-fA-F]+/, Num::Hex
-        rule /0w\d+/, Num::Integer
-        rule /~?\d+([.]\d+)?[eE]~?\d+/, Num::Float
-        rule /~?\d+[.]\d+/, Num::Float
-        rule /~?\d+/, Num::Integer
-
-        rule /#\s*[1-9][0-9]*/, Name::Label
-        rule /#\s*#{id}/, Name::Label
-        rule /#\s+#{symbol}/, Name::Label
-
-        rule /\b(datatype|abstype)\b(?!')/, Keyword::Reserved, :dname
+        rule %r/[()\[\]{},;_]|[.][.][.]/, Punctuation
+        rule %r/#"/, Str::Char, :char
+        rule %r/"/, Str::Double, :string
+        rule %r/~?0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/0wx[0-9a-fA-F]+/, Num::Hex
+        rule %r/0w\d+/, Num::Integer
+        rule %r/~?\d+([.]\d+)?[eE]~?\d+/, Num::Float
+        rule %r/~?\d+[.]\d+/, Num::Float
+        rule %r/~?\d+/, Num::Integer
+
+        rule %r/#\s*[1-9][0-9]*/, Name::Label
+        rule %r/#\s*#{id}/, Name::Label
+        rule %r/#\s+#{symbol}/, Name::Label
+
+        rule %r/\b(datatype|abstype)\b(?!')/, Keyword::Reserved, :dname
         rule(/(?=\bexception\b(?!'))/) { push :ename }
-        rule /\b(functor|include|open|signature|structure)\b(?!')/,
+        rule %r/\b(functor|include|open|signature|structure)\b(?!')/,
           Keyword::Reserved, :sname
-        rule /\b(type|eqtype)\b(?!')/, Keyword::Reserved, :tname
+        rule %r/\b(type|eqtype)\b(?!')/, Keyword::Reserved, :tname
 
-        rule /'#{id}/, Name::Decorator
-        rule /(#{id})([.])/ do |m|
+        rule %r/'#{id}/, Name::Decorator
+        rule %r/(#{id})([.])/ do |m|
           groups(token_for_id_with_dot(m[1]), Punctuation)
           push :dotted
         end
@@ -114,7 +114,7 @@ module Rouge
       end
 
       state :dotted do
-        rule /(#{id})([.])/ do |m|
+        rule %r/(#{id})([.])/ do |m|
           groups(token_for_id_with_dot(m[1]), Punctuation)
         end
 
@@ -130,15 +130,15 @@ module Rouge
       end
 
       state :root do
-        rule /#!.*?\n/, Comment::Preproc
+        rule %r/#!.*?\n/, Comment::Preproc
         rule(//) { push :main }
       end
 
       state :main do
         mixin :whitespace
 
-        rule /\b(val|and)\b(?!')/, Keyword::Reserved, :vname
-        rule /\b(fun)\b(?!')/ do
+        rule %r/\b(val|and)\b(?!')/, Keyword::Reserved, :vname
+        rule %r/\b(fun)\b(?!')/ do
           token Keyword::Reserved
           goto :main_fun
           push :fname
@@ -150,15 +150,15 @@ module Rouge
 
       state :main_fun do
         mixin :whitespace
-        rule /\b(fun|and)\b(?!')/, Keyword::Reserved, :fname
-        rule /\bval\b(?!')/ do
+        rule %r/\b(fun|and)\b(?!')/, Keyword::Reserved, :fname
+        rule %r/\bval\b(?!')/ do
           token Keyword::Reserved
           goto :main
           push :vname
         end
 
-        rule /[|]/, Punctuation, :fname
-        rule /\b(case|handle)\b(?!')/ do
+        rule %r/[|]/, Punctuation, :fname
+        rule %r/\b(case|handle)\b(?!')/ do
           token Keyword::Reserved
           goto :main
         end
@@ -168,27 +168,27 @@ module Rouge
       end
 
       state :has_escapes do
-        rule /\\[\\"abtnvfr]/, Str::Escape
-        rule /\\\^[\x40-\x5e]/, Str::Escape
-        rule /\\[0-9]{3}/, Str::Escape
-        rule /\\u\h{4}/, Str::Escape
-        rule /\\\s+\\/, Str::Interpol
+        rule %r/\\[\\"abtnvfr]/, Str::Escape
+        rule %r/\\\^[\x40-\x5e]/, Str::Escape
+        rule %r/\\[0-9]{3}/, Str::Escape
+        rule %r/\\u\h{4}/, Str::Escape
+        rule %r/\\\s+\\/, Str::Interpol
       end
 
       state :string do
-        rule /[^"\\]+/, Str::Double
-        rule /"/, Str::Double, :pop!
+        rule %r/[^"\\]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
         mixin :has_escapes
       end
 
       state :char do
-        rule /[^"\\]+/, Str::Char
-        rule /"/, Str::Char, :pop!
+        rule %r/[^"\\]+/, Str::Char
+        rule %r/"/, Str::Char, :pop!
         mixin :has_escapes
       end
 
       state :breakout do
-        rule /(?=\b(#{SML.keywords.to_a.join('|')})\b(?!'))/ do
+        rule %r/(?=\b(#{SML.keywords.to_a.join('|')})\b(?!'))/ do
           pop!
         end
       end
@@ -201,8 +201,8 @@ module Rouge
       end
 
       state :has_annotations do
-        rule /'[\w']*/, Name::Decorator
-        rule /[(]/, Punctuation, :tyvarseq
+        rule %r/'[\w']*/, Name::Decorator
+        rule %r/[(]/, Punctuation, :tyvarseq
       end
 
       state :fname do
@@ -217,12 +217,12 @@ module Rouge
         mixin :whitespace
         mixin :has_annotations
 
-        rule /(#{id})(\s*)(=(?!#{symbol}))/m do
+        rule %r/(#{id})(\s*)(=(?!#{symbol}))/m do
           groups Name::Variable, Text, Punctuation
           pop!
         end
 
-        rule /(#{symbol})(\s*)(=(?!#{symbol}))/m do
+        rule %r/(#{symbol})(\s*)(=(?!#{symbol}))/m do
           groups Name::Variable, Text, Punctuation
         end
 
@@ -237,8 +237,8 @@ module Rouge
         mixin :breakout
         mixin :has_annotations
 
-        rule /'[\w']*/, Name::Decorator
-        rule /[(]/, Punctuation, :tyvarseq
+        rule %r/'[\w']*/, Name::Decorator
+        rule %r/[(]/, Punctuation, :tyvarseq
 
         rule %r(=(?!#{symbol})) do
           token Punctuation
@@ -252,7 +252,7 @@ module Rouge
       state :typbind do
         mixin :whitespace
 
-        rule /\b(and)\b(?!')/ do
+        rule %r/\b(and)\b(?!')/ do
           token Keyword::Reserved
           goto :tname
         end
@@ -266,7 +266,7 @@ module Rouge
         mixin :breakout
         mixin :has_annotations
 
-        rule /(=)(\s*)(datatype)\b/ do
+        rule %r/(=)(\s*)(datatype)\b/ do
           groups Punctuation, Text, Keyword::Reserved
           pop!
         end
@@ -283,18 +283,18 @@ module Rouge
 
       state :datbind do
         mixin :whitespace
-        rule /\b(and)\b(?!')/ do
+        rule %r/\b(and)\b(?!')/ do
           token Keyword::Reserved; goto :dname
         end
-        rule /\b(withtype)\b(?!')/ do
+        rule %r/\b(withtype)\b(?!')/ do
           token Keyword::Reserved; goto :tname
         end
-        rule /\bof\b(?!')/, Keyword::Reserved
-        rule /([|])(\s*)(#{id})/ do
+        rule %r/\bof\b(?!')/, Keyword::Reserved
+        rule %r/([|])(\s*)(#{id})/ do
           groups(Punctuation, Text, Name::Class)
         end
 
-        rule /([|])(\s+)(#{symbol})/ do
+        rule %r/([|])(\s+)(#{symbol})/ do
           groups(Punctuation, Text, Name::Class)
         end
 
@@ -304,15 +304,15 @@ module Rouge
 
       state :ename do
         mixin :whitespace
-        rule /(exception|and)(\s+)(#{id})/ do
+        rule %r/(exception|and)(\s+)(#{id})/ do
           groups Keyword::Reserved, Text, Name::Class
         end
 
-        rule /(exception|and)(\s*)(#{symbol})/ do
+        rule %r/(exception|and)(\s*)(#{symbol})/ do
           groups Keyword::Reserved, Text, Name::Class
         end
 
-        rule /\b(of)\b(?!')/, Keyword::Reserved
+        rule %r/\b(of)\b(?!')/, Keyword::Reserved
         mixin :breakout
         mixin :core
       end
@@ -325,20 +325,20 @@ module Rouge
 
       state :tyvarseq do
         mixin :whitespace
-        rule /'[\w']*/, Name::Decorator
+        rule %r/'[\w']*/, Name::Decorator
         rule id, Name
-        rule /,/, Punctuation
-        rule /[)]/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/[)]/, Punctuation, :pop!
         rule symbol, Name
       end
 
       state :comment do
-        rule /[^(*)]+/, Comment::Multiline
-        rule /[(][*]/ do
+        rule %r/[^(*)]+/, Comment::Multiline
+        rule %r/[(][*]/ do
           token Comment::Multiline; push
         end
-        rule /[*][)]/, Comment::Multiline, :pop!
-        rule /[(*)]/, Comment::Multiline
+        rule %r/[*][)]/, Comment::Multiline, :pop!
+        rule %r/[(*)]/, Comment::Multiline
       end
     end
   end