rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/prometheus.rb

@@ -26,21 +26,21 @@ module Rouge
         mixin :strings
         mixin :whitespace
 
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+[smhdwy]?/, Num::Integer
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+[smhdwy]?/, Num::Integer
 
         mixin :operators
 
-        rule /(ignoring|on)(\()/ do
+        rule %r/(ignoring|on)(\()/ do
           groups Keyword::Pseudo, Punctuation
           push :label_list
         end
-        rule /(group_left|group_right)(\()/ do
+        rule %r/(group_left|group_right)(\()/ do
           groups Keyword::Type, Punctuation
         end
-        rule /(bool|offset)\b/, Keyword
-        rule /(without|by)\b/, Keyword, :label_list
-        rule /[\w:]+/ do |m|
+        rule %r/(bool|offset)\b/, Keyword
+        rule %r/(without|by)\b/, Keyword, :label_list
+        rule %r/[\w:]+/ do |m|
           if self.class.functions.include?(m[0])
             token Name::Builtin
           else
@@ -52,17 +52,17 @@ module Rouge
       end
 
       state :metrics do
-        rule /[a-zA-Z0-9_-]+/, Name
+        rule %r/[a-zA-Z0-9_-]+/, Name
 
-        rule /[\(\)\]:.,]/, Punctuation
-        rule /\{/, Punctuation, :filters
-        rule /\[/, Punctuation
+        rule %r/[\(\)\]:.,]/, Punctuation
+        rule %r/\{/, Punctuation, :filters
+        rule %r/\[/, Punctuation
       end
 
       state :strings do
-        rule /"/, Str::Double, :double_string_escaped
-        rule /'/, Str::Single, :single_string_escaped
-        rule /`.*`/, Str::Backtick
+        rule %r/"/, Str::Double, :double_string_escaped
+        rule %r/'/, Str::Single, :single_string_escaped
+        rule %r/`.*`/, Str::Backtick
       end
 
       [
@@ -70,52 +70,52 @@ module Rouge
         [:single, Str::Single, "'"]
       ].each do |name, tok, fin|
         state :"#{name}_string_escaped" do
-          rule /\\[\\abfnrtv#{fin}]/, Str::Escape
-          rule /[^\\#{fin}]+/m, tok
-          rule /#{fin}/, tok, :pop!
+          rule %r/\\[\\abfnrtv#{fin}]/, Str::Escape
+          rule %r/[^\\#{fin}]+/m, tok
+          rule %r/#{fin}/, tok, :pop!
         end
       end
 
       state :filters do
         mixin :inline_whitespace
-        rule /,/, Punctuation
+        rule %r/,/, Punctuation
         mixin :labels
         mixin :filter_matching_operators
         mixin :strings
-        rule /}/, Punctuation, :pop!
+        rule %r/}/, Punctuation, :pop!
       end
 
       state :label_list do
-        rule /\(/, Punctuation
-        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
-        rule /,/, Punctuation
+        rule %r/\(/, Punctuation
+        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/,/, Punctuation
         mixin :whitespace
-        rule /\)/, Punctuation, :pop!
+        rule %r/\)/, Punctuation, :pop!
       end
 
       state :labels do
-        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
       end
 
       state :operators do
         rule %r([+\-\*/%\^]), Operator  # Arithmetic
         rule %r(=|==|!=|<|>|<=|>=), Operator # Comparison
-        rule /and|or|unless/, Operator # Logical/Set
-        rule /(sum|min|max|avg|stddev|stdvar|count|count_values|bottomk|topk)\b/, Name::Function
+        rule %r/and|or|unless/, Operator # Logical/Set
+        rule %r/(sum|min|max|avg|stddev|stdvar|count|count_values|bottomk|topk)\b/, Name::Function
       end
 
       state :filter_matching_operators do
-        rule /!(=|~)|=~?/, Operator
+        rule %r/!(=|~)|=~?/, Operator
       end
 
       state :inline_whitespace do
-        rule /[ \t\r]+/, Text
+        rule %r/[ \t\r]+/, Text
       end
 
       state :whitespace do
         mixin :inline_whitespace
-        rule /\n\s*/m, Text
-        rule /#.*?$/, Comment
+        rule %r/\n\s*/m, Text
+        rule %r/#.*?$/, Comment
       end
     end
   end

data/lib/rouge/lexers/properties.rb

@@ -14,38 +14,38 @@ 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
       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 /\\u[0-9]{4}/, Str::Escape
-        rule /\\./m, Str::Escape
+        rule %r/\\u[0-9]{4}/, Str::Escape
+        rule %r/\\./m, Str::Escape
       end
     end
   end

data/lib/rouge/lexers/protobuf.rb

@@ -15,55 +15,55 @@ module Rouge
       datatype = /\b(bool|bytes|double|fixed32|fixed64|float|int32|int64|sfixed32|sfixed64|sint32|sint64|string|uint32|uint64)\b/
 
       state :root do
-        rule /[\s]+/, Text
-        rule /[,;{}\[\]()]/, Punctuation
-        rule /\/(\\\n)?\/(\n|(.|\n)*?[^\\]\n)/, Comment::Single
-        rule /\/(\\\n)?\*(.|\n)*?\*(\\\n)?\//, Comment::Multiline
+        rule %r/[\s]+/, Text
+        rule %r/[,;{}\[\]()]/, Punctuation
+        rule %r/\/(\\\n)?\/(\n|(.|\n)*?[^\\]\n)/, Comment::Single
+        rule %r/\/(\\\n)?\*(.|\n)*?\*(\\\n)?\//, Comment::Multiline
         rule kw, Keyword
         rule datatype, Keyword::Type
-        rule /true|false/, Keyword::Constant
-        rule /(package)(\s+)/ do
+        rule %r/true|false/, Keyword::Constant
+        rule %r/(package)(\s+)/ do
           groups Keyword::Namespace, Text
           push :package
         end
 
-        rule /(message|extend)(\s+)/ do
+        rule %r/(message|extend)(\s+)/ do
           groups Keyword::Declaration, Text
           push :message
         end
 
-        rule /(enum|group|service)(\s+)/ do
+        rule %r/(enum|group|service)(\s+)/ do
           groups Keyword::Declaration, Text
           push :type
         end
 
-        rule /".*?"/, Str
-        rule /'.*?'/, Str
-        rule /(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*/, Num::Float
-        rule /(\d+\.\d*|\.\d+|\d+[fF])[fF]?/, Num::Float
-        rule /(\-?(inf|nan))\b/, Num::Float
-        rule /0x[0-9a-fA-F]+[LlUu]*/, Num::Hex
-        rule /0[0-7]+[LlUu]*/, Num::Oct
-        rule /\d+[LlUu]*/, Num::Integer
-        rule /[+-=]/, Operator
-        rule /([a-zA-Z_][\w.]*)([ \t]*)(=)/ do
+        rule %r/".*?"/, Str
+        rule %r/'.*?'/, Str
+        rule %r/(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*/, Num::Float
+        rule %r/(\d+\.\d*|\.\d+|\d+[fF])[fF]?/, Num::Float
+        rule %r/(\-?(inf|nan))\b/, Num::Float
+        rule %r/0x[0-9a-fA-F]+[LlUu]*/, Num::Hex
+        rule %r/0[0-7]+[LlUu]*/, Num::Oct
+        rule %r/\d+[LlUu]*/, Num::Integer
+        rule %r/[+-=]/, Operator
+        rule %r/([a-zA-Z_][\w.]*)([ \t]*)(=)/ do
           groups Name::Attribute, Text, Operator
         end
-        rule /[a-zA-Z_][\w.]*/, Name
+        rule %r/[a-zA-Z_][\w.]*/, Name
       end
 
       state :package do
-        rule /[a-zA-Z_]\w*/, Name::Namespace, :pop!
+        rule %r/[a-zA-Z_]\w*/, Name::Namespace, :pop!
         rule(//) { pop! }
       end
 
       state :message do
-        rule /[a-zA-Z_]\w*/, Name::Class, :pop!
+        rule %r/[a-zA-Z_]\w*/, Name::Class, :pop!
         rule(//) { pop! }
       end
 
       state :type do
-        rule /[a-zA-Z_]\w*/, Name, :pop!
+        rule %r/[a-zA-Z_]\w*/, Name, :pop!
         rule(//) { pop! }
       end
     end

data/lib/rouge/lexers/puppet.rb

@@ -39,15 +39,15 @@ module Rouge
       qualname = /(::)?(#{id}::)*\w+/
 
       state :whitespace do
-        rule /\s+/m, Text
-        rule /#.*?\n/, Comment
+        rule %r/\s+/m, Text
+        rule %r/#.*?\n/, Comment
       end
 
       state :root do
         mixin :whitespace
 
-        rule /[$]#{qualname}/, Name::Variable
-        rule /(#{id})(?=\s*[=+]>)/m do |m|
+        rule %r/[$]#{qualname}/, Name::Variable
+        rule %r/(#{id})(?=\s*[=+]>)/m do |m|
           if self.class.metaparameters.include? m[0]
             token Keyword::Pseudo
           else
@@ -55,31 +55,31 @@ module Rouge
           end
         end
 
-        rule /(#{qualname})(?=\s*[(])/m, Name::Function
+        rule %r/(#{qualname})(?=\s*[(])/m, Name::Function
         rule cap_id, Name::Class
 
-        rule /[+=|~-]>|<[|~-]/, Punctuation
-        rule /[:}();\[\]]/, Punctuation
+        rule %r/[+=|~-]>|<[|~-]/, Punctuation
+        rule %r/[:}();\[\]]/, Punctuation
 
         # HACK for case statements and selectors
-        rule /{/, Punctuation, :regex_allowed
-        rule /,/, Punctuation, :regex_allowed
+        rule %r/{/, Punctuation, :regex_allowed
+        rule %r/,/, Punctuation, :regex_allowed
 
-        rule /(in|and|or)\b/, Operator::Word
-        rule /[=!<>]=/, Operator
-        rule /[=!]~/, Operator, :regex_allowed
+        rule %r/(in|and|or)\b/, Operator::Word
+        rule %r/[=!<>]=/, Operator
+        rule %r/[=!]~/, Operator, :regex_allowed
         rule %r([=<>!+*/-]), Operator
 
-        rule /(class|include)(\s*)(#{qualname})/ do
+        rule %r/(class|include)(\s*)(#{qualname})/ do
           groups Keyword, Text, Name::Class
         end
 
-        rule /node\b/, Keyword, :regex_allowed
+        rule %r/node\b/, Keyword, :regex_allowed
 
-        rule /'(\\[\\']|[^'])*'/m, Str::Single
-        rule /"/, Str::Double, :dquotes
+        rule %r/'(\\[\\']|[^'])*'/m, Str::Single
+        rule %r/"/, Str::Double, :dquotes
 
-        rule /\d+([.]\d+)?(e[+-]\d+)?/, Num
+        rule %r/\d+([.]\d+)?(e[+-]\d+)?/, Num
 
         # a valid regex.  TODO: regexes are only allowed
         # in certain places in puppet.
@@ -103,26 +103,26 @@ module Rouge
 
       state :regex do
         rule %r(/), Str::Regex, :pop!
-        rule /\\./, Str::Escape
-        rule /[(){}]/, Str::Interpol
-        rule /\[/, Str::Interpol, :regex_class
-        rule /./, Str::Regex
+        rule %r/\\./, Str::Escape
+        rule %r/[(){}]/, Str::Interpol
+        rule %r/\[/, Str::Interpol, :regex_class
+        rule %r/./, Str::Regex
       end
 
       state :regex_class do
-        rule /\]/, Str::Interpol, :pop!
-        rule /(?<!\[)-(?=\])/, Str::Regex
-        rule /-/, Str::Interpol
-        rule /\\./, Str::Escape
-        rule /[^\\\]-]+/, Str::Regex
+        rule %r/\]/, Str::Interpol, :pop!
+        rule %r/(?<!\[)-(?=\])/, Str::Regex
+        rule %r/-/, Str::Interpol
+        rule %r/\\./, Str::Escape
+        rule %r/[^\\\]-]+/, Str::Regex
       end
 
       state :dquotes do
-        rule /"/, Str::Double, :pop!
-        rule /[^$\\"]+/m, Str::Double
-        rule /\\./m, Str::Escape
-        rule /[$]#{qualname}/, Name::Variable
-        rule /[$][{]#{qualname}[}]/, Name::Variable
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^$\\"]+/m, Str::Double
+        rule %r/\\./m, Str::Escape
+        rule %r/[$]#{qualname}/, Name::Variable
+        rule %r/[$][{]#{qualname}[}]/, Name::Variable
       end
     end
   end

data/lib/rouge/lexers/python.rb

@@ -12,7 +12,7 @@ module Rouge
       mimetypes 'text/x-python', 'application/x-python'
 
       def self.detect?(text)
-        return true if text.shebang?(/pythonw?(3|2(\.\d)?)?/)
+        return true if text.shebang?(/pythonw?(?:[23](?:\.\d+)?)?/)
       end
 
       def self.keywords
@@ -69,23 +69,23 @@ module Rouge
       identifier =        /[a-z_][a-z0-9_]*/i
       dotted_identifier = /[a-z_.][a-z0-9_.]*/i
       state :root do
-        rule /\n+/m, Text
-        rule /^(:)(\s*)([ru]{,2}""".*?""")/mi do
+        rule %r/\n+/m, Text
+        rule %r/^(:)(\s*)([ru]{,2}""".*?""")/mi do
           groups Punctuation, Text, Str::Doc
         end
 
-        rule /[^\S\n]+/, Text
+        rule %r/[^\S\n]+/, Text
         rule %r(#(.*)?\n?), Comment::Single
-        rule /[\[\]{}:(),;]/, Punctuation
-        rule /\\\n/, Text
-        rule /\\/, Text
+        rule %r/[\[\]{}:(),;]/, Punctuation
+        rule %r/\\\n/, Text
+        rule %r/\\/, Text
 
-        rule /(in|is|and|or|not)\b/, Operator::Word
-        rule /(<<|>>|\/\/|\*\*)=?/, Operator
-        rule /[-~+\/*%=<>&^|@]=?|!=/, Operator
-        rule /\.(?![0-9])/, Operator  # so it doesn't match float literals
+        rule %r/(in|is|and|or|not)\b/, Operator::Word
+        rule %r/(<<|>>|\/\/|\*\*)=?/, Operator
+        rule %r/[-~+\/*%=<>&^|@]=?|!=/, Operator
+        rule %r/\.(?![0-9])/, Operator  # so it doesn't match float literals
 
-        rule /(from)((?:\\\s|\s)+)(#{dotted_identifier})((?:\\\s|\s)+)(import)/ do
+        rule %r/(from)((?:\\\s|\s)+)(#{dotted_identifier})((?:\\\s|\s)+)(import)/ do
           groups Keyword::Namespace,
                  Text,
                  Name::Namespace,
@@ -93,35 +93,35 @@ module Rouge
                  Keyword::Namespace
         end
 
-        rule /(import)(\s+)(#{dotted_identifier})/ do
+        rule %r/(import)(\s+)(#{dotted_identifier})/ do
           groups Keyword::Namespace, Text, Name::Namespace
         end
 
-        rule /(def)((?:\s|\\\s)+)/ do
+        rule %r/(def)((?:\s|\\\s)+)/ do
           groups Keyword, Text
           push :funcname
         end
 
-        rule /(class)((?:\s|\\\s)+)/ do
+        rule %r/(class)((?:\s|\\\s)+)/ do
           groups Keyword, Text
           push :classname
         end
 
         # TODO: not in python 3
-        rule /`.*?`/, Str::Backtick
-        rule /(?:r|ur|ru)"""/i, Str, :raw_tdqs
-        rule /(?:r|ur|ru)'''/i, Str, :raw_tsqs
-        rule /(?:r|ur|ru)"/i,   Str, :raw_dqs
-        rule /(?:r|ur|ru)'/i,   Str, :raw_sqs
-        rule /u?"""/i,          Str, :tdqs
-        rule /u?'''/i,          Str, :tsqs
-        rule /u?"/i,            Str, :dqs
-        rule /u?'/i,            Str, :sqs
-
-        rule /@#{dotted_identifier}/i, Name::Decorator
+        rule %r/`.*?`/, Str::Backtick
+        rule %r/(?:r|ur|ru)"""/i, Str, :raw_tdqs
+        rule %r/(?:r|ur|ru)'''/i, Str, :raw_tsqs
+        rule %r/(?:r|ur|ru)"/i,   Str, :raw_dqs
+        rule %r/(?:r|ur|ru)'/i,   Str, :raw_sqs
+        rule %r/u?"""/i,          Str, :tdqs
+        rule %r/u?'''/i,          Str, :tsqs
+        rule %r/u?"/i,            Str, :dqs
+        rule %r/u?'/i,            Str, :sqs
+
+        rule %r/@#{dotted_identifier}/i, Name::Decorator
 
         # using negative lookbehind so we don't match property names
-        rule /(?<!\.)#{identifier}/ do |m|
+        rule %r/(?<!\.)#{identifier}/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
           elsif self.class.exceptions.include? m[0]
@@ -140,15 +140,15 @@ module Rouge
         digits = /[0-9](_?[0-9])*/
         decimal = /((#{digits})?\.#{digits}|#{digits}\.)/
         exponent = /e[+-]?#{digits}/i
-        rule /#{decimal}(#{exponent})?j?/i, Num::Float
-        rule /#{digits}#{exponent}j?/i, Num::Float
-        rule /#{digits}j/i, Num::Float
+        rule %r/#{decimal}(#{exponent})?j?/i, Num::Float
+        rule %r/#{digits}#{exponent}j?/i, Num::Float
+        rule %r/#{digits}j/i, Num::Float
 
-        rule /0b(_?[0-1])+/i, Num::Bin
-        rule /0o(_?[0-7])+/i, Num::Oct
-        rule /0x(_?[a-f0-9])+/i, Num::Hex
-        rule /\d+L/, Num::Integer::Long
-        rule /([1-9](_?[0-9])*|0(_?0)*)/, Num::Integer
+        rule %r/0b(_?[0-1])+/i, Num::Bin
+        rule %r/0o(_?[0-7])+/i, Num::Oct
+        rule %r/0x(_?[a-f0-9])+/i, Num::Hex
+        rule %r/\d+L/, Num::Integer::Long
+        rule %r/([1-9](_?[0-9])*|0(_?0)*)/, Num::Integer
       end
 
       state :funcname do
@@ -160,11 +160,11 @@ module Rouge
       end
 
       state :raise do
-        rule /from\b/, Keyword
-        rule /raise\b/, Keyword
-        rule /yield\b/, Keyword
-        rule /\n/, Text, :pop!
-        rule /;/, Punctuation, :pop!
+        rule %r/from\b/, Keyword
+        rule %r/raise\b/, Keyword
+        rule %r/yield\b/, Keyword
+        rule %r/\n/, Text, :pop!
+        rule %r/;/, Punctuation, :pop!
         mixin :root
       end
 
@@ -173,28 +173,28 @@ module Rouge
       end
 
       state :strings do
-        rule /%(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, Str::Interpol
+        rule %r/%(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, Str::Interpol
       end
 
       state :strings_double do
-        rule /[^\\"%\n]+/, Str
+        rule %r/[^\\"%\n]+/, Str
         mixin :strings
       end
 
       state :strings_single do
-        rule /[^\\'%\n]+/, Str
+        rule %r/[^\\'%\n]+/, Str
         mixin :strings
       end
 
       state :nl do
-        rule /\n/, Str
+        rule %r/\n/, Str
       end
 
       state :escape do
         rule %r(\\
           ( [\\abfnrtv"']
           | \n
-          | N{[a-zA-z][a-zA-Z ]+[a-zA-Z]}
+          | N{[a-zA-Z][a-zA-Z ]+[a-zA-Z]}
           | u[a-fA-F0-9]{4}
           | U[a-fA-F0-9]{8}
           | x[a-fA-F0-9]{2}
@@ -204,32 +204,32 @@ module Rouge
       end
 
       state :raw_escape do
-        rule /\\./, Str
+        rule %r/\\./, Str
       end
 
       state :dqs do
-        rule /"/, Str, :pop!
+        rule %r/"/, Str, :pop!
         mixin :escape
         mixin :strings_double
       end
 
       state :sqs do
-        rule /'/, Str, :pop!
+        rule %r/'/, Str, :pop!
         mixin :escape
         mixin :strings_single
       end
 
       state :tdqs do
-        rule /"""/, Str, :pop!
-        rule /"/, Str
+        rule %r/"""/, Str, :pop!
+        rule %r/"/, Str
         mixin :escape
         mixin :strings_double
         mixin :nl
       end
 
       state :tsqs do
-        rule /'''/, Str, :pop!
-        rule /'/, Str
+        rule %r/'''/, Str, :pop!
+        rule %r/'/, Str
         mixin :escape
         mixin :strings_single
         mixin :nl