rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/mathematica.rb

@@ -56,18 +56,18 @@ module Rouge
 
       # The list of built-in symbols comes from a wolfram server and is created automatically by rake
       def self.builtins
-        load Pathname.new(__FILE__).dirname.join('mathematica/builtins.rb')
+        load File.join(__dir__, 'mathematica/builtins.rb')
         self.builtins
       end
 
       state :root do
-        rule /\s+/, Text::Whitespace
-        rule /\(\*/, Comment, :comment
-        rule /#{base}\^\^#{number_base}#{precision}?(\*\^[+-]?\d+)?/, Num # a number with a base
-        rule /(?:#{number}#{precision}?(?:\*\^[+-]?\d+)?)/, Num # all other numbers
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\(\*/, Comment, :comment
+        rule %r/#{base}\^\^#{number_base}#{precision}?(\*\^[+-]?\d+)?/, Num # a number with a base
+        rule %r/(?:#{number}#{precision}?(?:\*\^[+-]?\d+)?)/, Num # all other numbers
         rule message, Name::Tag
         rule in_out, Generic::Prompt
-        rule /#{context_symbol}/m do |m|
+        rule %r/#{context_symbol}/m do |m|
           match = m[0]
           if self.class.keywords.include? match
             token Name::Builtin::Pseudo
@@ -85,11 +85,11 @@ module Rouge
 
       # Allow for nested comments and special treatment of ::Section:: or :Author: markup
       state :comment do
-        rule /\(\*/, Comment, :comment
-        rule /\*\)/, Comment, :pop!
-        rule /::#{identifier}::/, Comment::Preproc
-        rule /[ ]:(#{identifier}|[^\S])+:[ ]/, Comment::Preproc
-        rule /./, Comment
+        rule %r/\(\*/, Comment, :comment
+        rule %r/\*\)/, Comment, :pop!
+        rule %r/::#{identifier}::/, Comment::Preproc
+        rule %r/[ ]:(#{identifier}|[^\S])+:[ ]/, Comment::Preproc
+        rule %r/./, Comment
       end
     end
   end

data/lib/rouge/lexers/matlab.rb

@@ -19,25 +19,25 @@ module Rouge
       end
 
       def self.builtins
-        load Pathname.new(__FILE__).dirname.join('matlab/builtins.rb')
+        load File.join(__dir__, 'matlab/builtins.rb')
         self.builtins
       end
 
       state :root do
-        rule /\s+/m, Text # Whitespace
+        rule %r/\s+/m, Text # Whitespace
         rule %r([{]%.*?%[}])m, Comment::Multiline
-        rule /%.*$/, Comment::Single
-        rule /([.][.][.])(.*?)$/ do
+        rule %r/%.*$/, Comment::Single
+        rule %r/([.][.][.])(.*?)$/ do
           groups(Keyword, Comment)
         end
 
-        rule /^(!)(.*?)(?=%|$)/ do |m|
+        rule %r/^(!)(.*?)(?=%|$)/ do |m|
           token Keyword, m[1]
           delegate Shell, m[2]
         end
 
 
-        rule /[a-zA-Z][_a-zA-Z0-9]*/m do |m|
+        rule %r/[a-zA-Z][_a-zA-Z0-9]*/m do |m|
           match = m[0]
           if self.class.keywords.include? match
             token Keyword
@@ -50,29 +50,29 @@ module Rouge
 
         rule %r{[(){};:,\/\\\]\[]}, Punctuation
 
-        rule /~=|==|<<|>>|[-~+\/*%=<>&^|.@]/, Operator
+        rule %r/~=|==|<<|>>|[-~+\/*%=<>&^|.@]/, Operator
 
 
-        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
-        rule /\d+e[+-]?[0-9]+/i, Num::Float
-        rule /\d+L/, Num::Integer::Long
-        rule /\d+/, Num::Integer
+        rule %r/(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
+        rule %r/\d+e[+-]?[0-9]+/i, Num::Float
+        rule %r/\d+L/, Num::Integer::Long
+        rule %r/\d+/, Num::Integer
 
-        rule /'(?=(.*'))/, Str::Single, :chararray
-        rule /"(?=(.*"))/, Str::Double, :string
-        rule /'/, Operator
+        rule %r/'(?=(.*'))/, Str::Single, :chararray
+        rule %r/"(?=(.*"))/, Str::Double, :string
+        rule %r/'/, Operator
       end
 
       state :chararray 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 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
     end
   end

data/lib/rouge/lexers/moonscript.rb

@@ -40,18 +40,18 @@ module Rouge
 
       state :root do
         rule %r(#!(.*?)$), Comment::Preproc # shebang
-        rule //, Text, :main
+        rule %r//, Text, :main
       end
 
       state :base do
-        ident = '(?:[\w_][\w\d_]*)'
+        ident = '(?:\w\w*)'
 
         rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
         rule %r((?i)\d+e[+-]?\d+), Num::Float
         rule %r((?i)0x[0-9a-f]*), Num::Hex
         rule %r(\d+), Num::Integer
         rule %r(@#{ident}*), Name::Variable::Instance
-        rule %r([A-Z][\w\d_]*), Name::Class
+        rule %r([A-Z]\w*), Name::Class
         rule %r("?[^"]+":), Literal::String::Symbol
         rule %r(#{ident}:), Literal::String::Symbol
         rule %r(:#{ident}), Literal::String::Symbol

data/lib/rouge/lexers/mosel.rb

@@ -166,7 +166,7 @@ module Rouge
 
       state :whitespace do
         # Spaces
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         # ! Comments
         rule %r((!).*$\n?), Comment::Single
         # (! Comments !)
@@ -182,14 +182,14 @@ module Rouge
       # The escape sequences are not interpreted if they are contained in strings that are enclosed in single quotes.
 
       state :single_quotes do
-        rule /'/, Str::Single, :pop!
-        rule /[^']+/, Str::Single
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[^']+/, Str::Single
       end
 
       state :double_quotes do
-        rule /"/, Str::Double, :pop!
-        rule /(\\"|\\[0-7]{1,3}\D|\\[abfnrtv]|\\\\)/, Str::Escape
-        rule /[^"]/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/(\\"|\\[0-7]{1,3}\D|\\[abfnrtv]|\\\\)/, Str::Escape
+        rule %r/[^"]/, Str::Double
       end
 
       state :base do
@@ -200,25 +200,25 @@ 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 /"(\\\\|\\"|[^"])*"/, Str
+#        rule %r/"(\\\\|\\"|[^"])*"/, Str
         
 
 
-        rule /(true|false)\b/i, Name::Builtin
-        rule /\b(#{core_keywords.join('|')})\b/i, Keyword
-        rule /\b(#{core_functions.join('|')})\b/, Name::Builtin
+        rule %r/(true|false)\b/i, Name::Builtin
+        rule %r/\b(#{core_keywords.join('|')})\b/i, Keyword
+        rule %r/\b(#{core_functions.join('|')})\b/, Name::Builtin
         
         
 
-        rule /\b(#{mmxprs_functions.join('|')})\b/, Name::Function
-        rule /\b(#{mmxpres_constants.join('|')})\b/, Name::Constant
-        rule /\b(#{mmxprs_parameters.join('|')})\b/i, Name::Property
+        rule %r/\b(#{mmxprs_functions.join('|')})\b/, Name::Function
+        rule %r/\b(#{mmxpres_constants.join('|')})\b/, Name::Constant
+        rule %r/\b(#{mmxprs_parameters.join('|')})\b/i, Name::Property
                   
-        rule /\b(#{mmsystem_functions.join('|')})\b/i, Name::Function
-        rule /\b(#{mmsystem_parameters.join('|')})\b/, Name::Property
+        rule %r/\b(#{mmsystem_functions.join('|')})\b/i, Name::Function
+        rule %r/\b(#{mmsystem_parameters.join('|')})\b/, Name::Property
           
-        rule /\b(#{mmjobs_functions.join('|')})\b/i, Name::Function
-        rule /\b(#{mmjobs_parameters.join('|')})\b/, Name::Property
+        rule %r/\b(#{mmjobs_functions.join('|')})\b/i, Name::Function
+        rule %r/\b(#{mmjobs_parameters.join('|')})\b/, Name::Property
 
         rule id, Name
       end

data/lib/rouge/lexers/mxml.rb

@@ -11,56 +11,56 @@ module Rouge
       mimetypes 'application/xv+xml'
 
       state :root do
-        rule /[^<&]+/, Text
-        rule /&\S*?;/, Name::Entity
+        rule %r/[^<&]+/, Text
+        rule %r/&\S*?;/, Name::Entity
 
-        rule /<!\[CDATA\[/m do
+        rule %r/<!\[CDATA\[/m do
           token Comment::Preproc
           push :actionscript_content
         end
 
-        rule /<!--/, Comment, :comment
-        rule /<\?.*?\?>/, Comment::Preproc
-        rule /<![^>]*>/, Comment::Preproc
+        rule %r/<!--/, Comment, :comment
+        rule %r/<\?.*?\?>/, Comment::Preproc
+        rule %r/<![^>]*>/, Comment::Preproc
 
         rule %r(<\s*[\w:.-]+)m, Name::Tag, :tag # opening tags
         rule %r(<\s*/\s*[\w:.-]+\s*>)m, Name::Tag # closing tags
       end
 
       state :comment do
-        rule /[^-]+/m, Comment
-        rule /-->/, Comment, :pop!
-        rule /-/, Comment
+        rule %r/[^-]+/m, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
       end
 
       state :tag do
-        rule /\s+/m, Text
-        rule /[\w.:-]+\s*=/m, Name::Attribute, :attribute
+        rule %r/\s+/m, Text
+        rule %r/[\w.:-]+\s*=/m, Name::Attribute, :attribute
         rule %r(/?\s*>), Name::Tag, :root
       end
 
       state :attribute do
-        rule /\s+/m, Text
-        rule /(")({|@{)/m do
+        rule %r/\s+/m, Text
+        rule %r/(")({|@{)/m do
           groups Str, Punctuation
           push :actionscript_attribute
         end
-        rule /".*?"|'.*?'|[^\s>]+/, Str, :tag
+        rule %r/".*?"|'.*?'|[^\s>]+/, Str, :tag
       end
 
       state :actionscript_content do
-        rule /\]\]\>/m, Comment::Preproc, :pop!
-        rule /.*?(?=\]\]\>)/m do
+        rule %r/\]\]\>/m, Comment::Preproc, :pop!
+        rule %r/.*?(?=\]\]\>)/m do
           delegate Actionscript
         end
       end
 
       state :actionscript_attribute do
