rouge 5.0.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9123349dc8d157c07642dd422b2ce6589c42728fcc9a204255b55c2cdac11a41
-  data.tar.gz: b077e0041bb215f3e3c33799e333c4983df1d98d35ecf0606e82563de05c2c0b
+  metadata.gz: 4fc775e033107ca0ecb870139f9a3863aea5eb90e26fc2314672757b3f745ca1
+  data.tar.gz: 26cae2d0593b1bf5ccd27d64e89a5dbdd2bb82fffba4e5019209e6a4c07a16ed
 SHA512:
-  metadata.gz: 3b94cebfc00d70f126ae1ee7675c123d1d2f6bbbdaba02b659c1f864392f457f7e934117f43a1f17691eefa1c3b2b160f2c2e43f368bcf39737a766d98d87e7e
-  data.tar.gz: d21221f27e9a98c1698a870fde934dc914e6cb7fea60ad782e2f3bcfa795ea7fc6eac2034193266e73ec8194f53f6c69d4a812467612536417bfb60bf39aec07
+  metadata.gz: 175d6d4949afdfa9366b5706c4dc47dc81379be9b5fb698d09d49a21a3b550213b716f3e8469297d442f52f3ff52d1eed6e825dc7fadea4ace10c3f426f9acb8
+  data.tar.gz: 99871aa091f369f89fc780430690752364d6060905d5facaf6e535cfc0693e5869df92360a1cb443de4279f2293e0343f82c27c962abb51cdff6b9e52f7e6ddd

data/lib/rouge/demos/addmusick

@@ -0,0 +1,12 @@
+#SPC {
+  #author "jneen"
+  #title "oh, you know"
+  #game "N/A"
+}
+
+#option TempoImmunity
+
+"INST=@8o4"
+
+#0
+l8INSTq7Fdq7Eeq7Ffge4q78cq7Fd^4r4^4

data/lib/rouge/demos/java

