rouge 3.3.0 → 3.4.0

data/lib/rouge/lexers/kotlin.rb

@@ -19,9 +19,9 @@ module Rouge
         external false final finally for fun get if import in infix
         inline inner interface internal is lateinit noinline null
         object open operator out override package private protected
-        public reified return sealed set super tailrec this throw
-        true try typealias typeof val var vararg when where while
-        yield
+        public reified return sealed set super suspend tailrec this
+        throw true try typealias typeof val var vararg when where
+        while yield
       )
 
       name = %r'@?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}][\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
@@ -73,7 +73,8 @@ module Rouge
         rule %r'[^\S\n]+', Text
         rule %r'\\\n', Text # line continuation
         rule %r'//.*?$', Comment::Single
-        rule %r'/[*].*?[*]/'m, Comment::Multiline
+        rule %r'/[*].*[*]/', Comment::Multiline # single line block comment
+        rule %r'/[*].*', Comment::Multiline, :comment # multiline block comment
         rule %r'\n', Text
         rule %r'::|!!|\?[:.]', Operator
         rule %r"(\.\.)", Operator
@@ -122,6 +123,12 @@ module Rouge
         rule %r'(\s+)', Text
         rule id, Name::Property
       end
+
+      state :comment do
+        rule %r'\s*/[*].*', Comment::Multiline, :comment
+        rule %r'.*[*]/', Comment::Multiline, :pop!
+        rule %r'.*', Comment::Multiline
+      end
     end
   end
 end

data/lib/rouge/lexers/markdown.rb

@@ -32,16 +32,33 @@ module Rouge
         rule /^#(?=[^#]).*?$/, Generic::Heading
         rule /^##*.*?$/, Generic::Subheading
 
-        rule /(\n[ \t]*)(```|~~~)(.*?)(\n.*?\n)(\2)/m do |m|
-          sublexer = Lexer.find_fancy(m[3].strip, m[4], @options)
+        rule /^([ \t]*)(```|~~~)([^\n]*\n)((.*?)(\2))?/m do |m|
+          name = m[3].strip
+          sublexer = Lexer.find_fancy(name.empty? ? "guess" : name, m[5], @options)
           sublexer ||= PlainText.new(@options.merge(:token => Str::Backtick))
           sublexer.reset!
 
           token Text, m[1]
           token Punctuation, m[2]
           token Name::Label, m[3]
-          delegate sublexer, m[4]
-          token Punctuation, m[5]
+          if m[5]
+            delegate sublexer, m[5]
+          end
+
+          if m[6]
+            token Punctuation, m[6]
+          else
+            push do
+              rule /^([ \t]*)(#{m[2]})/ do |mb|
+                pop!
+                token Text, mb[1]
+                token Punctuation, mb[2]
+              end
+              rule /^.*\n/ do |mb|
+                delegate sublexer, mb[1]
+              end
+            end
+          end
         end
 
         rule /\n\n((    |\t).*?\n|\n)+/, Str::Backtick

data/lib/rouge/lexers/matlab.rb

@@ -58,15 +58,22 @@ module Rouge
         rule /\d+L/, Num::Integer::Long
         rule /\d+/, Num::Integer
 
-        rule /'(?=(.*'))/, Str::Single, :string
+        rule /'(?=(.*'))/, Str::Single, :chararray
+        rule /"(?=(.*"))/, Str::Double, :string
         rule /'/, Operator
       end
 
