rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/pascal.rb

@@ -40,7 +40,7 @@ module Rouge
 
       state :whitespace do
         # Spaces
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         # // Comments
         rule %r((//).*$\n?), Comment::Single
         # -- Comments
@@ -57,9 +57,9 @@ module Rouge
         rule %r{((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?}, Num
         rule %r{[~!@#\$%\^&\*\(\)\+`\-={}\[\]:;<>\?,\.\/\|\\]}, Punctuation
         rule %r{'([^']|'')*'}, Str
-        rule /(true|false|nil)\b/i, Name::Builtin
-        rule /\b(#{keywords.join('|')})\b/i, Keyword
-        rule /\b(#{keywords_type.join('|')})\b/i, Keyword::Type
+        rule %r/(true|false|nil)\b/i, Name::Builtin
+        rule %r/\b(#{keywords.join('|')})\b/i, Keyword
+        rule %r/\b(#{keywords_type.join('|')})\b/i, Keyword::Type
         rule id, Name
       end
     end

data/lib/rouge/lexers/perl.rb

@@ -65,17 +65,17 @@ module Rouge
       end
 
       state :root do
-        rule /#.*?$/, Comment::Single
-        rule /^=[a-zA-Z0-9]+\s+.*?\n=cut/m, Comment::Multiline
-        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/#.*?$/, Comment::Single
+        rule %r/^=[a-zA-Z0-9]+\s+.*?\n=cut/m, Comment::Multiline
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
 
-        rule /(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
+        rule %r/(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
           groups Keyword, Text, Name, Text, Punctuation, Text
 
           push :format
         end
 
-        rule /(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
+        rule %r/(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
 
         # common delimiters
         rule %r(s/(\\\\|\\/|[^/])*/(\\\\|\\/|[^/])*/[msixpodualngc]*), re_tok
@@ -100,103 +100,103 @@ module Rouge
         rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[msixpodualngc]*),
           re_tok, :balanced_regex
 
-        rule /\s+/, Text
-        rule /(?:#{builtins.join('|')})\b/, Name::Builtin
-        rule /((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b/,
+        rule %r/\s+/, Text
+        rule %r/(?:#{builtins.join('|')})\b/, Name::Builtin
+        rule %r/((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b/,
           Name::Builtin::Pseudo
 
-        rule /<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
+        rule %r/<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
 
-        rule /__END__\b/, Comment::Preproc, :end_part
-        rule /\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
-        rule /\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
-        rule /[-+\/*%=<>&^\|!\\~]=?/, Operator
-        rule /[$@%#]+/, Name::Variable, :varname
+        rule %r/__END__\b/, Comment::Preproc, :end_part
+        rule %r/\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
+        rule %r/\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
+        rule %r/[-+\/*%=<>&^\|!\\~]=?/, Operator
+        rule %r/[$@%#]+/, Name::Variable, :varname
 
-        rule /0_?[0-7]+(_[0-7]+)*/, Num::Oct
-        rule /0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
-        rule /0b[01]+(_[01]+)*/, Num::Bin
-        rule /(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
+        rule %r/0_?[0-7]+(_[0-7]+)*/, Num::Oct
+        rule %r/0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
+        rule %r/0b[01]+(_[01]+)*/, Num::Bin
+        rule %r/(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
           Num::Float
-        rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
-        rule /\d+(_\d+)*/, Num::Integer
-
-        rule /'/, Punctuation, :sq
-        rule /"/, Punctuation, :dq
-        rule /`/, Punctuation, :bq
-        rule /<([^\s>]+)>/, re_tok
-        rule /(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
-        rule /(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
-        rule /(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
-        rule /(q|qq|qw|qr|qx)</, Str::Other, :lt_string
-        rule /(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
-
-        rule /package\s+/, Keyword, :modulename
-        rule /sub\s+/, Keyword, :funcname
-        rule /\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
+        rule %r/\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
+        rule %r/\d+(_\d+)*/, Num::Integer
+
+        rule %r/'/, Punctuation, :sq
+        rule %r/"/, Punctuation, :dq
+        rule %r/`/, Punctuation, :bq
+        rule %r/<([^\s>]+)>/, re_tok
+        rule %r/(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
+        rule %r/(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
+        rule %r/(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
+        rule %r/(q|qq|qw|qr|qx)</, Str::Other, :lt_string
+        rule %r/(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
+
+        rule %r/package\s+/, Keyword, :modulename
+        rule %r/sub\s+/, Keyword, :funcname
+        rule %r/\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
           Operator
-        rule /[()\[\]:;,<>\/?{}]/, Punctuation
+        rule %r/[()\[\]:;,<>\/?{}]/, Punctuation
         rule(/(?=\w)/) { push :name }
       end
 
       state :format do
-        rule /\.\n/, Str::Interpol, :pop!
-        rule /.*?\n/, Str::Interpol
+        rule %r/\.\n/, Str::Interpol, :pop!
+        rule %r/.*?\n/, Str::Interpol
       end
 
       state :name_common do
-        rule /\w+::/, Name::Namespace
-        rule /[\w:]+/, Name::Variable, :pop!
+        rule %r/\w+::/, Name::Namespace
+        rule %r/[\w:]+/, Name::Variable, :pop!
       end
 
       state :varname do
-        rule /\s+/, Text
-        rule /\{/, Punctuation, :pop! # hash syntax
-        rule /\)|,/, Punctuation, :pop! # arg specifier
+        rule %r/\s+/, Text
+        rule %r/\{/, Punctuation, :pop! # hash syntax
+        rule %r/\)|,/, Punctuation, :pop! # arg specifier
         mixin :name_common
       end
 
       state :name do
         mixin :name_common
-        rule /[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
+        rule %r/[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
         rule(/(?=\W)/) { pop! }
       end
 
       state :modulename do
-        rule /[a-z_]\w*/i, Name::Namespace, :pop!
+        rule %r/[a-z_]\w*/i, Name::Namespace, :pop!
       end
 
       state :funcname do
-        rule /[a-zA-Z_]\w*[!?]?/, Name::Function
-        rule /\s+/, Text
+        rule %r/[a-zA-Z_]\w*[!?]?/, Name::Function
+        rule %r/\s+/, Text
 
         # argument declaration
-        rule /(\([$@%]*\))(\s*)/ do
+        rule %r/(\([$@%]*\))(\s*)/ do
           groups Punctuation, Text
         end
 
-        rule /.*?{/, Punctuation, :pop!
-        rule /;/, Punctuation, :pop!
+        rule %r/.*?{/, Punctuation, :pop!
+        rule %r/;/, Punctuation, :pop!
       end
 
       state :sq do
-        rule /\\[']/, Str::Escape
-        rule /[^\\']+/, Str::Single
-        rule /'/, Punctuation, :pop!
+        rule %r/\\[']/, Str::Escape
+        rule %r/[^\\']+/, Str::Single
+        rule %r/'/, Punctuation, :pop!
       end
 
       state :dq do
         mixin :string_intp
-        rule /\\[\\tnr"]/, Str::Escape
-        rule /[^\\"]+?/, Str::Double
-        rule /"/, Punctuation, :pop!
+        rule %r/\\[\\tnr"]/, Str::Escape
+        rule %r/[^\\"]+?/, Str::Double
+        rule %r/"/, Punctuation, :pop!
       end
 
       state :bq do
         mixin :string_intp
-        rule /\\[\\tnr`]/, Str::Escape
-        rule /[^\\`]+?/, Str::Backtick
-        rule /`/, Punctuation, :pop!
+        rule %r/\\[\\tnr`]/, Str::Escape
+        rule %r/[^\\`]+?/, Str::Backtick
+        rule %r/`/, Punctuation, :pop!
       end
 
       [[:cb, '\{', '\}'],
@@ -205,28 +205,28 @@ module Rouge
        [:lt, '<',  '>']].each do |name, open, close|
         tok = Str::Other
         state :"#{name}_string" do
-          rule /\\[#{open}#{close}\\]/, tok
-          rule /\\/, tok
+          rule %r/\\[#{open}#{close}\\]/, tok
+          rule %r/\\/, tok
           rule(/#{open}/) { token tok; push }
-          rule /#{close}/, tok, :pop!
-          rule /[^#{open}#{close}\\]+/, tok
+          rule %r/#{close}/, tok, :pop!
+          rule %r/[^#{open}#{close}\\]+/, tok
         end
       end
 
       state :in_interp do
-        rule /}/, Str::Interpol, :pop!
-        rule /\s+/, Text
-        rule /[a-z_]\w*/i, Str::Interpol
+        rule %r/}/, Str::Interpol, :pop!
+        rule %r/\s+/, Text
+        rule %r/[a-z_]\w*/i, Str::Interpol
       end
 
       state :string_intp do
-        rule /[$@][{]/, Str::Interpol, :in_interp
-        rule /[$@][a-z_]\w*/i, Str::Interpol
+        rule %r/[$@][{]/, Str::Interpol, :in_interp
+        rule %r/[$@][a-z_]\w*/i, Str::Interpol
       end
 
       state :end_part do
         # eat the rest of the stream
-        rule /.+/m, Comment::Preproc, :pop!
+        rule %r/.+/m, Comment::Preproc, :pop!
       end
     end
   end

data/lib/rouge/lexers/php.rb

@@ -29,7 +29,7 @@ module Rouge
       end
 
       def self.builtins
-        load Pathname.new(__FILE__).dirname.join('php/builtins.rb')
+        load File.join(__dir__, 'php/builtins.rb')
         self.builtins
       end
 
@@ -91,49 +91,49 @@ module Rouge
       end
 
       state :template do
-        rule /<\?(php|=)?/, Comment::Preproc, :php
+        rule %r/<\?(php|=)?/, Comment::Preproc, :php
         rule(/.*?(?=<\?)|.*/m) { delegate parent }
       end
 
       state :php do
-        rule /\?>/, Comment::Preproc, :pop!
+        rule %r/\?>/, Comment::Preproc, :pop!
         # heredocs
-        rule /<<<('?)(#{id})\1\n.*?\n\2;?\n/im, Str::Heredoc
-        rule /\s+/, Text
-        rule /#.*?$/, Comment::Single
+        rule %r/<<<('?)(#{id})\1\n.*?\n\2;?\n/im, Str::Heredoc
+        rule %r/\s+/, Text
+        rule %r/#.*?$/, Comment::Single
         rule %r(//.*?$), Comment::Single
         # empty comment, otherwise seen as the start of a docstring
         rule %r(/\*\*/), Comment::Multiline
         rule %r(/\*\*.*?\*/)m, Str::Doc
         rule %r(/\*.*?\*/)m, Comment::Multiline
-        rule /(->|::)(\s*)(#{id})/ do
+        rule %r/(->|::)(\s*)(#{id})/ do
           groups Operator, Text, Name::Attribute
         end
 
-        rule /[~!%^&*+=\|:.<>\/?@-]+/, Operator
-        rule /[\[\]{}();,]/, Punctuation
-        rule /class\b/, Keyword, :classname
+        rule %r/[~!%^&*+=\|:.<>\/?@-]+/, Operator
+        rule %r/[\[\]{}();,]/, Punctuation
+        rule %r/class\b/, Keyword, :classname
         # anonymous functions
-        rule /(function)(\s*)(?=\()/ do
+        rule %r/(function)(\s*)(?=\()/ do
           groups Keyword, Text
         end
 
         # named functions
-        rule /(function)(\s+)(&?)(\s*)/ do
+        rule %r/(function)(\s+)(&?)(\s*)/ do
           groups Keyword, Text, Operator, Text
           push :funcname
         end
 
-        rule /(const)(\s+)(#{id})/i do
+        rule %r/(const)(\s+)(#{id})/i do
           groups Keyword, Text, Name::Constant
         end
 
-        rule /(true|false|null)\b/, Keyword::Constant
-        rule /\$\{\$+#{id}\}/i, Name::Variable
-        rule /\$+#{id}/i, Name::Variable
+        rule %r/(true|false|null)\b/, Keyword::Constant
+        rule %r/\$\{\$+#{id}\}/i, Name::Variable
+        rule %r/\$+#{id}/i, Name::Variable
 
         # may be intercepted for builtin highlighting
-        rule /\\?#{nsid}/i do |m|
+        rule %r/\\?#{nsid}/i do |m|
           name = m[0]
 
           if self.class.keywords.include? name
@@ -145,48 +145,48 @@ module Rouge
           end
         end
 
-        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, Num::Float
-        rule /\d+e[+-]?\d+/i, Num::Float
-        rule /0[0-7]+/, Num::Oct
-        rule /0x[a-f0-9]+/i, Num::Hex
-        rule /\d+/, Num::Integer
-        rule /'([^'\\]*(?:\\.[^'\\]*)*)'/, Str::Single
-        rule /`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
-        rule /"/, Str::Double, :string
+        rule %r/(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, Num::Float
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/0[0-7]+/, Num::Oct
+        rule %r/0x[a-f0-9]+/i, Num::Hex
+        rule %r/\d+/, Num::Integer
+        rule %r/'([^'\\]*(?:\\.[^'\\]*)*)'/, Str::Single
+        rule %r/`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
+        rule %r/"/, Str::Double, :string
       end
 
       state :classname do
-        rule /\s+/, Text
-        rule /#{nsid}/, Name::Class, :pop!
+        rule %r/\s+/, Text
+        rule %r/#{nsid}/, Name::Class, :pop!
       end
 
       state :funcname do
-        rule /#{id}/, Name::Function, :pop!
+        rule %r/#{id}/, Name::Function, :pop!
       end
 
       state :string do
-        rule /"/, Str::Double, :pop!
-        rule /[^\\{$"]+/, Str::Double
-        rule /\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})/,
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^\\{$"]+/, Str::Double
+        rule %r/\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})/,
           Str::Escape
-        rule /\$#{id}(\[\S+\]|->#{id})?/, Name::Variable
+        rule %r/\$#{id}(\[\S+\]|->#{id})?/, Name::Variable
 
-        rule /\{\$\{/, Str::Interpol, :interp_double
-        rule /\{(?=\$)/, Str::Interpol, :interp_single
-        rule /(\{)(\S+)(\})/ do
+        rule %r/\{\$\{/, Str::Interpol, :interp_double
+        rule %r/\{(?=\$)/, Str::Interpol, :interp_single
+        rule %r/(\{)(\S+)(\})/ do
           groups Str::Interpol, Name::Variable, Str::Interpol
         end
 
-        rule /[${\\]+/, Str::Double
+        rule %r/[${\\]+/, Str::Double
       end
 
       state :interp_double do
-        rule /\}\}/, Str::Interpol, :pop!
+        rule %r/\}\}/, Str::Interpol, :pop!
         mixin :php
       end
 
       state :interp_single do
-        rule /\}/, Str::Interpol, :pop!
+        rule %r/\}/, Str::Interpol, :pop!
         mixin :php
       end
     end

data/lib/rouge/lexers/plist.rb

@@ -6,41 +6,41 @@ module Rouge
       desc 'plist'
       tag 'plist'
       aliases 'plist'
-      filenames *%w(*.plist *.pbxproj)
+      filenames '*.plist', '*.pbxproj'
 
       mimetypes 'text/x-plist', 'application/x-plist'
 
       state :whitespace do
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
       end
 
       state :root do
         rule %r{//.*$}, Comment
         rule %r{/\*.+?\*/}m, Comment
         mixin :whitespace
-        rule /{/, Punctuation, :dictionary
-        rule /\(/, Punctuation, :array
-        rule /"([^"\\]|\\.)*"/, Literal::String::Double
-        rule /'([^'\\]|\\.)*'/, Literal::String::Single
-        rule /</, Punctuation, :data
-        rule %r{[\w_$/:.-]+}, Literal
+        rule %r/{/, Punctuation, :dictionary
+        rule %r/\(/, Punctuation, :array
+        rule %r/"([^"\\]|\\.)*"/, Literal::String::Double
+        rule %r/'([^'\\]|\\.)*'/, Literal::String::Single
+        rule %r/</, Punctuation, :data
+        rule %r{[\w$/:.-]+}, Literal
       end
 
       state :dictionary do
         mixin :root
-        rule /[=;]/, Punctuation
-        rule /}/, Punctuation, :pop!
+        rule %r/[=;]/, Punctuation
+        rule %r/}/, Punctuation, :pop!
       end
 
       state :array do
         mixin :root
-        rule /[,]/, Punctuation
-        rule /\)/, Punctuation, :pop!
+        rule %r/[,]/, Punctuation
+        rule %r/\)/, Punctuation, :pop!
       end
 
       state :data do
-        rule /[\h\s]+/, Literal::Number::Hex
-        rule />/, Punctuation, :pop!
+        rule %r/[\h\s]+/, Literal::Number::Hex
+        rule %r/>/, Punctuation, :pop!
       end
     end
   end

data/lib/rouge/lexers/pony.rb

@@ -40,28 +40,28 @@ module Rouge
       )
 
       state :whitespace do
-        rule /[\s\t\r\n]+/m, Text
+        rule %r/\s+/m, Text
       end
 
       state :root do
         mixin :whitespace
-        rule /"""/, Str::Doc, :docstring
+        rule %r/"""/, Str::Doc, :docstring
         rule %r{//(.*?)\n}, Comment::Single
         rule %r{/(\\\n)?[*](.|\n)*?[*](\\\n)?/}, Comment::Multiline
-        rule /"/, Str, :string
+        rule %r/"/, Str, :string
         rule %r([~!%^&*+=\|?:<>/-]), Operator
-        rule /(true|false|NULL)\b/, Name::Constant
+        rule %r/(true|false|NULL)\b/, Name::Constant
         rule %r{(?:[A-Z_][a-zA-Z0-9_]*)}, Name::Class
-        rule /[()\[\],.';]/, Punctuation
+        rule %r/[()\[\],.';]/, Punctuation
 
         # Numbers
-        rule /0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
-        rule /[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
-        rule /\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
-        rule /0[xX][0-9a-fA-F_]+/, Num::Hex
-        rule /(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
+        rule %r/0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
+        rule %r/[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
+        rule %r/\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
+        rule %r/0[xX][0-9a-fA-F_]+/, Num::Hex
+        rule %r/(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
 
-        rule /[a-z_][a-z0-9_]*/io do |m|
+        rule %r/[a-z_][a-z0-9_]*/io do |m|
           match = m[0]
 
           if capabilities.include?(match)
@@ -77,17 +77,17 @@ module Rouge
       end
 
       state :string do
-        rule /"/, Str, :pop!
-        rule /\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
-        rule /[^\\"\n]+/, Str
-        rule /\\\n/, Str
-        rule /\\/, Str # stray backslash
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\\n/, Str
+        rule %r/\\/, Str # stray backslash
       end
 
       state :docstring do
-        rule /"""/, Str::Doc, :pop!
-        rule /\n/, Str::Doc
-        rule /./, Str::Doc
+        rule %r/"""/, Str::Doc, :pop!
+        rule %r/\n/, Str::Doc
+        rule %r/./, Str::Doc
       end
     end
   end