rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/sqf.rb

@@ -55,7 +55,7 @@ module Rouge
       end
 
       def self.commands
-        load Pathname.new(__FILE__).dirname.join("sqf/commands.rb")
+        load File.join(__dir__, "sqf/commands.rb")
         @commands = self.commands
       end
 

data/lib/rouge/lexers/sql.rb

@@ -89,15 +89,15 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, Text
-        rule /--.*/, Comment::Single
+        rule %r/\s+/m, Text
+        rule %r/--.*/, Comment::Single
         rule %r(/\*), Comment::Multiline, :multiline_comments
-        rule /\d+/, Num::Integer
-        rule /'/, Str::Single, :single_string
-        rule /"/, Name::Variable, :double_string
-        rule /`/, Name::Variable, :backtick
+        rule %r/\d+/, Num::Integer
+        rule %r/'/, Str::Single, :single_string
+        rule %r/"/, Name::Variable, :double_string
+        rule %r/`/, Name::Variable, :backtick
 
-        rule /\w[\w\d]*/ do |m|
+        rule %r/\w\w*/ do |m|
           if self.class.keywords.include? m[0].upcase
             token Keyword
           else
@@ -105,8 +105,8 @@ module Rouge
           end
         end
 
-        rule %r([+*/<>=~!@#%^&|?^-]), Operator
-        rule /[;:()\[\],.]/, Punctuation
+        rule %r([+*/<>=~!@#%&|?^-]), Operator
+        rule %r/[;:()\[\],.]/, Punctuation
       end
 
       state :multiline_comments do
@@ -117,24 +117,24 @@ module Rouge
       end
 
       state :backtick do
-        rule /\\./, Str::Escape
-        rule /``/, Str::Escape
-        rule /`/, Name::Variable, :pop!
-        rule /[^\\`]+/, Name::Variable
+        rule %r/\\./, Str::Escape
+        rule %r/``/, Str::Escape
+        rule %r/`/, Name::Variable, :pop!
+        rule %r/[^\\`]+/, Name::Variable
       end
 
       state :single_string do
-        rule /\\./, Str::Escape
-        rule /''/, Str::Escape
-        rule /'/, Str::Single, :pop!
-        rule /[^\\']+/, Str::Single
+        rule %r/\\./, Str::Escape
+        rule %r/''/, Str::Escape
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[^\\']+/, Str::Single
       end
 
       state :double_string do
-        rule /\\./, Str::Escape
-        rule /""/, Str::Escape
-        rule /"/, Name::Variable, :pop!
-        rule /[^\\"]+/, Name::Variable
+        rule %r/\\./, Str::Escape
+        rule %r/""/, Str::Escape
+        rule %r/"/, Name::Variable, :pop!
+        rule %r/[^\\"]+/, Name::Variable
       end
     end
   end

data/lib/rouge/lexers/supercollider.rb

@@ -35,7 +35,7 @@ module Rouge
       end
 
       state :whitespace do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
       end
 
       state :comments do
@@ -50,43 +50,43 @@ module Rouge
         rule %r(/[*]), Comment::Multiline, :nested_comment
         rule %r([*]/), Comment::Multiline, :pop!
         rule %r([^*/]+)m, Comment::Multiline
-        rule /./, Comment::Multiline
+        rule %r/./, Comment::Multiline
       end
 
       state :root do
         mixin :whitespace
         mixin :comments
 
-        rule /[\-+]?0[xX]\h+/, Num::Hex
+        rule %r/[\-+]?0[xX]\h+/, Num::Hex
 
         # radix float
-        rule /[\-+]?\d+r[0-9a-zA-Z]*(\.[0-9A-Z]*)?/, Num::Float
+        rule %r/[\-+]?\d+r[0-9a-zA-Z]*(\.[0-9A-Z]*)?/, Num::Float
 
         # normal float
-        rule /[\-+]?((\d+(\.\d+)?([eE][\-+]?\d+)?(pi)?)|pi)/, Num::Float
+        rule %r/[\-+]?((\d+(\.\d+)?([eE][\-+]?\d+)?(pi)?)|pi)/, Num::Float
 
-        rule /[\-+]?\d+/, Num::Integer
+        rule %r/[\-+]?\d+/, Num::Integer
 
-        rule /\$(\\.|.)/, Str::Char
+        rule %r/\$(\\.|.)/, Str::Char
 
-        rule /"([^\\"]|\\.)*"/, Str
+        rule %r/"([^\\"]|\\.)*"/, Str
 
         # symbols (single-quote notation)
-        rule /'([^\\']|\\.)*'/, Str::Other
+        rule %r/'([^\\']|\\.)*'/, Str::Other
 
         # symbols (backslash notation)