-      state :string do
+      state :chararray do
         rule /[^']+/, Str::Single
         rule /''/, Str::Escape
         rule /'/, Str::Single, :pop!
       end
+
+      state :string do
+        rule /[^"]+/, Str::Double
+        rule /""/, Str::Escape
+        rule /"/, Str::Double, :pop!
+      end
     end
   end
 end

data/lib/rouge/lexers/objective_c.rb

@@ -44,15 +44,8 @@ module Rouge
         rule /@\d+l?/, Num::Integer
         rule /\bin\b/, Keyword
 
-        rule /@(?:interface|implementation)\b/ do
-          token Keyword
-          goto :classname
-        end
-
-        rule /@(?:class|protocol)\b/ do
-          token Keyword
-          goto :forward_classname
-        end
+        rule /@(?:interface|implementation)\b/, Keyword, :classname
+        rule /@(?:class|protocol)\b/, Keyword, :forward_classname
 
         rule /@([[:alnum:]]+)/ do |m|
           if self.class.at_keywords.include? m[1]
@@ -80,7 +73,7 @@ module Rouge
         rule /\{/, Punctuation, :pop!
         rule /;/, Error
 
-        mixin :statement
+        mixin :statements
       end
 
       state :message do
@@ -160,8 +153,10 @@ module Rouge
           ([(].*?[)])?(\s*)
           (?=#{id}:?)
         )ix do |m|
-          token Keyword, m[1]; token Text, m[2]
-          recurse m[3]; token Text, m[4]
+          token Keyword, m[1]
+          token Text, m[2]
+          recurse(m[3]) if m[3]
+          token Text, m[4]
           push :method_definition
         end
       end

data/lib/rouge/lexers/perl.rb

@@ -93,9 +93,10 @@ module Rouge
         rule %r(m?/(\\\\|\\/|[^/\n])*/[msixpodualngc]*), re_tok
         rule %r(m(?=[/!\\{<\[\(@%\$])), re_tok, :balanced_regex
 
-        # Perl allows any non-whitespace character to delimit
-        # a regex when `m` is used.
-        rule %r(m(\S).*\1[msixpodualngc]*), re_tok
+        # arbitrary non-whitespace delimiters
+        rule %r(m\s*([^\w\s])((\\\\|\\\1)|[^\1])*?\1[msixpodualngc]*)m, re_tok
+        rule %r(m\s+(\w)((\\\\|\\\1)|[^\1])*?\1[msixpodualngc]*)m, re_tok
+
         rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[msixpodualngc]*),
           re_tok, :balanced_regex
 
@@ -120,9 +121,9 @@ module Rouge
         rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
         rule /\d+(_\d+)*/, Num::Integer
 
-        rule /'(\\\\|\\'|[^'])*'/, Str
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /`(\\\\|\\`|[^`])*`/, Str::Backtick
+        rule /'/, Punctuation, :sq
+        rule /"/, Punctuation, :dq
+        rule /`/, Punctuation, :bq
         rule /<([^\s>]+)>/, re_tok
         rule /(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
         rule /(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
@@ -178,6 +179,26 @@ module Rouge
         rule /;/, Punctuation, :pop!
       end
 
+      state :sq do
+        rule /\\[']/, Str::Escape
+        rule /[^\\']+/, Str::Single
+        rule /'/, Punctuation, :pop!
+      end
+
+      state :dq do
+        mixin :string_intp
+        rule /\\[\\tnr"]/, Str::Escape
+        rule /[^\\"]+?/, Str::Double
+        rule /"/, Punctuation, :pop!
+      end
+
+      state :bq do
+        mixin :string_intp
+        rule /\\[\\tnr`]/, Str::Escape
+        rule /[^\\`]+?/, Str::Backtick
+        rule /`/, Punctuation, :pop!
+      end
+
       [[:cb, '\{', '\}'],
        [:rb, '\(', '\)'],
        [:sb, '\[', '\]'],
@@ -192,6 +213,17 @@ module Rouge
         end
       end
 
+      state :in_interp do
+        rule /}/, Str::Interpol, :pop!
+        rule /\s+/, Text
+        rule /[a-z_]\w*/i, Str::Interpol
+      end
+
+      state :string_intp do
+        rule /[$@][{]/, Str::Interpol, :in_interp
+        rule /[$@][a-z_]\w*/i, Str::Interpol
+      end
+
       state :end_part do
         # eat the rest of the stream
         rule /.+/m, Comment::Preproc, :pop!

data/lib/rouge/lexers/powershell.rb

@@ -9,7 +9,7 @@ module Rouge
       title 'powershell'
       desc 'powershell'
       tag 'powershell'
-      aliases 'posh'
+      aliases 'posh', 'microsoftshell', 'msshell'
       filenames '*.ps1', '*.psm1', '*.psd1', '*.psrc', '*.pssc'
       mimetypes 'text/x-powershell'
 

data/lib/rouge/lexers/rust.rb

@@ -56,7 +56,7 @@ module Rouge
       id = /[a-z_]\w*/i
       hex = /[0-9a-f]/i
       escapes = %r(
-        \\ ([nrt'\\] | x#{hex}{2} | u#{hex}{4} | U#{hex}{8})
+        \\ ([nrt'"\\0] | x#{hex}{2} | u#{hex}{4} | U#{hex}{8})
       )x
       size = /8|16|32|64/
 

data/lib/rouge/lexers/scala.rb

@@ -47,12 +47,38 @@ module Rouge
         rule %r(/\*), Comment::Multiline, :comment
 
         rule /@#{idrest}/, Name::Decorator
+
+        rule /(def)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+          groups Keyword, Text, Name::Function, Text
+        end
+
+        rule /(val)(\s+)(#{idrest}|#{op}+|`[^`]+`)(\s*)/ do
+          groups Keyword, Text, Name::Variable, Text
+        end
+
+        rule /(this)(\n*)(\.)(#{idrest})/ do
+          groups Keyword, Text, Operator, Name::Property
+        end
+
+        rule /(#{idrest}|_)(\n*)(\.)(#{idrest})/ do
+          groups Name::Variable, Text, Operator, Name::Property
+        end
+
+        rule /#{upper}#{idrest}\b/, Name::Class
+
+        rule /(#{idrest})(#{whitespace}*)(\()/ do
+          groups Name::Function, Text, Operator
+        end
+
+        rule /(\.)(#{idrest})/ do
+          groups Operator, Name::Property
+        end
+
         rule %r(
           (#{keywords.join("|")})\b|
           (<[%:-]|=>|>:|[#=@_\u21D2\u2190])(\b|(?=\s)|$)
         )x, Keyword
-        rule /:(?!#{op})/, Keyword, :type
-        rule /#{upper}#{idrest}\b/, Name::Class
+        rule /:(?!#{op})/, Keyword, :type        
         rule /(true|false|null)\b/, Keyword::Constant
         rule /(import|package)(\s+)/ do
           groups Keyword, Text

data/lib/rouge/lexers/shell.rb

@@ -10,7 +10,7 @@ module Rouge
       tag 'shell'
       aliases 'bash', 'zsh', 'ksh', 'sh'
       filenames '*.sh', '*.bash', '*.zsh', '*.ksh',
-                '.bashrc', '.zshrc', '.kshrc', '.profile', 'PKGBUILD'
+                '.bashrc', '.zshrc', '.kshrc', '.profile', 'APKBUILD', 'PKGBUILD'
 
       mimetypes 'application/x-sh', 'application/x-shellscript'
 

data/lib/rouge/lexers/slim.rb

@@ -172,9 +172,9 @@ module Rouge
         # Need at top
         mixin :indented_block
 
-        rule(/,\s*\n/) { delegate ruby }
+        rule(/[,\\]\s*\n/) { delegate ruby }
         rule /[ ]\|[ \t]*\n/, Str::Escape
-        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+        rule(/.*?(?=([,\\]$| \|)?[ \t]*$)/) { delegate ruby }
       end
 
       state :filter_block do

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 /\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 /./, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :comments
+
+        rule /[\-+]?0[xX]\h+/, Num::Hex
+
+        # radix float
+        rule /[\-+]?\d+r[0-9a-zA-Z]*(\.[0-9A-Z]*)?/, Num::Float
+
+        # normal float
+        rule /[\-+]?((\d+(\.\d+)?([eE][\-+]?\d+)?(pi)?)|pi)/, Num::Float
+
+        rule /[\-+]?\d+/, Num::Integer
+
+        rule /\$(\\.|.)/, Str::Char
+
+        rule /"([^\\"]|\\.)*"/, Str
+
+        # symbols (single-quote notation)
+        rule /'([^\\']|\\.)*'/, Str::Other
+
+        # symbols (backslash notation)
+        rule /\\\w+/, Str::Other
+
+        # symbol arg
+        rule /[A-Za-z_]\w*:/, Name::Label
+
+        rule /[A-Z]\w*/, Name::Class
+
+        # primitive
+        rule /_\w+/, Name::Function
+
+        # main identifiers section
+        rule /[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 /~\w+/, Name::Variable::Global
+
+        rule /[\{\}()\[\];,\.]/, Punctuation
+
+        # operators. treat # (array unpack) as an operator
+        rule /[\+\-\*\/&\|%<>=]+/, Operator
+        rule /[\^:#]/, Operator
+
+        # treat curry argument as a special operator
+        rule /\b_\b/, Name::Builtin
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/xml.rb

@@ -7,7 +7,7 @@ module Rouge
       title "XML"
       desc %q(<desc for="this-lexer">XML</desc>)
       tag 'xml'
-      filenames *%w(*.xml *.xsl *.rss *.xslt *.xsd *.wsdl *.svg)
+      filenames *%w(*.xml *.xsl *.rss *.xslt *.xsd *.wsdl *.svg *.plist)
       mimetypes *%w(
         text/xml
         application/xml

data/lib/rouge/lexers/xojo.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Xojo < RegexLexer
+      title "Xojo"
+      desc "Xojo"
+      tag 'xojo'
+      aliases 'realbasic'
+      filenames '*.xojo_code', '*.xojo_window', '*.xojo_toolbar', '*.xojo_menu'
+
+      keywords = %w(
+          addhandler aggregates array asc assigns attributes begin break
+          byref byval call case catch class const continue char ctype declare
+          delegate dim do downto each else elseif end enum event exception
+          exit extends false finally for function global goto if
+          implements inherits interface lib loop mod module
+          new next nil object of optional paramarray
+          private property protected public raise raiseevent rect redim
+          removehandler return select shared soft static step sub super
+          then to true try until using uend uhile
+        )
+
+      keywords_type = %w(
+          boolean cfstringref cgfloat cstring curency date double int8 int16
+          int32 int64 integer ostype pstring ptr short single
+          single string structure variant uinteger uint8 uint16 uint32 uint64
+          ushort windowptr wstring
+        )
+
+      operator_words = %w(
+          addressof and as in is isa mod not or xor
+        )
+
+      state :root do
+        rule /\s+/, Text::Whitespace
+
+        rule /rem\b.*?$/i, Comment::Single
+        rule /\/\/.*$/, Comment::Single
+        rule /\#tag Note.*\#tag EndNote/m, Comment::Preproc
+        rule /\s*[#].*$/x, Comment::Preproc
+
+        rule /".*?"/, Literal::String::Double
+        rule /[(){}!#,:]/, Punctuation
+
+        rule /\b(?:#{keywords.join('|')})\b/i, Keyword
+        rule /\b(?:#{keywords_type.join('|')})\b/i, Keyword::Declaration
+
+        rule /\b(?:#{operator_words.join('|')})\b/i, Operator
+        rule /[+-]?(\d+\.\d*|\d*\.\d+)/i, Literal::Number::Float
+        rule /[+-]?\d+/, Literal::Number::Integer
+        rule /&[CH][0-9a-f]+/i, Literal::Number::Hex
+        rule /&O[0-7]+/i, Literal::Number::Oct
+
+        rule /\b[\w\.]+\b/i, Text
+        rule(%r(<=|>=|<>|[=><\+\-\*\/\\]), Operator)
+      end
+    end
+  end
+end