rouge 3.3.0 → 3.8.0

data/lib/rouge/lexers/igorpro.rb

@@ -20,7 +20,7 @@ module Rouge
           break return continue
           for endfor do while
           case default
-	  try catch endtry
+          try catch endtry
           abortonrte
         )
       end
@@ -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

data/lib/rouge/lexers/ini.rb

@@ -15,39 +15,39 @@ 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
 
-        rule /\[.*?\]/, Name::Namespace
+        rule %r/\[.*?\]/, Name::Namespace
       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 /\\./m, Str::Escape
+        rule %r/\\./m, Str::Escape
       end
     end
   end

data/lib/rouge/lexers/io.rb

@@ -26,22 +26,22 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule %r(//.*?\n), Comment::Single
         rule %r(#.*?\n), Comment::Single
         rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
         rule %r(/[+]), Comment::Multiline, :nested_comment
 
-        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
 
         rule %r(:?:=), Keyword
-        rule /[()]/, Punctuation
+        rule %r/[()]/, Punctuation
 
         rule %r([-=;,*+><!/|^.%&\[\]{}]), Operator
 
-        rule /[A-Z]\w*/, Name::Class
+        rule %r/[A-Z]\w*/, Name::Class
 
-        rule /[a-z_]\w*/ do |m|
+        rule %r/[a-z_]\w*/ do |m|
           name = m[0]
 
           if self.class.constants.include? name
@@ -54,9 +54,9 @@ module Rouge
         end
 
         rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, Num::Float
-        rule /\d+/, Num::Integer
+        rule %r/\d+/, Num::Integer
 
-        rule /@@?/, Keyword
+        rule %r/@@?/, Keyword
       end
 
       state :nested_comment do

data/lib/rouge/lexers/irb.rb

@@ -41,25 +41,25 @@ module Rouge
 
       state :has_irb_output do
         rule %r(=>), Punctuation, :pop!
-        rule /.+?(\n|$)/, Generic::Output
+        rule %r/.+?(\n|$)/, Generic::Output
       end
 
       state :irb_error do
-        rule /.+?(\n|$)/, Generic::Error
+        rule %r/.+?(\n|$)/, Generic::Error
         mixin :has_irb_output
       end
 
       state :stdout do
-        rule /\w+?(Error|Exception):.+?(\n|$)/, Generic::Error, :irb_error
+        rule %r/\w+?(Error|Exception):.+?(\n|$)/, Generic::Error, :irb_error
         mixin :has_irb_output
       end
 
       prepend :root do
-        rule /#</, Keyword::Type, :irb_object
+        rule %r/#</, Keyword::Type, :irb_object
       end
 
       state :irb_object do
-        rule />/, Keyword::Type, :pop!
+        rule %r/>/, Keyword::Type, :pop!
         mixin :root
       end
     end

data/lib/rouge/lexers/java.rb

@@ -24,14 +24,16 @@ module Rouge
       types = %w(boolean byte char double float int long short var void)
 
       id = /[a-zA-Z_][a-zA-Z0-9_]*/
+      const_name = /[A-Z][A-Z0-9_]*\b/
+      class_name = /[A-Z][a-zA-Z0-9]*\b/
 
       state :root do
-        rule /[^\S\n]+/, Text
+        rule %r/[^\S\n]+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/\*.*?\*/)m, Comment::Multiline
         # keywords: go before method names to avoid lexing "throw new XYZ"
         # as a method signature
-        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
 
         rule %r(
           (\s*(?:[a-zA-Z_][a-zA-Z0-9_.\[\]<>]*\s+)+?) # return arguments
@@ -45,43 +47,45 @@ module Rouge
           token Operator, m[4]
         end
 
-        rule /@#{id}/, Name::Decorator
-        rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
-        rule /(?:#{types.join('|')})\b/, Keyword::Type
-        rule /package\b/, Keyword::Namespace
-        rule /(?:true|false|null)\b/, Keyword::Constant
-        rule /(?:class|interface)\b/, Keyword::Declaration, :class
-        rule /import\b/, Keyword::Namespace, :import
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
-        rule /(\.)(#{id})/ do
+        rule %r/@#{id}/, Name::Decorator
+        rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule %r/(?:#{types.join('|')})\b/, Keyword::Type
+        rule %r/package\b/, Keyword::Namespace
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/import\b/, Keyword::Namespace, :import
+        rule %r/"(\\\\|\\"|[^"])*"/, Str
+        rule %r/'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
+        rule %r/(\.)(#{id})/ do
           groups Operator, Name::Attribute
         end
 
-        rule /#{id}:/, Name::Label
-        rule /\$?#{id}/, Name
-        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule %r/#{id}:/, Name::Label
+        rule const_name, Name::Constant
+        rule class_name, Name::Class
+        rule %r/\$?#{id}/, Name
+        rule %r/[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
 
         digit = /[0-9]_+[0-9]|[0-9]/
         bin_digit = /[01]_+[01]|[01]/
         oct_digit = /[0-7]_+[0-7]|[0-7]/
         hex_digit = /[0-9a-f]_+[0-9a-f]|[0-9a-f]/i
-        rule /#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
-        rule /0b#{bin_digit}+/i, Num::Bin
-        rule /0x#{hex_digit}+/i, Num::Hex
-        rule /0#{oct_digit}+/, Num::Oct
-        rule /#{digit}+L?/, Num::Integer
-        rule /\n/, Text
+        rule %r/#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
+        rule %r/0b#{bin_digit}+/i, Num::Bin
+        rule %r/0x#{hex_digit}+/i, Num::Hex
+        rule %r/0#{oct_digit}+/, Num::Oct
+        rule %r/#{digit}+L?/, Num::Integer
+        rule %r/\n/, Text
       end
 
       state :class do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule id, Name::Class, :pop!
       end
 
       state :import do
-        rule /\s+/m, Text
-        rule /[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+        rule %r/\s+/m, Text
+        rule %r/[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
       end
     end
   end

data/lib/rouge/lexers/javascript.rb

@@ -32,8 +32,8 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
-        rule /<!--/, Comment # really...?
+        rule %r/\s+/, Text
+        rule %r/<!--/, Comment # really...?
         rule %r(//.*?$), Comment::Single
         rule %r(/[*]), Comment::Multiline, :multiline_comment
       end
@@ -46,12 +46,12 @@ module Rouge
           goto :regex
         end
 
-        rule /[{]/ do
+        rule %r/[{]/ do
           token Punctuation
           goto :object
         end
 
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :regex do
@@ -62,62 +62,59 @@ module Rouge
 
         rule %r([^/]\n), Error, :pop!
 
-        rule /\n/, Error, :pop!
-        rule /\[\^/, Str::Escape, :regex_group
-        rule /\[/, Str::Escape, :regex_group
-        rule /\\./, Str::Escape
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
         rule %r{[(][?][:=<!]}, Str::Escape
-        rule /[{][\d,]+[}]/, Str::Escape
-        rule /[()?]/, Str::Escape
-        rule /./, Str::Regex
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :regex_end do
-        rule /[gim]+/, Str::Regex, :pop!
+        rule %r/[gim]+/, Str::Regex, :pop!
         rule(//) { pop! }
       end
 
       state :regex_group do
         # specially highlight / in a group to indicate that it doesn't
         # close the regex
-        rule /\//, Str::Escape
+        rule %r(/), Str::Escape
 
         rule %r([^/]\n) do
           token Error
           pop! 2
         end
 
-        rule /\]/, Str::Escape, :pop!
-        rule /\\./, Str::Escape
-        rule /./, Str::Regex
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :bad_regex do
-        rule /[^\n]+/, Error, :pop!
+        rule %r/[^\n]+/, Error, :pop!
       end
 
       def self.keywords
         @keywords ||= Set.new %w(
-          for in of while do break return continue switch case default
-          if else throw try catch finally new delete typeof instanceof
-          void this yield import export from as async super this
+          as async await break case catch continue debugger default delete
+          do else export finally from for if import in instanceof new of
+          return super switch this throw try typeof void while yield
         )
       end
 
       def self.declarations
         @declarations ||= Set.new %w(
           var let const with function class
-          extends constructor get set
+          extends constructor get set static
         )
       end
 
       def self.reserved
         @reserved ||= Set.new %w(
-          abstract boolean byte char debugger double enum
-          final float goto implements int interface
-          long native package private protected public short static
-          synchronized throws transient volatile
-          eval arguments await
+          enum implements interface
+          package private protected public
         )
       end
 
@@ -147,34 +144,34 @@ module Rouge
       id = self.id_regex
 
       state :root do
-        rule /\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule %r/\A\s*#!.*?\n/m, Comment::Preproc, :statement
         rule %r((?<=\n)(?=\s|/|<!--)), Text, :expr_start
         mixin :comments_and_whitespace
         rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
                | !== )x,
           Operator, :expr_start
         rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start
-        rule /[(\[,]/, Punctuation, :expr_start
-        rule /;/, Punctuation, :statement
-        rule /[)\].]/, Punctuation
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
 
-        rule /`/ do
+        rule %r/`/ do
           token Str::Double
           push :template_string
         end
 
-        rule /[?]/ do
+        rule %r/[?]/ do
           token Punctuation
           push :ternary
           push :expr_start
         end
 
-        rule /(\@)(\w+)?/ do
+        rule %r/(\@)(\w+)?/ do
           groups Punctuation, Name::Decorator
           push :expr_start
         end
 
-        rule /[{}]/, Punctuation, :statement
+        rule %r/[{}]/, Punctuation, :statement
 
         rule id do |m|
           if self.class.keywords.include? m[0]
@@ -194,42 +191,41 @@ module Rouge
           end
         end
 
-        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
-        rule /0x[0-9a-fA-F]+/i, Num::Hex
-        rule /0o[0-7][0-7_]*/i, Num::Oct
-        rule /0b[01][01_]*/i, Num::Bin
-        rule /[0-9]+/, Num::Integer
+        rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/[0-9]+/, Num::Integer
 
-        rule /"/, Str::Double, :dq
-        rule /'/, Str::Single, :sq
-        rule /:/, Punctuation
+        rule %r/"/, Str::Delimiter, :dq
+        rule %r/'/, Str::Delimiter, :sq
+        rule %r/:/, Punctuation
       end
 
       state :dq do
-        rule /[^\\"]+/, Str::Double
-        rule /\\n/, Str::Escape
-        rule /\\"/, Str::Escape
-        rule /"/, Str::Double, :pop!
+        rule %r/\\[\\nrt"]?/, Str::Escape
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/"/, Str::Delimiter, :pop!
       end
 
       state :sq do
-        rule /[^\\']+/, Str::Single
-        rule /\\'/, Str::Escape
-        rule /'/, Str::Single, :pop!
+        rule %r/\\[\\nrt']?/, Str::Escape
+        rule %r/[^\\']+/, Str::Single
+        rule %r/'/, Str::Delimiter, :pop!
       end
 
       # braced parts that aren't object literals
       state :statement do
-        rule /case\b/ do
+        rule %r/case\b/ do
           token Keyword
           goto :expr_start
         end
 
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
         end
 
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         mixin :expr_start
       end
@@ -238,28 +234,28 @@ module Rouge
       state :object do
         mixin :comments_and_whitespace
 
-        rule /[{]/ do
+        rule %r/[{]/ do
           token Punctuation
           push
         end
 
-        rule /[}]/ do
+        rule %r/[}]/ do
           token Punctuation
           goto :statement
         end
 
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Attribute, Text, Punctuation
           push :expr_start
         end
 
-        rule /:/, Punctuation
+        rule %r/:/, Punctuation
         mixin :root
       end
 
       # ternary expressions, where <id>: is not a label!
       state :ternary do
-        rule /:/ do
+        rule %r/:/ do
           token Punctuation
           goto :expr_start
         end
@@ -269,13 +265,13 @@ module Rouge
 
       # template strings
       state :template_string do
-        rule /\${/, Punctuation, :template_string_expr
-        rule /`/, Str::Double, :pop!
-        rule /(\\\\|\\[\$`]|[^\$`]|\$(?!{))*/, Str::Double
+        rule %r/\${/, Punctuation, :template_string_expr
+        rule %r/`/, Str::Double, :pop!
+        rule %r/(\\\\|\\[\$`]|[^\$`]|\$(?!{))*/, Str::Double
       end
 
       state :template_string_expr do
-        rule /}/, Punctuation, :pop!
+        rule %r/}/, Punctuation, :pop!
         mixin :root
       end
     end