rouge 3.2.0 → 3.18.0

data/lib/rouge/lexers/supercollider.rb

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class SuperCollider < RegexLexer
+      tag 'supercollider'
+      filenames '*.sc', '*.scd'
+
+      title "SuperCollider"
+      desc 'A cross-platform interpreted programming language for sound synthesis, algorithmic composition, and realtime performance'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          var arg classvar const super this
+        )
+      end
+
+      # these aren't technically keywords, but we treat
+      # them as such because it makes things clearer 99%
+      # of the time
+      def self.reserved
+        @reserved ||= Set.new %w(
+          case do for forBy loop if while new newCopyArgs
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          true false nil inf thisThread
+          thisMethod thisFunction thisProcess
+          thisFunctionDef currentEnvironment
+          topEnvironment
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+      end
+
+      state :comments do
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*]) do
+          token Comment::Multiline
+          push :nested_comment
+        end
+      end
+
+      state :nested_comment do
+        rule %r(/[*]), Comment::Multiline, :nested_comment
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^*/]+)m, Comment::Multiline
+        rule %r/./, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :comments
+
+        rule %r/[\-+]?0[xX]\h+/, Num::Hex
+
+        # radix float
+        rule %r/[\-+]?\d+r[0-9a-zA-Z]*(\.[0-9A-Z]*)?/, Num::Float
+
+        # normal float
+        rule %r/[\-+]?((\d+(\.\d+)?([eE][\-+]?\d+)?(pi)?)|pi)/, Num::Float
+
+        rule %r/[\-+]?\d+/, Num::Integer
+
+        rule %r/\$(\\.|.)/, Str::Char
+
+        rule %r/"([^\\"]|\\.)*"/, Str
+
+        # symbols (single-quote notation)
+        rule %r/'([^\\']|\\.)*'/, Str::Other
+
+        # symbols (backslash notation)
+        rule %r/\\\w+/, Str::Other
+
+        # symbol arg
+        rule %r/[A-Za-z_]\w*:/, Name::Label
+
+        rule %r/[A-Z]\w*/, Name::Class
+
+        # primitive
+        rule %r/_\w+/, Name::Function
+
+        # main identifiers section
+        rule %r/[a-z]\w*/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+
+        # environment variables
+        rule %r/~\w+/, Name::Variable::Global
+
+        rule %r/[\{\}()\[\];,\.]/, Punctuation
+
+        # operators. treat # (array unpack) as an operator
+        rule %r/[\+\-\*\/&\|%<>=]+/, Operator
+        rule %r/[\^:#]/, Operator
+
+        # treat curry argument as a special operator
+        rule %r/\b_\b/, Name::Builtin
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/swift.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -19,10 +20,12 @@ 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(
-        class deinit enum extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate
+        class deinit enum convenience extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate some
       )
 
       constants = Set.new %w(
@@ -33,7 +36,7 @@ module Rouge
 
       # beginning of line
       state :bol do
-        rule /#.*/, Comment::Preproc
+        rule %r/#.*/, Comment::Preproc
 
         mixin :inline_whitespace
 
@@ -41,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
@@ -59,27 +62,28 @@ 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
@@ -87,43 +91,43 @@ 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
             groups Keyword::Declaration, Error, Keyword::Declaration
           end
         end
-        
-        rule /#available\([^)]+\)/, Keyword::Declaration
-        
-        rule /(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
+
+        rule %r/#available\([^)]+\)/, Keyword::Declaration
+
+        rule %r/(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
           groups Keyword::Declaration, Name::Function, Keyword::Declaration
         end
-        
-        rule /#(line|file|column|function|dsohandle)/, Keyword::Declaration
 
-        rule /(let|var)\b(\s*)(#{id})/ do
+        rule %r/#(line|file|column|function|dsohandle)/, Keyword::Declaration
+
+        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
             token Name::Function
           end
         end
-        
-        rule /as[?!]?(?=\s)/, Keyword
-        rule /try[!]?(?=\s)/, Keyword
 
-        rule /(#?(?!default)(?![[:upper:]])#{id})(\s*)(:)/ do
+        rule %r/as[?!]?(?=\s)/, Keyword
+        rule %r/try[!]?(?=\s)/, Keyword
+
+        rule %r/(#?(?!default)(?![[:upper:]])#{id})(\s*)(:)/ do
           groups Name::Variable, Text, Punctuation
         end
 
@@ -141,39 +145,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     class Tap < RegexLexer
@@ -11,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

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -38,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]
@@ -115,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!
@@ -127,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
@@ -146,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!