@@ -1,3 +1,6 @@
+import java.util.List;
+import static java.util.Collections.sort;
+
 public class java {
     public static void main(String[] args) {
         System.out.println("Hello World");

data/lib/rouge/lexer.rb

@@ -225,6 +225,12 @@ module Rouge
       def register(name, lexer)
         # reset an existing list of lexers
         @all = nil if defined?(@all)
+        name = name.to_s
+
+        if registry.key?(name)
+          Kernel.warn("duplicate lexer tag/alias: #{name}")
+        end
+
         registry[name.to_s] = lexer
       end
 
@@ -351,6 +357,35 @@ module Rouge
       @debug = Lexer.debug_enabled? && bool_option('debug')
     end
 
+    def inspect
+      parts = []
+      inspect_parts do |*new_parts|
+        parts.concat(new_parts)
+      end
+
+      parts.join
+    end
+
+    def inspect_parts(&b)
+      yield "#<", self.class.name, " "
+
+      first = true
+      @options.each do |k, v|
+        yield (first ? '?' : '&')
+        first = false
+
+        yield k, "=", v
+      end
+
+      inspect_details(&b)
+
+      yield ">"
+    end
+
+    def inspect_details
+      # pass
+    end
+
     def eager_load!
       self.class.eager_load!
     end

data/lib/rouge/lexers/addmusick.rb

@@ -0,0 +1,251 @@
+# documentation:
+#   - https://bin.smwcentral.net/u/1743/syntax_reference.html
+#   - https://codeberg.org/jneen/ramekin
+module Rouge
+  module Lexers
+    class AddmusicK < RegexLexer
+      title 'AddmusicK'
+      desc 'AddmusicK and Ramekin MML (https://smwc.me/s/37906, https://codeberg.org/jneen/ramekin)'
+      tag 'addmusick'
+      aliases 'ramekin', 'addmusickff', 'amk', 'rmk'
+
+      filenames '*.amk', '*.rmk', '*.mml'
+
+      KEYWORDS = Set.new %w(
+        samples instruments instrument path default optimized pack
+      )
+
+      def self.detect?(analyzer)
+        return true if analyzer.match?(/\A(\s+|;.*?$)*#spc\s*[{]/i)
+        return true if analyzer.match?(/\A(\s+|;.*?$)*#option smwvtable\b/i)
+        return true if analyzer.match?(/\A(\s+|;.*?$)*#amk \d/i)
+      end
+
+      def initialize(*)
+        super
+
+        @highlight_macros = bool_option(:macros) { true }
+      end
+
+      def note_token
+        return Str if @last == :rest
+        return Name::Function if @last == :fade || @last == :arp
+        Str::Symbol
+      end
+
+      # override
+      # [jneen] This override is required because AddmusicK has an extremely
+      # free-form macro system that doesn't "look like a function call" the same
+      # way that normal preproc macros do. They are quite literally arbitrary
+      # characters that pre-empt other tokens, in all states.
+      #
+      # AddmusicK is technically *even more* lenient than this about where macros
+      # can show up, e.g. "F=v123" will attempt to substitute into $FF twice.
+      # Neither Ramekin nor this lexer support that.
+      def step(state, stream)
+        if @highlight_macros
+          @macros.reverse_each do |macro|
+            if stream.skip(macro)
+              token Comment::Preproc
+              return true
+            end
+          end
+        end
+
+        super(state, stream)
+      end
+
+      start do
+        @macros = []
+      end
+
+      state :whitespace do
+        rule %r/\s+/, Text
+        rule %r/;.*/, Comment
+      end
+
+      state :ties do
+        rule %r/\^/ do
+          token(note_token)
+          push :post_note
+        end
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r/#spc/i, Keyword, :spc_pre
+        rule %r/(#amk)(\s+)(\d+)/ do
+          groups Keyword, Text, Num
+        end
+
+        rule %r/(#option)(\s+)(\w+)/ do
+          groups Keyword, Text, Name::Tag
+        end
+
+        rule %r/#path\b/, Keyword, :string_arg
+        rule %r/#tune:\S+/, Operator::Word
+        rule %r(#legato/toggle), Operator::Word
+        rule %r(#sustain/global-toggle), Operator::Word
+        rule %r(#echo/toggle), Operator::Word
+        rule %r(#amplify:\d+), Operator::Word
+        rule %r(#echo/\w+:\S+), Comment::Preproc
+        rule %r(#tuning:\h\h\h\h), Operator::Word
+        arg = %r(\d+|max(?:-\d+)?)
+        rule %r(#adsr:#{arg}(?:,#{arg}){3}), Operator::Word
+        rule %r(#adsr:(?:flat|reset)), Operator::Word
+        rule %r(#incompatible:\w+), Comment::Preproc
+        rule %r(#bpm:\d+), Operator::Word
+        rule %r(#arp/off), Operator::Word
+        rule %r/#(?:arp|gliss)\[/ do
+          token Operator::Word
+          @last = :arp
+          push :arp
+          push :post_note
+        end
+
+        rule %r(#ifn?def\s*\w+), Comment::Preproc
+
+        rule %r/[$]\h\h/, Name::Tag
+        rule %r/@\d+/, Name::Tag
+        rule %r/@\w+/, Name::Tag
+
+        # vcmds
+        rule %r/[tw]\d+/, Name::Function
+        rule %r/[v_][+-]?\d+/, Name::Function
+        rule %r/y[LR]?\d+/, Name::Function
+        rule %r/y[C]/, Name::Function
+
+        # note intrinsics
+        rule %r/[il]\d+/, Name::Builtin
+        rule %r/[uh][+-]?\d+/, Name::Builtin
+        rule %r/o\d/, Name::Builtin
+        rule %r/q\d\h/, Name::Builtin
+
+        # notes
+        rule %r/[a-g][+-]?/ do
+          @last = :note
+          token Str::Symbol
+          push :post_note
+        end
+
+        mixin :ties
+
+        rule %r/#[.][\w-]*/, Name::Label
+
+        rule %r/\\/ do
+          @last = :fade
+          token Name::Function
+          push :post_note
+        end
+
+        rule %r/r/ do
+          @last = :rest
+          token Str
+          push :post_note
+        end
+
+        rule %r/p\d+,\d+(?:,\d+)?/, Name::Function
+
+        rule %r/#\d/ do
+          token Name::Namespace
+          @last = nil
+        end
+
+        rule %r/#(\w+)/ do |m|
+          if KEYWORDS.include?(m[1])
+            token Keyword
+          else
+            token Name::Class
+          end
+        end
+
+        rule %r/(")([^"=]+)(=)/ do |m|
+          @macros << m[2].strip
+          @macros.sort_by!(&:size)
+          groups Comment::Preproc, Name::Class, Comment::Preproc
+          push :macro
+        end
+
+        rule %r/".*?"/m, Str::Double
+        rule %r([{},/<>~&'`]), Punctuation
+        rule %r([|]) do
+          token Punctuation
+          @last = nil
+        end
+
+        rule %r/[(][!]/, Name::Namespace, :remote
+
+        rule %r/[(]\s*[\w-]+\s*[)]\d*/ do
+          token Name::Namespace
+          @last = nil
+        end
+
+        rule %r/[*]\d*/ do
+          token Name::Namespace
+          @last = nil
+        end
+
+        rule %r/\[\[?/, Name::Namespace
+        rule %r/\]\]?\d*/ do
+          token Name::Namespace
+          @last = nil
+        end
+
+        rule %r/./ do
+          if @highlight_macros
+            fallthrough!
+          else
+            token Text
+          end
+        end
+      end
+
+      state :post_note do
+        rule(/=\d+/) { token(note_token); pop! }
+        rule(/\d+[.]*/) { token(note_token); pop! }
+        rule(//) { pop! }
+      end
+
+      state :string_arg do
+        mixin :whitespace
+        rule %r/".*?"/, Str::Double, :pop!
+        rule(//) { pop! }
+      end
+
+      state :spc_pre do
+        mixin :whitespace
+        rule %r/[{]/, Punctuation, :spc
+        rule(//) { pop! }
+      end
+
+      state :spc do
+        mixin :whitespace
+        rule %r/#(?:title|author|game|comment)/, Name::Attribute
+        rule %r/".*?"/, Str::Double
+        rule(/[}]/) { token Punctuation; pop! 2 }
+      end
+
+      state :macro do
+        rule %r/"/, Comment::Preproc, :pop!
+        mixin :root
+      end
+
+      state :arp do
+        mixin :whitespace
+        mixin :ties
+        rule %r([:/]), Punctuation
+        rule %r/[+-]?\d+/, Num
+        rule %r/\]/, Operator::Word, :pop!
+      end
+
+      state :remote do
+        mixin :whitespace
+        rule %r/,/, Punctuation
+        rule %r/\d+/, Name::Namespace
+        rule %r/#\w+/, Keyword
+        rule %r/\w+/, Name::Namespace
+        rule %r/[)]/, Name::Namespace, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/apiblueprint.rb

@@ -9,7 +9,7 @@ module Rouge
       desc 'Markdown based API description language.'
 
       tag 'apiblueprint'
-      aliases 'apiblueprint', 'apib'
+      aliases 'apib'
       filenames '*.apib'
       mimetypes 'text/vnd.apiblueprint'
 

data/lib/rouge/lexers/apple_script.rb

@@ -7,8 +7,8 @@ module Rouge
       title "AppleScript"
       desc "The AppleScript scripting language by Apple Inc. (https://developer.apple.com/library/archive/documentation/AppleScript/Conceptual/AppleScriptLangGuide/introduction/ASLR_intro.html)"
 
-      tag 'applescript'
-      aliases 'applescript'
+      tag 'apple_script'
+      aliases 'applescript', 'osa'
 
       filenames '*.applescript', '*.scpt'
 

data/lib/rouge/lexers/cypher.rb

@@ -5,7 +5,6 @@ module Rouge
   module Lexers
     class Cypher < RegexLexer
       tag 'cypher'
-      aliases 'cypher'
       filenames '*.cypher'
       mimetypes 'application/x-cypher-query'
 

data/lib/rouge/lexers/elixir.rb

@@ -10,7 +10,7 @@ module Rouge
       desc "Elixir language (elixir-lang.org)"
 
       tag 'elixir'
-      aliases 'elixir', 'exs'
+      aliases 'exs'
 
       filenames '*.ex', '*.exs'
 

data/lib/rouge/lexers/gdscript.rb

@@ -7,7 +7,7 @@ module Rouge
       title "GDScript"
       desc "The Godot Engine programming language (https://godotengine.org/)"
       tag 'gdscript'
-      aliases 'gd', 'gdscript'
+      aliases 'gd', 'godot'
       filenames '*.gd'
       mimetypes 'text/x-gdscript', 'application/x-gdscript'
 

data/lib/rouge/lexers/go.rb

@@ -7,7 +7,7 @@ module Rouge
       title "Go"
       desc 'The Go programming language (http://golang.org)'
       tag 'go'
-      aliases 'go', 'golang'
+      aliases 'golang'
       filenames '*.go'
 
       mimetypes 'text/x-go', 'application/x-go'

data/lib/rouge/lexers/hack.rb

@@ -9,7 +9,7 @@ module Rouge
       title 'Hack'
       desc 'The Hack programming language (hacklang.org)'
       tag 'hack'
-      aliases 'hack', 'hh'
+      aliases 'hh'
       filenames '*.php', '*.hh'
 
       def self.detect?(text)

data/lib/rouge/lexers/haxe.rb

@@ -7,7 +7,7 @@ module Rouge
       desc "Haxe Cross-platform Toolkit (http://haxe.org)"
 
       tag 'haxe'
-      aliases 'hx', 'haxe'
+      aliases 'hx'
       filenames '*.hx'
       mimetypes 'text/haxe', 'text/x-haxe', 'text/x-hx'
 

data/lib/rouge/lexers/java.rb

@@ -14,11 +14,12 @@ module Rouge
       keywords = %w(
         assert break case catch continue default do else finally for
         if goto instanceof new return switch this throw try while
+        yield when
       )
 
       declarations = %w(
-        abstract const enum extends final implements native private protected
-        public static strictfp super synchronized throws transient volatile
+        abstract const extends final implements native permits private protected
+        public sealed static strictfp super synchronized throws transient volatile
       )
 
       types = %w(boolean byte char double float int long short var void)
@@ -47,12 +48,14 @@ module Rouge
           token Operator, m[4]
         end
 
+        rule %r/non-sealed\b/, Keyword::Declaration
+        rule %r/@interface\b/, Keyword::Declaration, :class
         rule %r/@#{id}/, Name::Decorator
         rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
         rule %r/(?:#{types.join('|')})\b/, Keyword::Type
         rule %r/(?:true|false|null)\b/, Keyword::Constant
-        rule %r/(?:class|interface|record)\b/, Keyword::Declaration, :class
-        rule %r/(?:import|package)\b/, Keyword::Namespace, :import
+        rule %r/(?:class|enum|interface|record)\b/, Keyword::Declaration, :class
+        rule %r/(?:import(?:\s+(?:static|module))?|package)\b/, Keyword::Namespace, :import
         rule %r/"""\s*\n.*?(?<!\\)"""/m, Str::Heredoc
         rule %r/"(\\\\|\\"|[^"])*"/, Str
         rule %r/'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char

data/lib/rouge/lexers/jsx.rb

@@ -8,7 +8,7 @@ module Rouge
       title 'JSX'
       desc 'An XML-like syntax extension to JavaScript (facebook.github.io/jsx/)'
       tag 'jsx'
-      aliases 'jsx', 'react'
+      aliases 'react'
       filenames '*.jsx'
 
       mimetypes 'text/x-jsx', 'application/x-jsx'

data/lib/rouge/lexers/lean.rb

@@ -8,7 +8,6 @@ module Rouge
       title 'Lean'
       desc 'The Lean programming language (leanprover.github.io)'
       tag 'lean'
-      aliases 'lean'
       filenames '*.lean'
 
       def self.keywords

data/lib/rouge/lexers/make.rb

@@ -103,6 +103,8 @@ module Rouge
           groups Keyword, Text, Comment, Text
         end
 
+        rule %r/#.*\n?/, Comment
+
         rule %r/(\t[\t ]*)([@-]?)/ do
           groups Text, Punctuation
           push :shell_line

data/lib/rouge/lexers/markdown.rb

@@ -26,12 +26,6 @@ module Rouge
 
         rule %r/\\./, Str::Escape
 
-        rule %r/^[\S ]+\n(?:---*)\n/, Generic::Heading
-        rule %r/^[\S ]+\n(?:===*)\n/, Generic::Subheading
-
-        rule %r/^#(?=[^#]).*?$/, Generic::Heading
-        rule %r/^##*.*?$/, Generic::Subheading
-
         rule %r/^([ \t]*)(`{3,}|~{3,})([^\n]*\n)((.*?)(\n\1)(\2))?/m do |m|
           name = m[3].strip
           sublexer =
@@ -73,6 +67,12 @@ module Rouge
 
         rule %r/(`+)(?:#{edot}|\n)+?\1/, Str::Backtick
 
+        rule %r/^[\S ]+\n(?:---*)\n/, Generic::Heading
+        rule %r/^[\S ]+\n(?:===*)\n/, Generic::Subheading
+
+        rule %r/^#(?=[^#]).*?$/, Generic::Heading
+        rule %r/^##*.*?$/, Generic::Subheading
+
         # various uses of * are in order of precedence
 
         # line breaks
@@ -139,6 +139,7 @@ module Rouge
 
         rule %r/[(]/ do
           token Punctuation
+          pop!
           push :inline_title
           push :inline_url
         end

data/lib/rouge/lexers/mojo.rb

@@ -9,7 +9,6 @@ module Rouge
       title "Mojo"
       desc "The Mojo programming language (modular.com)"
       tag 'mojo'
-      aliases 'mojo'
       filenames '*.mojo', '*.🔥'
       mimetypes 'text/x-mojo', 'application/x-mojo'
 

data/lib/rouge/lexers/perl.rb

@@ -17,13 +17,13 @@ module Rouge
         return true if text.shebang? 'perl'
       end
 
-      keywords = %w(
+      KEYWORDS = Set.new %w(
         case continue do else elsif for foreach if last my next our
         redo reset then unless until while use print new BEGIN CHECK
         INIT END return
       )
 
-      builtins = %w(
+      BUILTINS = Set.new %w(
         abs accept alarm atan2 bind binmode bless caller chdir chmod
         chomp chop chown chr chroot close closedir connect continue cos
         crypt dbmclose dbmopen defined delete die dump each endgrent
@@ -49,25 +49,108 @@ module Rouge
         utime values vec wait waitpid wantarray warn write
       )
 
+      OPERATOR_WORDS = Set.new %w(eq lt gt le ge ne not and or cmp)
+
       re_tok = Str::Regex
 
       state :balanced_regex do
-        rule %r(/(\\[\\/]|[^/])*/[egimosx]*)m, re_tok, :pop!
-        rule %r(!(\\[\\!]|[^!])*![egimosx]*)m, re_tok, :pop!
-        rule %r(\\(\\\\|[^\\])*\\[egimosx]*)m, re_tok, :pop!
-        rule %r({(\\[\\}]|[^}])*}[egimosx]*), re_tok, :pop!
-        rule %r(<(\\[\\>]|[^>])*>[egimosx]*), re_tok, :pop!
-        rule %r(\[(\\[\\\]]|[^\]])*\][egimosx]*), re_tok, :pop!
-        rule %r[\((\\[\\\)]|[^\)])*\)[egimosx]*], re_tok, :pop!
-        rule %r(@(\\[\\@]|[^@])*@[egimosx]*), re_tok, :pop!
-        rule %r(%(\\[\\%]|[^%])*%[egimosx]*), re_tok, :pop!
-        rule %r(\$(\\[\\\$]|[^\$])*\$[egimosx]*), re_tok, :pop!
+        rule %r/\s+/, Text
+        rule %r/./ do |m|
+          pop!
+          open_regex!(m[0])
+          token Str::Delimiter
+        end
       end
 
-      state :root do
+      state :continued_regex do
+        mixin :regex
+      end
+
+      state :regex_flags do
+        rule %r/[msixpodualngcr]+/, Str::Affix
+        rule(//) { pop! }
+      end
+
+      state :regex_escapes do
+        rule %r/\\[0-7][0-7][0-7]/, Str::Escape
+        rule %r/\\x\h\h/, Str::Escape
+        rule %r/\\.(?:[{]\w+[}])?/, Str::Escape
+      end
+
+      state :regex do
+        rule %r/./ do |m|
+          if m[0] == @regex_end
+            token Str::Delimiter
+            goto :regex_flags
+          else
+            fallthrough!
+          end
+        end
+
+        mixin :regex_escapes
+        rule %r/[{]\d+(?:,\d+)?[}]/, Operator
+        rule %r/\[\^?/, Punctuation, :regex_char_class
+        rule %r/[?]|[.]|[|]|[*+][?]?/, Operator
+        rule %r/[(](?:[?][=!<:]?)?/, Punctuation
+        rule %r/[(][?]<!/, Punctuation
+        rule %r/[{})]/, Punctuation
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_char_class do
+        rule(/\^/) { token Punctuation; goto :regex_char_class_inner }
+        rule(/-/) { token Str::Regex; goto :regex_char_class_inner }
+        rule(//) { goto :regex_char_class_inner }
+      end
+
+      state :regex_char_class_inner do
+        mixin :regex_escapes
+        rule %r/-(?!\])/, Punctuation
+        rule %r/\\./, Str::Escape
+        rule %r/[^-\]\\]+/, Str::Regex
+        rule %r/\]/, Punctuation, :pop!
+      end
+
+      BALANCED_DELIMITERS = {
+        '{' => '}',
+        '(' => ')',
+        '[' => ']',
+        '<' => '>',
+      }
+
+      def open_regex!(delimiter)
+        @regex_end = BALANCED_DELIMITERS.fetch(delimiter, delimiter)
+        push :regex
+      end
+
+      def open_regex_operator!(delimiter)
+        if BALANCED_DELIMITERS.key?(delimiter)
+          push :balanced_regex
+        else
+          push :continued_regex
+        end
+
+        open_regex!(delimiter)
+      end
+
+      state :expr_start do
+        mixin :whitespace
+        rule %r(/) do
+          open_regex!('/')
+          token Str::Delimiter
+        end
+
+        rule(//) { pop! }
+      end
+
+      state :whitespace do
         rule %r/#.*/, Comment::Single
+        rule %r/\s+/, Text
         rule %r/^=[a-zA-Z0-9]+\s+.*?\n=cut/m, Comment::Multiline
-        rule %r/(?:#{keywords.join('|')})\b/, Keyword
+      end
+
+      state :root do
+        mixin :whitespace
 
         rule %r/(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
           groups Keyword, Text, Name, Text, Punctuation, Text
@@ -75,34 +158,37 @@ module Rouge
           push :format
         end
 
-        rule %r/(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
-
-        # substitution/transliteration: balanced delimiters
-        rule %r((?:s|tr|y){(\\\\|\\}|[^}])*}\s*), re_tok, :balanced_regex
-        rule %r((?:s|tr|y)<(\\\\|\\>|[^>])*>\s*), re_tok, :balanced_regex
-        rule %r((?:s|tr|y)\[(\\\\|\\\]|[^\]])*\]\s*), re_tok, :balanced_regex
-        rule %r[(?:s|tr|y)\((\\\\|\\\)|[^\)])*\)\s*], re_tok, :balanced_regex
-
-        # substitution/transliteration: arbitrary non-whitespace delimiters
-        rule %r((?:s|tr|y)\s*([^\w\s])((\\\\|\\\1)|[^\1])*?\1((\\\\|\\\1)|[^\1])*?\1[msixpodualngcr]*)m, re_tok
-        rule %r((?:s|tr|y)\s+(\w)((\\\\|\\\1)|[^\1])*?\1((\\\\|\\\1)|[^\1])*?\1[msixpodualngcr]*)m, re_tok
-
-        # matches: common case, m-optional
-        rule %r(m?/(\\\\|\\/|[^/\n])*/[msixpodualngc]*), re_tok
-        rule %r(m(?=[/!\\{<\[\(@%\$])), re_tok, :balanced_regex
+        rule %r/\w+/ do |m|
+          w = m[0]
+          if KEYWORDS.include?(w)
+            token Keyword
+          elsif OPERATOR_WORDS.include?(w)
+            token Operator::Word
+          else
+            fallthrough!
+          end
+        end
 
-        # 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{(?=[a-z_]\w*(\s*#.*\n)*\s*=>)}i do
+          push :fat_comma
+        end
 
-        rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[msixpodualngc]*),
-          re_tok, :balanced_regex
+        # non-whitespace delimiters that match \w are allowed only
+        # if there is whitespace between the operator and the delimiter.
+        # here we use a \b to detect that case in a way that shouldn't
+        # cause backtracking explosion.
+        regex_delim = /[^\w\s]|\b\w/
 
-        rule %r/\s+/, Text
+        rule %r/(s|tr|y)(\s*)(#{regex_delim})/ do |m|
+          open_regex_operator!(m[3])
+          groups Str::Affix, Text, Str::Delimiter
+        end
 
-        rule(/(?=[a-z_]\w*(\s*#.*\n)*\s*=>)/i) { push :fat_comma }
+        rule %r/(m)(\s*)(#{regex_delim})/ do |m|
+          open_regex!(m[3])
+          groups Str::Affix, Text, Str::Delimiter
+        end
 
-        rule %r/(?:#{builtins.join('|')})\b/, Name::Builtin
         rule %r/((__(DIE|WARN)__)|(DATA|STD(IN|OUT|ERR)))\b/,
           Name::Builtin::Pseudo
 
@@ -113,7 +199,9 @@ module Rouge
         rule %r/\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/_-](?!\w)/, Name::Variable::Global
         rule %r/[$@%&*][$@%&*#_]*(?=[a-z{\[;])/i, Name::Variable, :varname
 
-        rule %r/[-+\/*%=<>&^\|!\\~]=?/, Operator
+        rule %r/\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
+          Operator, :expr_start
+        rule %r/[-+\/*%=<>&^\|!\\~]=?/, Operator, :expr_start
 
         rule %r/0_?[0-7]+(_[0-7]+)*/, Num::Oct
         rule %r/0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
@@ -133,11 +221,20 @@ module Rouge
         rule %r/(q|qq|qw|qr|qx)</, Str::Other, :lt_string
         rule %r/(q|qq|qw|qr|qx)(\W)(.|\n)*?\2/, Str::Other
 
-        rule %r/package\s+/, Keyword, :modulename
-        rule %r/sub\s+/, Keyword, :funcname
-        rule %r/\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
-          Operator
-        rule %r/[()\[\]:;,<>\/?{}]/, Punctuation
+        rule %r/package\b/, Keyword, :modulename
+        rule %r/sub\b/, Keyword, :funcname
+        rule %r/[(]/, Punctuation, :expr_start
+        rule %r/[)\[\]:;,<>\/?{}]/, Punctuation
+
+        rule %r/[a-z]\w*/ do |m|
+          w = m[0]
+          if BUILTINS.include?(w)
+            token Name::Builtin
+          else
+            fallthrough!
+          end
+        end
+
         rule(/(?=\w)/) { push :name }
       end
 

data/lib/rouge/lexers/php.rb

@@ -7,7 +7,7 @@ module Rouge
       title "PHP"
       desc "The PHP scripting language (php.net)"
       tag 'php'
-      aliases 'php', 'php3', 'php4', 'php5'
+      aliases 'php3', 'php4', 'php5'
       filenames '*.php', '*.php[345t]','*.phtml',
                 # Support Drupal file extensions, see:
                 # https://github.com/gitlabhq/gitlabhq/issues/8900

data/lib/rouge/lexers/plist.rb

@@ -5,7 +5,6 @@ module Rouge
     class Plist < RegexLexer
       desc 'plist'
       tag 'plist'
-      aliases 'plist'
       filenames '*.plist', '*.pbxproj'
 
       mimetypes 'text/x-plist', 'application/x-plist'

data/lib/rouge/lexers/postscript.rb

@@ -8,7 +8,7 @@ module Rouge
       title "PostScript"
       desc "The PostScript language (adobe.com/devnet/postscript.html)"
       tag "postscript"
-      aliases "postscr", "postscript", "ps", "eps"
+      aliases "postscr", "ps", "eps"
       filenames "*.ps", "*.eps"
       mimetypes "application/postscript"
 

data/lib/rouge/lexers/prolog.rb

@@ -7,7 +7,6 @@ module Rouge
       title "Prolog"
       desc "The Prolog programming language (http://en.wikipedia.org/wiki/Prolog)"
       tag 'prolog'
-      aliases 'prolog'
       filenames '*.pro', '*.P', '*.prolog', '*.pl'
       mimetypes 'text/x-prolog'
 

data/lib/rouge/lexers/prometheus.rb

@@ -5,7 +5,6 @@ module Rouge
     class Prometheus < RegexLexer
       desc 'prometheus'
       tag 'prometheus'
-      aliases 'prometheus'
       filenames '*.prometheus'
 
       mimetypes 'text/x-prometheus', 'application/x-prometheus'

data/lib/rouge/lexers/properties.rb

@@ -11,10 +11,10 @@ module Rouge
       filenames '*.properties'
       mimetypes 'text/x-java-properties'
 
-      identifier = /[\w.-]+/
+      identifier = /(?:[\w.-]|\\u\h{4}|\\.)+/
 
       state :basic do
-        rule %r/[!#].*?\n/, Comment
+        rule %r/[!#].*/, Comment
         rule %r/\s+/, Text
         rule %r/\\\n/, Str::Escape
       end

data/lib/rouge/lexers/qml.rb

@@ -9,7 +9,6 @@ module Rouge
       title "QML"
       desc 'QML, a UI markup language'
       tag 'qml'
-      aliases 'qml'
       filenames '*.qml'
 
       mimetypes 'application/x-qml', 'text/x-qml'

data/lib/rouge/lexers/r.rb

@@ -7,7 +7,7 @@ module Rouge
       title "R"
       desc 'The R statistics language (r-project.org)'
       tag 'r'
-      aliases 'r', 'R', 's', 'S'
+      aliases 'R', 's', 'S'
       filenames '*.R', '*.r', '.Rhistory', '.Rprofile'
       mimetypes 'text/x-r-source', 'text/x-r', 'text/x-R'
 

data/lib/rouge/lexers/scala.rb

@@ -7,7 +7,6 @@ module Rouge
       title "Scala"
       desc "The Scala programming language (scala-lang.org)"
       tag 'scala'
-      aliases 'scala'
       filenames '*.scala', '*.sbt'
 
       mimetypes 'text/x-scala', 'application/x-scala'

data/lib/rouge/lexers/shell.rb

@@ -161,9 +161,21 @@ module Rouge
         mixin :root
       end
 
+      state :curly_interp do
+        rule %r/[}]/, Str::Interpol, :pop!
+        rule %r/[{]/, Operator, :curly_inner
+        mixin :root
+      end
+
+      state :curly_inner do
+        rule %r/[{]/, Operator, :push
+        rule %r/[}]/, Operator, :pop!
+        mixin :root
+      end
+
       state :math do
         rule %r/\)\)/, Keyword, :pop!
-        rule %r([-+*/%^|&!]|\*\*|\|\|), Operator
+        rule %r([-+*/%^|&!]|\*\*|\|\||<<|>>), Operator
         rule %r/\d+(#\w+)?/, Num
         mixin :root
       end
@@ -189,7 +201,11 @@ module Rouge
         rule %r/\\$/, Str::Escape # line continuation
         rule %r/\\./, Str::Escape
         rule %r/\$\(\(/, Keyword, :math
-        rule %r/\$\(/, Str::Interpol, :paren_interp
+        rule %r/\$[(]/, Str::Interpol, :paren_interp
+
+        # see https://www.gnu.org/software/bash/manual/bash.html#Command-Substitution-1
+        rule %r/\$[{][\s|]/, Str::Interpol, :curly_interp
+
         rule %r/\${#?/, Keyword, :curly
         rule %r/`/, Str::Backtick, :backticks
         rule %r/\$#?(\w+|.)/, Name::Variable

data/lib/rouge/lexers/smarty.rb

@@ -7,7 +7,6 @@ module Rouge
       title "Smarty"
       desc 'Smarty Template Engine'
       tag 'smarty'
-      aliases 'smarty'
       filenames '*.tpl', '*.smarty'
       mimetypes 'application/x-smarty', 'text/x-smarty'
 

data/lib/rouge/lexers/tap.rb

@@ -6,7 +6,6 @@ module Rouge
       title 'TAP'
       desc 'Test Anything Protocol'
       tag 'tap'
-      aliases 'tap'
       filenames '*.tap'
 
       mimetypes 'text/x-tap', 'application/x-tap'

data/lib/rouge/lexers/tulip.rb

@@ -5,7 +5,6 @@ module Rouge
     class Tulip < RegexLexer
       desc 'the tulip programming language (twitter.com/tuliplang)'
       tag 'tulip'
-      aliases 'tulip'
 
       filenames '*.tlp'
 

data/lib/rouge/lexers/vhdl.rb

@@ -43,8 +43,10 @@ module Rouge
       state :whitespace do
         rule %r/\s+/, Text
         rule %r/\n/, Text
-        # Find Comments (VHDL doesn't support multiline comments)
+        # Find single-line comments "-- ..."
         rule %r/--.*$/, Comment::Single
+        # Find delimited comments "/* ... */"
+        rule %r{/\*.*?\*/}m, Comment::Multiline
       end
 
       state :statements do

data/lib/rouge/lexers/vue.rb

@@ -5,6 +5,19 @@ require_relative 'html'
 module Rouge
   module Lexers
     class Vue < HTML
+      # HTML extended with Vue template attribute shorthands.
+      # Used as the delegate lexer for <template> content so that directives
+      # like @click and @click.disabled are recognised without polluting the plain
+      # HTML lexer with framework-specific syntax.
+      class TemplateHTML < HTML
+        prepend :tag do
+          rule %r/([@a-zA-Z0-9_:#\[\]()*.-]+\s*)(=)(\s*)/m do
+            groups Name::Attribute, Operator, Text
+            push :attr
+          end
+        end
+      end
+
       desc 'Vue.js single-file components'
       tag 'vue'
       aliases 'vuejs'
@@ -38,7 +51,7 @@ module Rouge
       prepend :root do
         rule %r/(<)(\s*)(template)/ do
           groups Name::Tag, Text, Keyword
-          @lang = HTML
+          @lang = TemplateHTML
           push :template
           push :lang_tag
         end
@@ -59,7 +72,10 @@ module Rouge
       end
 
       prepend :tag do
-        rule %r/[a-zA-Z0-9_:#\[\]()*.-]+\s*=\s*/m, Name::Attribute, :attr
+        rule %r/([a-zA-Z0-9_:#\[\]()*.-]+\s*)(=)(\s*)/m do
+          groups Name::Attribute, Operator, Text
+          push :attr
+        end
       end
 
       state :style do

data/lib/rouge/regex_lexer.rb

@@ -281,6 +281,18 @@ module Rouge
       end
     end
 
+    def inspect_details
+      yield ' stack:['
+      first = true
+      stack.each do |state|
+        yield ',' unless first
+        first = false
+        yield state.name
+      end
+
+      yield ']'
+    end
+
     # @private
     def get_state(state_name)
       self.class.get_state(state_name)

data/lib/rouge/themes/thankful_eyes.rb

@@ -60,7 +60,8 @@ module Rouge
             Literal::Date,
             Literal::String::Symbol, :fg => :pink_merengue, :bold => true
       style Literal::String, :fg => :dune, :bold => true
-      style Literal::String::Affix, :fg => :sandy, :bold => true
+      style Literal::String::Affix,
+            Literal::String::Delimiter, :fg => :sandy, :bold => true
       style Literal::String::Escape,
             Literal::String::Char,
             Literal::String::Interpol, :fg => :backlit, :bold => true

data/lib/rouge/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "5.0.0"
+    "5.1.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Jeanine Adkisson
@@ -39,10 +39,11 @@ files:
 - lib/rouge/demos/abap
 - lib/rouge/demos/actionscript
 - lib/rouge/demos/ada
+- lib/rouge/demos/addmusick
 - lib/rouge/demos/apache
 - lib/rouge/demos/apex
 - lib/rouge/demos/apiblueprint
-- lib/rouge/demos/applescript
+- lib/rouge/demos/apple_script
 - lib/rouge/demos/armasm
 - lib/rouge/demos/augeas
 - lib/rouge/demos/awk
@@ -298,6 +299,7 @@ files:
 - lib/rouge/lexers/abap/builtins.rb
 - lib/rouge/lexers/actionscript.rb
 - lib/rouge/lexers/ada.rb
+- lib/rouge/lexers/addmusick.rb
 - lib/rouge/lexers/apache.rb
 - lib/rouge/lexers/apache/keywords.rb
 - lib/rouge/lexers/apex.rb