-        rule /\\\w+/, Str::Other
+        rule %r/\\\w+/, Str::Other
 
         # symbol arg
-        rule /[A-Za-z_]\w*:/, Name::Label
+        rule %r/[A-Za-z_]\w*:/, Name::Label
 
-        rule /[A-Z]\w*/, Name::Class
+        rule %r/[A-Z]\w*/, Name::Class
 
         # primitive
-        rule /_\w+/, Name::Function
+        rule %r/_\w+/, Name::Function
 
         # main identifiers section
-        rule /[a-z]\w*/ do |m|
+        rule %r/[a-z]\w*/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
           elsif self.class.constants.include? m[0]
@@ -99,16 +99,16 @@ module Rouge
         end
 
         # environment variables
-        rule /~\w+/, Name::Variable::Global
+        rule %r/~\w+/, Name::Variable::Global
 
-        rule /[\{\}()\[\];,\.]/, Punctuation
+        rule %r/[\{\}()\[\];,\.]/, Punctuation
 
         # operators. treat # (array unpack) as an operator
-        rule /[\+\-\*\/&\|%<>=]+/, Operator
-        rule /[\^:#]/, Operator
+        rule %r/[\+\-\*\/&\|%<>=]+/, Operator
+        rule %r/[\^:#]/, Operator
 
         # treat curry argument as a special operator
-        rule /\b_\b/, Name::Builtin
+        rule %r/\b_\b/, Name::Builtin
       end
     end
   end

data/lib/rouge/lexers/swift.rb

@@ -20,6 +20,8 @@ module Rouge
         as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
 
         associativity didSet get infix inout mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
+
+        #available #colorLiteral #column #else #elseif #endif #error #file #fileLiteral #function #if #imageLiteral #line #selector #sourceLocation #warning
       )
 
       declarations = Set.new %w(
@@ -34,7 +36,7 @@ module Rouge
 
       # beginning of line
       state :bol do
-        rule /#.*/, Comment::Preproc
+        rule %r/#.*/, Comment::Preproc
 
         mixin :inline_whitespace
 
@@ -42,12 +44,12 @@ module Rouge
       end
 
       state :inline_whitespace do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         mixin :has_comments
       end
 
       state :whitespace do
-        rule /\n+/m, Text, :bol
+        rule %r/\n+/m, Text, :bol
         rule %r(\/\/.*?$), Comment::Single, :bol
         mixin :inline_whitespace
       end
@@ -60,27 +62,27 @@ module Rouge
         mixin :has_comments
         rule %r([*]/), Comment::Multiline, :pop!
         rule %r([^*/]+)m, Comment::Multiline
-        rule /./, Comment::Multiline
+        rule %r/./, Comment::Multiline
       end
 
       state :root do
         mixin :whitespace
-        rule /\$(([1-9]\d*)?\d)/, Name::Variable
+        rule %r/\$(([1-9]\d*)?\d)/, Name::Variable
 
         rule %r{[()\[\]{}:;,?\\]}, Punctuation
         rule %r([-/=+*%<>!&|^.~]+), Operator
-        rule /@?"/, Str, :dq
-        rule /'(\\.|.)'/, Str::Char
-        rule /(\d+\*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
-        rule /\d+e[+-]?[0-9]+/i, Num::Float
-        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 %r/@?"/, Str, :dq
+        rule %r/'(\\.|.)'/, Str::Char
+        rule %r/(\d+(?:_\d+)*\*|(?:\d+(?:_\d+)*)*\.\d+(?:_\d)*)(e[+-]?\d+(?:_\d)*)?/i, Num::Float
+        rule %r/\d+e[+-]?[0-9]+/i, Num::Float
+        rule %r/0o?[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule %r/0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*((\.[0-9A-F]+(?:_[0-9A-F]+)*)?p[+-]?\d+)?/, Num::Hex
+        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
         rule %r{[\d]+(?:_\d+)*}, Num::Integer
 
-        rule /@#{id}(\([^)]+\))?/, Keyword::Declaration
+        rule %r/@#{id}(\([^)]+\))?/, Keyword::Declaration
 
-        rule /(private|internal)(\([ ]*)(\w+)([ ]*\))/ do |m|
+        rule %r/(private|internal)(\([ ]*)(\w+)([ ]*\))/ do |m|
           if m[3] == 'set'
             token Keyword::Declaration
           else
@@ -88,7 +90,7 @@ module Rouge
           end
         end
 
-        rule /(unowned\([ ]*)(\w+)([ ]*\))/ do |m|
+        rule %r/(unowned\([ ]*)(\w+)([ ]*\))/ do |m|
           if m[2] == 'safe' || m[2] == 'unsafe'
             token Keyword::Declaration
           else
@@ -96,24 +98,24 @@ module Rouge
           end
         end
         
-        rule /#available\([^)]+\)/, Keyword::Declaration
+        rule %r/#available\([^)]+\)/, Keyword::Declaration
         
-        rule /(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
+        rule %r/(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
           groups Keyword::Declaration, Name::Function, Keyword::Declaration
         end
         
-        rule /#(line|file|column|function|dsohandle)/, Keyword::Declaration
+        rule %r/#(line|file|column|function|dsohandle)/, Keyword::Declaration
 
-        rule /(let|var)\b(\s*)(#{id})/ do
+        rule %r/(let|var)\b(\s*)(#{id})/ do
           groups Keyword, Text, Name::Variable
         end
 
-        rule /(let|var)\b(\s*)([(])/ do
+        rule %r/(let|var)\b(\s*)([(])/ do
           groups Keyword, Text, Punctuation
           push :tuple
         end
 
-        rule /(?!\b(if|while|for|private|internal|unowned|switch|case)\b)\b#{id}(?=(\?|!)?\s*[(])/ do |m|
+        rule %r/(?!\b(if|while|for|private|internal|unowned|switch|case)\b)\b#{id}(?=(\?|!)?\s*[(])/ do |m|
           if m[0] =~ /^[[:upper:]]/
             token Keyword::Type
           else
@@ -121,10 +123,10 @@ module Rouge
           end
         end
         
-        rule /as[?!]?(?=\s)/, Keyword
-        rule /try[!]?(?=\s)/, Keyword
+        rule %r/as[?!]?(?=\s)/, Keyword
+        rule %r/try[!]?(?=\s)/, Keyword
 
-        rule /(#?(?!default)(?![[:upper:]])#{id})(\s*)(:)/ do
+        rule %r/(#?(?!default)(?![[:upper:]])#{id})(\s*)(:)/ do
           groups Name::Variable, Text, Punctuation
         end
 
@@ -142,39 +144,40 @@ module Rouge
           end
         end
 
-        rule /(`)(#{id})(`)/ do
+        rule %r/(`)(#{id})(`)/ do
           groups Punctuation, Name::Variable, Punctuation
         end
       end
 
       state :tuple do
-        rule /(#{id})/, Name::Variable
-        rule /(`)(#{id})(`)/ do
+        rule %r/(#{id})/, Name::Variable
+        rule %r/(`)(#{id})(`)/ do
             groups Punctuation, Name::Variable, Punctuation
         end
-        rule /,/, Punctuation
-        rule /[(]/, Punctuation, :push
-        rule /[)]/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/[(]/, Punctuation, :push
+        rule %r/[)]/, Punctuation, :pop!
         mixin :inline_whitespace
       end
 
       state :dq do
-        rule /\\[\\0tnr'"]/, Str::Escape
-        rule /\\[(]/, Str::Escape, :interp
-        rule /\\u\{\h{1,8}\}/, Str::Escape
-        rule /[^\\"]+/, Str
-        rule /"/, Str, :pop!
+        rule %r/\\[\\0tnr'"]/, Str::Escape
+        rule %r/\\[(]/, Str::Escape, :interp
+        rule %r/\\u\{\h{1,8}\}/, Str::Escape
+        rule %r/[^\\"]+/, Str
+        rule %r/"""/, Str, :pop!
+        rule %r/"/, Str, :pop!
       end
 
       state :interp do
-        rule /[(]/, Punctuation, :interp_inner
-        rule /[)]/, Str::Escape, :pop!
+        rule %r/[(]/, Punctuation, :interp_inner
+        rule %r/[)]/, Str::Escape, :pop!
         mixin :root
       end
 
       state :interp_inner do
-        rule /[(]/, Punctuation, :push
-        rule /[)]/, Punctuation, :pop!
+        rule %r/[(]/, Punctuation, :push
+        rule %r/[)]/, Punctuation, :pop!
         mixin :root
       end
     end

data/lib/rouge/lexers/tap.rb

@@ -13,72 +13,72 @@ module Rouge
 
       state :root do
         # A TAP version may be specified.
-        rule /^TAP version \d+\n/, Name::Namespace
+        rule %r/^TAP version \d+\n/, Name::Namespace
 
         # Specify a plan with a plan line.
-        rule /^1\.\.\d+/, Keyword::Declaration, :plan
+        rule %r/^1\.\.\d+/, Keyword::Declaration, :plan
 
         # A test failure
-        rule /^(not ok)([^\S\n]*)(\d*)/ do
+        rule %r/^(not ok)([^\S\n]*)(\d*)/ do
           groups Generic::Error, Text, Literal::Number::Integer
           push :test
         end
 
         # A test success
-        rule /^(ok)([^\S\n]*)(\d*)/ do
+        rule %r/^(ok)([^\S\n]*)(\d*)/ do
           groups Keyword::Reserved, Text, Literal::Number::Integer
           push :test
         end
 
         # Diagnostics start with a hash.
-        rule /^#.*\n/, Comment
+        rule %r/^#.*\n/, Comment
 
         # TAP's version of an abort statement.
-        rule /^Bail out!.*\n/, Generic::Error
+        rule %r/^Bail out!.*\n/, Generic::Error
 
         # # TAP ignores any unrecognized lines.
-        rule /^.*\n/, Text
+        rule %r/^.*\n/, Text
       end
 
       state :plan do
         # Consume whitespace (but not newline).
-        rule /[^\S\n]+/, Text
+        rule %r/[^\S\n]+/, Text
 
         # A plan may have a directive with it.
-        rule /#/, Comment, :directive
+        rule %r/#/, Comment, :directive
 
         # Or it could just end.
-        rule /\n/, Comment, :pop!
+        rule %r/\n/, Comment, :pop!
 
         # Anything else is wrong.
-        rule /.*\n/, Generic::Error, :pop!
+        rule %r/.*\n/, Generic::Error, :pop!
       end
 
       state :test do
         # Consume whitespace (but not newline).
-        rule /[^\S\n]+/, Text
+        rule %r/[^\S\n]+/, Text
 
         # A test may have a directive with it.
-        rule /#/, Comment, :directive
+        rule %r/#/, Comment, :directive
 
-        rule /\S+/, Text
+        rule %r/\S+/, Text
 
-        rule /\n/, Text, :pop!
+        rule %r/\n/, Text, :pop!
       end
 
       state :directive do
         # Consume whitespace (but not newline).
-        rule /[^\S\n]+/, Comment
+        rule %r/[^\S\n]+/, Comment
 
         # Extract todo items.
-        rule /(?i)\bTODO\b/, Comment::Preproc
+        rule %r/(?i)\bTODO\b/, Comment::Preproc
 
         # Extract skip items.
-        rule /(?i)\bSKIP\S*/, Comment::Preproc
+        rule %r/(?i)\bSKIP\S*/, Comment::Preproc
 
-        rule /\S+/, Comment
+        rule %r/\S+/, Comment
 
-        rule /\n/ do
+        rule %r/\n/ do
           token Comment
           pop! 2
         end

data/lib/rouge/lexers/tcl.rb

@@ -39,33 +39,33 @@ module Rouge
       CLOSE = %w| \) \] \} |
       ALL = OPEN + CLOSE
       END_LINE = CLOSE + %w(; \n)
-      END_WORD = END_LINE + %w(\s)
+      END_WORD = END_LINE + %w(\r \t \v)
 
       CHARS =     lambda { |list| Regexp.new %/[#{list.join}]/  }
       NOT_CHARS = lambda { |list| Regexp.new %/[^#{list.join}]/ }
 
       state :word do
-        rule /\{\*\}/, Keyword
+        rule %r/\{\*\}/, Keyword
 
         mixin :brace_abort
         mixin :interp
-        rule /\{/, Punctuation, :brace
-        rule /\(/, Punctuation,   :paren
-        rule /"/,  Str::Double, :string
-        rule /#{NOT_CHARS[END_WORD]}+?(?=#{CHARS[OPEN+['\\\\']]})/, Text
+        rule %r/\{/, Punctuation, :brace
+        rule %r/\(/, Punctuation,   :paren
+        rule %r/"/,  Str::Double, :string
+        rule %r/#{NOT_CHARS[END_WORD]}+?(?=#{CHARS[OPEN+['\\\\']]})/, Text
       end
 
       def self.gen_command_state(name='')
         state(:"command#{name}") do
           mixin :word
 
-          rule /##{NOT_CHARS[END_LINE]}+/, Comment::Single
+          rule %r/##{NOT_CHARS[END_LINE]}+/, Comment::Single
 
-          rule /(?=#{CHARS[END_WORD]})/ do
+          rule %r/(?=#{CHARS[END_WORD]})/ do
             push :"params#{name}"
           end
 
-          rule /#{NOT_CHARS[END_WORD]}+/ do |m|
+          rule %r/#{NOT_CHARS[END_WORD]}+/ do |m|
             if KEYWORDS.include? m[0]
               token Keyword
             elsif BUILTINS.include? m[0]
@@ -116,7 +116,7 @@ module Rouge
       # such things as [ abc" ] are a runtime error, but will still
       # parse.  Currently something like this will muck up the lex.
       state :brace_abort do
-        rule /}/ do
+        rule %r/}/ do
           if in_state? :brace
             pop! until state? :brace
             pop!
@@ -128,12 +128,12 @@ module Rouge
       end
 
       state :params do
-        rule /;/, Punctuation, :pop!
-        rule /\n/, Text, :pop!
-        rule /else|elseif|then/, Keyword
+        rule %r/;/, Punctuation, :pop!
+        rule %r/\n/, Text, :pop!
+        rule %r/else|elseif|then/, Keyword
         mixin :word
         mixin :whitespace
-        rule /#{NOT_CHARS[END_WORD]}+/, Text
+        rule %r/#{NOT_CHARS[END_WORD]}+/, Text
       end
 
       gen_delimiter_states :brace,   /\}/, :strict => false
@@ -147,37 +147,37 @@ module Rouge
 
       state :whitespace do
         # not a multiline regex because we want to capture \n sometimes
-        rule /\s+/, Text
+        rule %r/\s+/, Text
       end
 
       state :interp do
-        rule /\[/, Punctuation, :bracket
-        rule /\$[a-z0-9.:-]+/, Name::Variable
-        rule /\$\{.*?\}/m, Name::Variable
-        rule /\$/, Text
+        rule %r/\[/, Punctuation, :bracket
+        rule %r/\$[a-z0-9.:-]+/, Name::Variable
+        rule %r/\$\{.*?\}/m, Name::Variable
+        rule %r/\$/, Text
 
         # escape sequences
-        rule /\\[0-7]{3}/, Str::Escape
-        rule /\\x[0-9a-f]{2}/i, Str::Escape
-        rule /\\u[0-9a-f]{4}/i, Str::Escape
-        rule /\\./m, Str::Escape
+        rule %r/\\[0-7]{3}/, Str::Escape
+        rule %r/\\x[0-9a-f]{2}/i, Str::Escape
+        rule %r/\\u[0-9a-f]{4}/i, Str::Escape
+        rule %r/\\./m, Str::Escape
       end
 
       state :string do
-        rule /"/, Str::Double, :pop!
+        rule %r/"/, Str::Double, :pop!
         mixin :interp
-        rule /[^\\\[\$"{}]+/m, Str::Double
+        rule %r/[^\\\[\$"{}]+/m, Str::Double
 
         # strings have to keep count of their internal braces, to support
         # for example { "{ }" }.
-        rule /{/ do
+        rule %r/{/ do
           @brace_count ||= 0
           @brace_count += 1
 
           token Str::Double
         end
 
-        rule /}/ do
+        rule %r/}/ do
           if in_state? :brace and @brace_count.to_i == 0
             pop! until state? :brace
             pop!