rouge 3.3.0 → 3.8.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

@@ -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

@@ -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,43 +90,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
 
@@ -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