-        rule /(})(")/m do
+        rule %r/(})(")/m do
           groups Punctuation, Str
           push :tag
         end
-        rule /.*?(?=}")/m do
+        rule %r/.*?(?=}")/m do
           delegate Actionscript
         end
       end

data/lib/rouge/lexers/nasm.rb

@@ -11,7 +11,6 @@ module Rouge
       title "Nasm"
       desc "Netwide Assembler"
 
-      ws = %r((?:\s|;.*?\n/)+)
       id = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       #todo: pull more instructions from: http://www.nasm.us/doc/nasmdocb.html
@@ -119,57 +118,57 @@ module Rouge
       end
 
       state :inline_whitespace do
-        rule /[ \t\r]+/, Text
+        rule %r/[ \t\r]+/, Text
       end
 
       state :whitespace do
-        rule /\n+/m, Text, :expr_bol
+        rule %r/\n+/m, Text, :expr_bol
         rule %r(//(\\.|.)*?\n), Comment::Single, :expr_bol
         mixin :inline_whitespace
       end
 
       state :expr_whitespace do
-        rule /\n+/m, Text, :expr_bol
+        rule %r/\n+/m, Text, :expr_bol
         mixin :whitespace
       end
 
       state :root do
         mixin :expr_whitespace
         rule(//) { push :statement }
-        rule /^%[a-zA-Z0-9]+/, Comment::Preproc, :statement
+        rule %r/^%[a-zA-Z0-9]+/, Comment::Preproc, :statement
 
         rule(
           %r(&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>.]),
           Operator
         )
-        rule /;.*/, Comment, :statement
-        rule /^[a-zA-Z]+[a-zA-Z0-9]*:/, Name::Function
-        rule /;.*/, Comment
+        rule %r/;.*/, Comment, :statement
+        rule %r/^[a-zA-Z]+[a-zA-Z0-9]*:/, Name::Function
+        rule %r/;.*/, Comment
       end
 
       state :statement do
         mixin :expr_whitespace
         mixin :statements
-        rule /;.*/, Comment
-        rule /^%[a-zA-Z0-9]+/, Comment::Preproc
-        rule /[a-zA-Z]+%[0-9]+:/, Name::Function
+        rule %r/;.*/, Comment
+        rule %r/^%[a-zA-Z0-9]+/, Comment::Preproc
+        rule %r/[a-zA-Z]+%[0-9]+:/, Name::Function
       end
 
       state :statements do
         mixin :whitespace
-        rule /L?"/, Str, :string
-        rule /[a-zA-Z]+%[0-9]+:/, Name::Function  #labels/subroutines/functions
+        rule %r/L?"/, Str, :string
+        rule %r/[a-zA-Z]+%[0-9]+:/, Name::Function  #labels/subroutines/functions
         rule %r(L?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
-        rule /0x[0-9a-f]+[lu]*/i, Num::Hex
-        rule /\d+[lu]*/i, Num::Integer
+        rule %r/0x[0-9a-f]+[lu]*/i, Num::Hex
+        rule %r/\d+[lu]*/i, Num::Integer
         rule %r(\*/), Error
         rule %r([~&*+=\|?:<>/-]), Operator
-        rule /[(),.]/, Punctuation
-        rule /\[[a-zA-Z0-9]*\]/, Punctuation
-        rule /%[0-9]+/, Keyword::Reserved
-        rule /[a-zA-Z]+%[0-9]+/, Name::Function  #labels/subroutines/functions
+        rule %r/[(),.]/, Punctuation
+        rule %r/\[[a-zA-Z0-9]*\]/, Punctuation
+        rule %r/%[0-9]+/, Keyword::Reserved
+        rule %r/[a-zA-Z]+%[0-9]+/, Name::Function  #labels/subroutines/functions
 
-        #rule /(?<!\.)#{id}/ do |m|
+        #rule %r/(?<!\.)#{id}/ do |m|
         rule id do |m|
           name = m[0]
 
@@ -188,11 +187,11 @@ 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
     end
   end

data/lib/rouge/lexers/nginx.rb

@@ -13,7 +13,7 @@ module Rouge
       id = /[^\s$;{}()#]+/
 
       state :root do
-        rule /(include)(\s+)([^\s;]+)/ do
+        rule %r/(include)(\s+)([^\s;]+)/ do
           groups Keyword, Text, Name
         end
 
@@ -23,49 +23,49 @@ module Rouge
       end
 
       state :block do
-        rule /}/, Punctuation, :pop!
+        rule %r/}/, Punctuation, :pop!
         rule id, Keyword::Namespace, :statement
         mixin :base
       end
 
       state :statement do
-        rule /{/ do
+        rule %r/{/ do
           token Punctuation; pop!; push :block
         end
 
-        rule /;/, Punctuation, :pop!
+        rule %r/;/, Punctuation, :pop!
 
         mixin :base
       end
 
       state :base do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /#.*?\n/, Comment::Single
-        rule /(?:on|off)\b/, Name::Constant
-        rule /[$][\w-]+/, Name::Variable
+        rule %r/#.*?\n/, Comment::Single
+        rule %r/(?:on|off)\b/, Name::Constant
+        rule %r/[$][\w-]+/, Name::Variable
 
         # host/port
-        rule /([a-z0-9.-]+)(:)([0-9]+)/i do
+        rule %r/([a-z0-9.-]+)(:)([0-9]+)/i do
           groups Name::Function, Punctuation, Num::Integer
         end
 
         # mimetype
         rule %r([a-z-]+/[a-z-]+)i, Name::Class
 
-        rule /[0-9]+[kmg]?\b/i, Num::Integer
-        rule /(~)(\s*)([^\s{]+)/ do
+        rule %r/[0-9]+[kmg]?\b/i, Num::Integer
+        rule %r/(~)(\s*)([^\s{]+)/ do
           groups Punctuation, Text, Str::Regex
         end
 
-        rule /[:=~]/, Punctuation
+        rule %r/[:=~]/, Punctuation
 
         # pathname
         rule %r(/#{id}?), Name
 
-        rule /[^#\s;{}$\\]+/, Str # catchall
+        rule %r/[^#\s;{}$\\]+/, Str # catchall
 
-        rule /[$;]/, Text
+        rule %r/[$;]/, Text
       end
     end
   end