rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/hcl.rb

@@ -16,19 +16,19 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(#.*?$), Comment::Single
         rule %r(/[*]), Comment::Multiline, :multiline_comment
       end
 
       state :primitives do
-        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?([kKmMgG]b?)?/, Num::Float
-        rule /[0-9]+([kKmMgG]b?)?/, Num::Integer
+        rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?([kKmMgG]b?)?/, Num::Float
+        rule %r/[0-9]+([kKmMgG]b?)?/, Num::Integer
 
-        rule /"/, Str::Double, :dq
-        rule /'/, Str::Single, :sq
-        rule /(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
+        rule %r/(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
           groups Operator, Text, Str::Heredoc, Str::Heredoc, Name::Constant, Str::Heredoc
           @heredocstr = Regexp.escape(m[5])
           push :heredoc
@@ -61,11 +61,11 @@ module Rouge
         mixin :comments_and_whitespace
         mixin :primitives
 
-        rule /\{/ do
+        rule %r/\{/ do
           token Punctuation
           push :hash
         end
-        rule /\[/ do
+        rule %r/\[/ do
           token Punctuation
           push :array
         end
@@ -93,13 +93,13 @@ module Rouge
       state :composite do
         mixin :comments_and_whitespace
 
-        rule /[{]/ do
+        rule %r/[{]/ do
           token Punctuation
           pop!
           push :hash
         end
 
-        rule /[\[]/ do
+        rule %r/[\[]/ do
           token Punctuation
           pop!
           push :array
@@ -107,14 +107,14 @@ module Rouge
 
         mixin :root
 
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :hash do
         mixin :comments_and_whitespace
 
-        rule /\=/, Punctuation
-        rule /\}/, Punctuation, :pop!
+        rule %r/\=/, Punctuation
+        rule %r/\}/, Punctuation, :pop!
 
         mixin :root
       end
@@ -122,32 +122,32 @@ module Rouge
       state :array do
         mixin :comments_and_whitespace
 
-        rule /,/, Punctuation
-        rule /\]/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/\]/, Punctuation, :pop!
 
         mixin :root
       end
 
       state :dq 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
 
       state :sq do
-        rule /[^\\']+/, Str::Single
-        rule /\\'/, Str::Escape
-        rule /'/, Str::Single, :pop!
+        rule %r/[^\\']+/, Str::Single
+        rule %r/\\'/, Str::Escape
+        rule %r/'/, Str::Single, :pop!
       end
 
       state :heredoc do
-        rule /\n/, Str::Heredoc, :heredoc_nl
-        rule /[^$\n]+/, Str::Heredoc
-        rule /[$]/, Str::Heredoc
+        rule %r/\n/, Str::Heredoc, :heredoc_nl
+        rule %r/[^$\n]+/, Str::Heredoc
+        rule %r/[$]/, Str::Heredoc
       end
 
       state :heredoc_nl do
-        rule /\s*(\w+)\s*\n/ do |m|
+        rule %r/\s*(\w+)\s*\n/ do |m|
           if m[1] == @heredocstr
             token Name::Constant
             pop! 2

data/lib/rouge/lexers/html.rb

@@ -22,21 +22,21 @@ module Rouge
       end
 
       state :root do
-        rule /[^<&]+/m, Text
-        rule /&\S*?;/, Name::Entity
-        rule /<!DOCTYPE .*?>/im, Comment::Preproc
-        rule /<!\[CDATA\[.*?\]\]>/m, Comment::Preproc
-        rule /<!--/, Comment, :comment
-        rule /<\?.*?\?>/m, Comment::Preproc # php? really?
-
-        rule /<\s*script\s*/m do
+        rule %r/[^<&]+/m, Text
+        rule %r/&\S*?;/, Name::Entity
+        rule %r/<!DOCTYPE .*?>/im, Comment::Preproc
+        rule %r/<!\[CDATA\[.*?\]\]>/m, Comment::Preproc
+        rule %r/<!--/, Comment, :comment
+        rule %r/<\?.*?\?>/m, Comment::Preproc # php? really?
+
+        rule %r/<\s*script\s*/m do
           token Name::Tag
           @javascript.reset!
           push :script_content
           push :tag
         end
 
-        rule /<\s*style\s*/m do
+        rule %r/<\s*style\s*/m do
           token Name::Tag
           @css.reset!
           @lang = @css
@@ -44,8 +44,8 @@ module Rouge
           push :tag
         end
 
-        rule /<\//, Name::Tag, :tag_end
-        rule /</, Name::Tag, :tag_start
+        rule %r(</), Name::Tag, :tag_end
+        rule %r/</, Name::Tag, :tag_start
 
         rule %r(<\s*[a-zA-Z0-9:-]+), Name::Tag, :tag # opening tags
         rule %r(<\s*/\s*[a-zA-Z0-9:-]+\s*>), Name::Tag # closing tags
@@ -53,21 +53,21 @@ module Rouge
 
       state :tag_end do
         mixin :tag_end_end
-        rule /[a-zA-Z0-9:-]+/ do
+        rule %r/[a-zA-Z0-9:-]+/ do
           token Name::Tag
           goto :tag_end_end
         end
       end
 
       state :tag_end_end do
-        rule /\s+/, Text
-        rule />/, Name::Tag, :pop!
+        rule %r/\s+/, Text
+        rule %r/>/, Name::Tag, :pop!
       end
 
       state :tag_start do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /[a-zA-Z0-9:-]+/ do
+        rule %r/[a-zA-Z0-9:-]+/ do
           token Name::Tag
           goto :tag
         end
@@ -76,41 +76,41 @@ module Rouge
       end
 
       state :comment do
-        rule /[^-]+/, Comment
-        rule /-->/, Comment, :pop!
-        rule /-/, Comment
+        rule %r/[^-]+/, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
       end
 
       state :tag do
-        rule /\s+/m, Text
-        rule /[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
-        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/\s+/m, Text
+        rule %r/[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
+        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
         rule %r(/?\s*>)m, Name::Tag, :pop!
       end
 
       state :attr do
         # TODO: are backslash escapes valid here?
-        rule /"/ do
+        rule %r/"/ do
           token Str
           goto :dq
         end
 
-        rule /'/ do
+        rule %r/'/ do
           token Str
           goto :sq
         end
 
-        rule /[^\s>]+/, Str, :pop!
+        rule %r/[^\s>]+/, Str, :pop!
       end
 
       state :dq do
-        rule /"/, Str, :pop!
-        rule /[^"]+/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/[^"]+/, Str
       end
 
       state :sq do
-        rule /'/, Str, :pop!
-        rule /[^']+/, Str
+        rule %r/'/, Str, :pop!
+        rule %r/[^']+/, Str
       end
 
       state :script_content do
@@ -126,13 +126,13 @@ module Rouge
       end
 
       state :style_content do
-        rule /[^<]+/ do
+        rule %r/[^<]+/ do
           delegate @lang
         end
 
         rule %r(<\s*/\s*style\s*>)m, Name::Tag, :pop!
 
-        rule /</ do
+        rule %r/</ do
           delegate @lang
         end
       end

data/lib/rouge/lexers/http.rb

@@ -54,7 +54,7 @@ module Rouge
       end
 
       state :headers do
-        rule /([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|$)/ do |m|
+        rule %r/([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|$)/ do |m|
           key = m[1]
           value = m[5]
           if key.strip.casecmp('content-type').zero?
@@ -64,15 +64,15 @@ module Rouge
           groups Name::Attribute, Text, Punctuation, Text, Str, Text
         end
 
-        rule /([^\r\n]+)(\r?\n|$)/ do
+        rule %r/([^\r\n]+)(\r?\n|$)/ do
           groups Str, Text
         end
 
-        rule /\r?\n/, Text, :content
+        rule %r/\r?\n/, Text, :content
       end
 
       state :content do
-        rule /.+/m do |m|
+        rule %r/.+/m do |m|
           delegate(content_lexer)
         end
       end

data/lib/rouge/lexers/hylang.rb

@@ -54,22 +54,22 @@ module Rouge
       end
 
       state :root do
-        rule /;.*?$/, Comment::Single
-        rule /\s+/m, Text::Whitespace
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/m, Text::Whitespace
 
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+/, Num::Integer
-        rule /0x-?[0-9a-fA-F]+/, Num::Hex
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
+        rule %r/0x-?[0-9a-fA-F]+/, Num::Hex
 
-        rule /"(\\.|[^"])*"/, Str
-        rule /'#{keyword}/, Str::Symbol
-        rule /::?#{keyword}/, Name::Constant
-        rule /\\(.|[a-z]+)/i, Str::Char
+        rule %r/"(\\.|[^"])*"/, Str
+        rule %r/'#{keyword}/, Str::Symbol
+        rule %r/::?#{keyword}/, Name::Constant
+        rule %r/\\(.|[a-z]+)/i, Str::Char
 
 
-        rule /~@|[`\'#^~&@]/, Operator
+        rule %r/~@|[`\'#^~&@]/, Operator
 
-        rule /(\()(\s*)(#{identifier})/m do |m|
+        rule %r/(\()(\s*)(#{identifier})/m do |m|
           token Punctuation, m[1]
           token Text::Whitespace, m[2]
           token(name_token(m[3]) || Name::Function, m[3])
@@ -80,13 +80,13 @@ module Rouge
         end
 
         # vectors
-        rule /[\[\]]/, Punctuation
+        rule %r/[\[\]]/, Punctuation
 
         # maps
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         # parentheses
-        rule /[()]/, Punctuation
+        rule %r/[()]/, Punctuation
       end
     end
   end

data/lib/rouge/lexers/idlang.rb

@@ -209,17 +209,17 @@ module Rouge
       end
 
       state :root do
-        rule /[\s\n]+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
         # Normal comments
-        rule /;.*$/, Comment::Single
-        rule /\,\s*\,/, Error
-        rule /\!#{name}/, Name::Variable::Global
+        rule %r/;.*$/, Comment::Single
+        rule %r/\,\s*\,/, Error
+        rule %r/\!#{name}/, Name::Variable::Global
 
-        rule /[(),:\&\$]/, Punctuation
+        rule %r/[(),:\&\$]/, Punctuation
 
         ## Format statements are quite a strange beast.
         ## Better process them in their own state.
-        #rule /\b(FORMAT)(\s*)(\()/mi do |m|
+        #rule %r/\b(FORMAT)(\s*)(\()/mi do |m|
         #  token Keyword, m[1]
         #  token Text::Whitespace, m[2]
         #  token Punctuation, m[3]
@@ -235,25 +235,25 @@ module Rouge
           (_#{kind_param})? # kind parameter
         )xi, Num::Float
 
-        rule /\d+(B|S|U|US|LL|L|ULL|UL)?/i, Num::Integer
-        rule /"[0-7]+(B|O|U|ULL|UL|LL|L)?/i, Num::Oct
-        rule /'[0-9A-F]+'X(B|S|US|ULL|UL|U|LL|L)?/i, Num::Hex
-        rule /(#{kind_param}_)?'/, Str::Single, :string_single
-        rule /(#{kind_param}_)?"/, Str::Double, :string_double
+        rule %r/\d+(B|S|U|US|LL|L|ULL|UL)?/i, Num::Integer
+        rule %r/"[0-7]+(B|O|U|ULL|UL|LL|L)?/i, Num::Oct
+        rule %r/'[0-9A-F]+'X(B|S|US|ULL|UL|U|LL|L)?/i, Num::Hex
+        rule %r/(#{kind_param}_)?'/, Str::Single, :string_single
+        rule %r/(#{kind_param}_)?"/, Str::Double, :string_double
 
         rule %r{\#\#|\#|\&\&|\|\||/=|<=|>=|->|\@|\?|[-+*/<=~^{}]}, Operator
         # Structures and the like
-        rule /(#{name})(\.)([^\s,]*)/i do |m|
+        rule %r/(#{name})(\.)([^\s,]*)/i do |m|
           groups Name, Operator, Name
           #delegate IDLang, m[3]
         end
 
-        rule /(function|pro)((?:\s|\$\s)+)/i do
+        rule %r/(function|pro)((?:\s|\$\s)+)/i do
           groups Keyword, Text::Whitespace
           push :funcname
         end
 
-        rule /#{name}/m do |m|
+        rule %r/#{name}/m do |m|
           match = m[0].upcase
           if self.class.keywords.include? match
             token Keyword
@@ -275,37 +275,37 @@ module Rouge
       end
 
       state :funcname do
-        rule /#{name}/, Name::Function
+        rule %r/#{name}/, Name::Function
 
-        rule /\s+/, Text::Whitespace
-        rule /(:+|\$)/, Operator
-        rule /;.*/, Comment::Single
+        rule %r/\s+/, Text::Whitespace
+        rule %r/(:+|\$)/, Operator
+        rule %r/;.*/, Comment::Single
 
         # Be done with this state if we hit EOL or comma
-        rule /$/, Text::Whitespace, :pop!
-        rule /,/, Operator, :pop!
+        rule %r/$/, Text::Whitespace, :pop!
+        rule %r/,/, Operator, :pop!
       end
 
       state :string_single do
-        rule /[^']+/, Str::Single
-        rule /''/, Str::Escape
-        rule /'/, Str::Single, :pop!
+        rule %r/[^']+/, Str::Single
+        rule %r/''/, Str::Escape
+        rule %r/'/, Str::Single, :pop!
       end
 
       state :string_double do
-        rule /[^"]+/, Str::Double
-        rule /"/, Str::Double, :pop!
+        rule %r/[^"]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
       end
 
       state :format_spec do
-        rule /'/, Str::Single, :string_single
-        rule /"/, Str::Double, :string_double
-        rule /\(/, Punctuation, :format_spec
-        rule /\)/, Punctuation, :pop!
-        rule /,/, Punctuation
-        rule /[\s\n]+/, Text::Whitespace
+        rule %r/'/, Str::Single, :string_single
+        rule %r/"/, Str::Double, :string_double
+        rule %r/\(/, Punctuation, :format_spec
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/\s+/, Text::Whitespace
         # Edit descriptors could be seen as a kind of "format literal".
-        rule /[^\s'"(),]+/, Literal
+        rule %r/[^\s'"(),]+/, Literal
       end
     end
   end

data/lib/rouge/lexers/igorpro.rb

@@ -521,7 +521,7 @@ module Rouge
       state :root do
         rule %r(//), Comment, :comments
 
-        rule /#{object}/ do |m|
+        rule %r/#{object}/ do |m|
           if m[0].downcase =~ /function/
             token Keyword::Declaration
             push :parse_function
@@ -567,22 +567,22 @@ module Rouge
 
       state :assignment do
         mixin :whitespace
-        rule /\"/, Literal::String::Double, :string1 #punctuation for string
+        rule %r/\"/, Literal::String::Double, :string1 #punctuation for string
         mixin :string2
-        rule /#{number_float}/, Literal::Number::Float, :pop!
-        rule /#{number_int}/, Literal::Number::Integer, :pop!
-        rule /[\(\[\{][^\)\]\}]+[\)\]\}]/, Generic, :pop!
-        rule /[^\s\/\(]+/, Generic, :pop!
+        rule %r/#{number_float}/, Literal::Number::Float, :pop!
+        rule %r/#{number_int}/, Literal::Number::Integer, :pop!
+        rule %r/[\(\[\{][^\)\]\}]+[\)\]\}]/, Generic, :pop!
+        rule %r/[^\s\/\(]+/, Generic, :pop!
         rule(//) { pop! }
       end
 
       state :parse_variables do
         mixin :whitespace
-        rule /[=]/, Punctuation, :assignment
+        rule %r/[=]/, Punctuation, :assignment
         rule object, Name::Variable
-        rule /[\[\]]/, Punctuation # optional variables in functions
-        rule /[,]/, Punctuation, :parse_variables
-        rule /\)/, Punctuation, :pop! # end of function
+        rule %r/[\[\]]/, Punctuation # optional variables in functions
+        rule %r/[,]/, Punctuation, :parse_variables
+        rule %r/\)/, Punctuation, :pop! # end of function
         rule %r([/][a-z]+)i, Keyword::Pseudo, :parse_variables
         rule(//) { pop! }
       end
@@ -591,15 +591,15 @@ module Rouge
         rule %r([/][a-z]+)i, Keyword::Pseudo # only one flag
         mixin :whitespace
         rule object, Name::Function
-        rule /[\(]/, Punctuation, :parse_variables
+        rule %r/[\(]/, Punctuation, :parse_variables
         rule(//) { pop! }
       end
 
       state :operationFlags do
-        rule /#{noLineBreak}/, Text
-        rule /[=]/, Punctuation, :assignment
+        rule %r/#{noLineBreak}/, Text
+        rule %r/[=]/, Punctuation, :assignment
         rule %r([/][a-z]+)i, Keyword::Pseudo, :operationFlags
-        rule /(as)(\s*)(#{object})/i do
+        rule %r/(as)(\s*)(#{object})/i do
           groups Keyword::Type, Text, Name::Label
         end
         rule(//) { pop! }
@@ -621,34 +621,34 @@ module Rouge
       end
 
       state :characters do
-        rule /\s/, Text
-        rule /#{operator}/, Operator
-        rule /#{punctuation}/, Punctuation
-        rule /\"/, Literal::String::Double, :string1 #punctuation for string
+        rule %r/\s/, Text
+        rule %r/#{operator}/, Operator
+        rule %r/#{punctuation}/, Punctuation
+        rule %r/\"/, Literal::String::Double, :string1 #punctuation for string
         mixin :string2
       end
 
       state :numbers do
-        rule /#{number_float}/, Literal::Number::Float
-        rule /#{number_hex}/, Literal::Number::Hex
-        rule /#{number_int}/, Literal::Number::Integer
+        rule %r/#{number_float}/, Literal::Number::Float
+        rule %r/#{number_hex}/, Literal::Number::Hex
+        rule %r/#{number_int}/, Literal::Number::Integer
       end
 
       state :whitespace do
-        rule /#{noLineBreak}/, Text
+        rule %r/#{noLineBreak}/, Text
       end
 
       state :string1 do
-        rule /%\w\b/, Literal::String::Other
-        rule /\\\\/, Literal::String::Escape
-        rule /\\\"/, Literal::String::Escape
-        rule /\\/, Literal::String::Escape
-        rule /[^"]/, Literal::String
-        rule /\"/, Literal::String::Double, :pop! #punctuation for string
+        rule %r/%\w\b/, Literal::String::Other
+        rule %r/\\\\/, Literal::String::Escape
+        rule %r/\\\"/, Literal::String::Escape
+        rule %r/\\/, Literal::String::Escape
+        rule %r/[^"]/, Literal::String
+        rule %r/\"/, Literal::String::Double, :pop! #punctuation for string
       end
 
       state :string2 do
-        rule /\'[^']*\'/, Literal::String::Single
+        rule %r/\'[^']*\'/, Literal::String::Single
       end
 
       state :comments do
@@ -656,7 +656,7 @@ module Rouge
           # doxygen comments
           groups Comment, Comment::Special
         end
-        rule /[^\r\n]/, Comment
+        rule %r/[^\r\n]/, Comment
         rule(//) { pop! }
       end
     end