rouge 3.3.0 → 3.8.0

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([=<>!+*/-]), Operator
+        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

data/lib/rouge/lexers/q.rb

@@ -36,23 +36,23 @@ module Rouge
 
       state :root do
         # q allows a file to start with a shebang
-        rule /#!(.*?)$/, Comment::Preproc, :top
-        rule //, Text, :top
+        rule %r/#!(.*?)$/, Comment::Preproc, :top
+        rule %r//, Text, :top
       end
 
       state :top do
         # indented lines at the top of the file are ignored by q
-        rule /^[ \t\r]+.*$/, Comment::Special
-        rule /\n+/, Text
-        rule //, Text, :base
+        rule %r/^[ \t\r]+.*$/, Comment::Special
+        rule %r/\n+/, Text
+        rule %r//, Text, :base
       end
 
       state :base do
-        rule /\n+/m, Text
+        rule %r/\n+/m, Text
         rule(/^.\)/, Keyword::Declaration)
 
         # Identifiers, word operators, etc.
-        rule /#{identifier}/ do |m|
+        rule %r/#{identifier}/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
           elsif self.class.word_operators.include? m[0]
@@ -102,7 +102,7 @@ module Rouge
         rule(%r{(`:[:a-z0-9._\/]*|`(?:[a-z0-9.][:a-z0-9._]*)?)}i, Str::Symbol)
         rule(/(?:<=|>=|<>|::)|[?:$%&|@._#*^\-+~,!><=]:?/, Operator)
 
-        rule /[{}\[\]();]/, Punctuation
+        rule %r/[{}\[\]();]/, Punctuation
 
         # commands
         rule(/\\.*\n/, Text)
@@ -111,13 +111,13 @@ module Rouge
 
       state :string do
         rule(/"/, Str, :pop!)
-        rule /\\([\\nr]|[01][0-7]{2})/, Str::Escape
-        rule /[^\\"\n]+/, Str
-        rule /\\/, Str # stray backslash
+        rule %r/\\([\\nr]|[01][0-7]{2})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\/, Str # stray backslash
       end
 
       state :bottom do
-        rule /.*\z/m, Comment::Multiline
+        rule %r/.*\z/m, Comment::Multiline
       end
     end
   end