rouge 4.1.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 555fb3207f31723860f17a269418bbaea9dff23c0ae97dc5f27fabd797fc4ad5
-  data.tar.gz: ad0c9a8de4f66de72f487f8310abda1e763c92816ef2de031a7aea89bcd155c0
+  metadata.gz: 37949922e331ce08a0d8270560930eca1a9b5b0f2c7a4beb8a0c70c47e39e9ac
+  data.tar.gz: 2a9bcecc9809c7211f74be3d294cf21408f76539b804733299b4a54f808a5d0a
 SHA512:
-  metadata.gz: fcdb09306c5640839523e4ade20a7a272d835f0cd7eec7d2a3b43ae4598d5f0ef50ce2c64e24de31d98e10501f5a8ea53b0e064b51a0e3166756a0669e76b3e9
-  data.tar.gz: 8c2deba5fc1d897f655642ed01f1817743d249fe1a8dabcc9de873b5203378b63315c5f5fd18c25a479d97aed5e726c9efffb43b1f0c83fbcc6aaf75ce1cf23d
+  metadata.gz: a2f8da79bd3fcf3c5449a2cc4ccd3a2fdaca4c0bbc33748f3d4552061771f458d9b2fc890d72445576240a446672aa09fea559ed5eb7c65f68f700bf8c1999ed
+  data.tar.gz: f0908d8e6ad216c960496da16778ce6c2e5ff4762a4cf8e1de71b4a68c2d113293462a0186bcbee83280da6c1ef5c6fa8ef9456899e14aad8f9a2bafd903e7f0

data/Gemfile

@@ -10,22 +10,22 @@ gem 'minitest', '>= 5.0'
 gem 'minitest-power_assert'
 gem 'power_assert', '~> 2.0'
 
-gem 'rubocop', '~> 1.0', '<= 1.11'
-gem 'rubocop-performance'
-
 # don't try to install redcarpet under jruby
 gem 'redcarpet', platforms: :ruby
 
 # Profiling
 gem 'memory_profiler', require: false
 
-# Needed for a Rake task
-gem 'git'
-gem 'yard'
-
 group :development do
   gem 'pry'
 
+  # Needed for a Rake task
+  gem 'git'
+  gem 'yard'
+
+  gem 'rubocop', '~> 1.0', '<= 1.11'
+  gem 'rubocop-performance'
+
   # docs
   gem 'github-markup'
 

data/lib/rouge/cli.rb

@@ -347,8 +347,7 @@ module Rouge
         formatter.format(lexer.lex(input), &method(:print))
       end
 
-    private_class_method
-      def self.parse_cgi(str)
+    private_class_method def self.parse_cgi(str)
         pairs = CGI.parse(str).map { |k, v| [k.to_sym, v.first] }
         Hash[pairs]
       end
@@ -511,8 +510,7 @@ module Rouge
     end
 
 
-  private_class_method
-    def self.normalize_syntax(argv)
+  private_class_method def self.normalize_syntax(argv)
       out = []
       argv.each do |arg|
         case arg

data/lib/rouge/demos/codeowners

@@ -0,0 +1,6 @@
+# Specify a default Code Owner by using a wildcard:
+* @default-codeowner
+
+/docs/ @all-docs
+
+[Development] @dev-team

data/lib/rouge/demos/svelte

@@ -0,0 +1,29 @@
+<!-- This file is made up from several examples on https://svelte.dev/examples and is not expected to function. -->
+<script lang="ts">
+    import Image from './Image.svelte';
+
+    let src: string = '/tutorial/image.gif';
+    let count: number = 1;
+    $: doubled = count * 2;  // the `$:` is special in svelte
+</script>
+
+<Image {src} bind:alt="{name.capitalize()} dancing" user={name.toUpperCase(false, 42, {key: 'value'})}
+       tooltip="I'm helping" false text=asdf on:message={handleMessage} />
+
+{#await loadSrc(src)}
+    loading...
+{:then data}
+    {#each cats as { name }, i}
+        <li>{name}</li>
+    {/each}
+
+    <!-- Keyed Each Block -->
+    {#each cats as cat (cat.id)}
+        <li>{cat.name}</li>
+    {/each}
+{:catch err}
+    {@debug err}
+    {#await solveErr(err, {x: 'asdf'}) then reason}{@html reason}{/await}
+{/await}
+
+<style>p {font-family: 'Comic Sans MS', cursive;}</style>

data/lib/rouge/guessers/disambiguation.rb

@@ -129,6 +129,7 @@ module Rouge
 
       disambiguate '*.cls' do
         next TeX if matches?(/\A\s*(?:\\|%)/)
+        next OpenEdge if matches?(/(no\-undo|BLOCK\-LEVEL|ROUTINE\-LEVEL|&ANALYZE\-SUSPEND)/i)
         next Apex
       end
 
@@ -139,6 +140,12 @@ module Rouge
 
         Puppet
       end
+      
+      disambiguate '*.p' do
+        next Prolog if contains?(':-')
+        next Prolog if matches?(/\A\w+(\(\w+\,\s*\w+\))*\./)
+        next OpenEdge
+      end
     end
   end
 end

data/lib/rouge/lexers/ada.rb

@@ -155,7 +155,7 @@ module Rouge
         end
 
         # Flag word-like things that don't match the ID pattern.
-        rule %r{\b(\p{Pc}|[[alpha]])\p{Word}*}, Error
+        rule %r{\b(\p{Pc}|[[:alpha:]])\p{Word}*}, Error
       end
     end
   end

data/lib/rouge/lexers/bpf.rb

@@ -9,11 +9,11 @@ module Rouge
       tag 'bpf'
 
       TYPE_KEYWORDS = %w(
-        u8 u16 u32 u64 ll
+        u8 u16 u32 u64 s8 s16 s32 s64 ll
       ).join('|')
 
       MISC_KEYWORDS = %w(
-        be16 be32 be64 exit lock map
+        be16 be32 be64 le16 le32 le64 bswap16 bswap32 bswap64 exit lock map
       ).join('|')
 
       state :root do
@@ -32,21 +32,21 @@ module Rouge
         rule %r/(call)(\s+)(\d+)/i do
           groups Keyword, Text::Whitespace, Literal::Number::Integer
         end
-        rule %r/(call)(\s+)(\w+)(#)(\d+)/i do
+        rule %r/(call)(\s+)(\w+)(?:(#)(\d+))?/i do
           groups Keyword, Text::Whitespace, Name::Builtin, Punctuation, Literal::Number::Integer
         end
 
         # Unconditional jumps
-        rule %r/(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
-          groups Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
+        rule %r/(gotol?)(\s*)([-+]0x\w+)?([-+]\d+)?(\s*)(<?\w+>?)/i do
+          groups Keyword, Text::Whitespace, Literal::Number::Hex, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
 
         # Conditional jumps
-        rule %r/(if)(\s+)([rw]\d+)(\s*)([s!=<>]+)(\s*)(0x\h+|[-]?\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
-          groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
+        rule %r/(if)(\s+)([rw]\d+)(\s*)([s!=<>]+)(\s*)(0x\h+|[-]?\d+)(\s*)(gotol?)(\s*)([-+]0x\w+)?([-+]\d+)?(\s*)(<?\w+>?)/i do
+          groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Hex, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
-        rule %r/(if)(\s+)([rw]\d+)(\s*)([s!=<>]+)(\s*)([rw]\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
-          groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Name, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
+        rule %r/(if)(\s+)([rw]\d+)(\s*)([s!=<>]+)(\s*)([rw]\d+)(\s*)(gotol?)(\s*)([-+]0x\w+)?([-+]\d+)?(\s*)(<?\w+>?)/i do
+          groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Name, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Hex, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
 
         # Dereferences
@@ -70,7 +70,7 @@ module Rouge
         rule %r/#{MISC_KEYWORDS}/i, Keyword
 
         # Literals and global objects (maps) refered by name
-        rule %r/(0x\h+|[-]?\d+)(\s*)(ll)?/i do
+        rule %r/([-]?0x\h+|[-]?\d+)(\s*)(ll)?/i do
           groups Literal::Number, Text::Whitespace, Keyword::Type
         end
         rule %r/(\w+)(\s*)(ll)/i do

data/lib/rouge/lexers/clean.rb

@@ -79,7 +79,7 @@ module Rouge
 
         rule %r/code(\s+inline)?\s*{/, Comment::Preproc, :abc
 
-        rule %r/_*[a-z][\w_`]*/ do |m|
+        rule %r/_*[a-z][\w`]*/ do |m|
           if self.class.keywords.include?(m[0])
             token Keyword
           else
@@ -87,7 +87,7 @@ module Rouge
           end
         end
 
-        rule %r/_*[A-Z][\w_`]*/ do |m|
+        rule %r/_*[A-Z][\w`]*/ do |m|
           if m[0]=='True' || m[0]=='False'
             token Keyword::Constant
           else
@@ -95,7 +95,7 @@ module Rouge
           end
         end
 
-        rule %r/[^\w_\s`]/, Punctuation
+        rule %r/[^\w\s`]/, Punctuation
         rule %r/_\b/, Punctuation
       end
 
@@ -136,7 +136,7 @@ module Rouge
 
         rule %r/}/, Comment::Preproc, :pop!
         rule %r/\.\w*/, Keyword, :abc_rest_of_line
-        rule %r/[\w_]+/, Name::Builtin, :abc_rest_of_line
+        rule %r/[\w]+/, Name::Builtin, :abc_rest_of_line
       end
 
       state :abc_rest_of_line do

data/lib/rouge/lexers/codeowners.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Codeowners < RegexLexer
+      title 'CODEOWNERS'
+      desc 'Code Owners syntax (https://docs.gitlab.com/ee/user/project/codeowners/reference.html)'
+      tag 'codeowners'
+      filenames 'CODEOWNERS'
+
+      state :root do
+        rule %r/[ \t\r\n]+/, Text::Whitespace
+        rule %r/^\s*#.*$/, Comment::Single
+
+        rule %r(
+          (\^?\[(?!\d+\])[^\]]+\])
+          (\[\d+\])?
+        )x do
+          groups Name::Namespace, Literal::Number
+        end
+
+        rule %r/\S*@\S+/, Name::Function
+
+        rule %r/[\p{Word}\.\/\-\*]+/, Name
+        rule %r/.*\\[\#\s]/, Name
+      end
+    end
+  end
+end

data/lib/rouge/lexers/cpp.rb

@@ -27,7 +27,7 @@ module Rouge
           delete dynamic_cast explicit export friend
           mutable namespace new operator private protected public
           reinterpret_cast requires restrict size_of static_cast this throw throws
-          typeid typename using virtual final override
+          typeid typename using virtual final override import module
 
           alignas alignof decltype noexcept static_assert
           thread_local try

data/lib/rouge/lexers/dart.rb

@@ -12,16 +12,16 @@ module Rouge
       mimetypes 'text/x-dart'
 
       keywords = %w(
-        as assert await break case catch continue default do else finally for
-        if in is new rethrow return super switch this throw try while with yield
+        as assert await break case catch continue default do else finally for if
+        in is new rethrow return super switch this throw try while when with yield
       )
 
       declarations = %w(
-        abstract async dynamic const covariant external extends factory final get
-        implements late native on operator required set static sync typedef var
+        abstract base async dynamic const covariant external extends factory final get implements
+        interface late native on operator required sealed set static sync typedef var
       )
 
-      types = %w(bool Comparable double Dynamic enum Function int List Map Never Null num Object Pattern Set String Symbol Type Uri void)
+      types = %w(bool Comparable double Dynamic enum Function int List Map Never Null num Object Pattern Record Set String Symbol Type Uri void)
 
       imports = %w(import deferred export library part\s*of part source)
 
@@ -53,7 +53,7 @@ module Rouge
         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|mixin)\b/, Keyword::Declaration, :class
+        rule %r/(?:class|mixin)\b/, Keyword::Declaration, :class
         rule %r/(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
         rule %r/(\.)(#{id})/ do
           groups Operator, Name::Attribute

data/lib/rouge/lexers/dot.rb

@@ -8,6 +8,7 @@ module Rouge
       desc "graph description language"
 
       tag 'dot'
+      aliases 'graphviz'
       filenames '*.dot'
       mimetypes 'text/vnd.graphviz'
 

data/lib/rouge/lexers/ecl.rb

@@ -114,8 +114,8 @@ module Rouge
         mixin :single_quote
 
         rule %r(\b(?i:(and|not|or|in))\b), Operator::Word
-        rule %r([:=|>|<|<>|/|\\|\+|-|=]), Operator
-        rule %r([\[\]{}();,\&,\.,\%]), Punctuation
+        rule %r(:=|>|<|<>|/|\\|\+|-|=), Operator
+        rule %r([\[\]{}();,\&\.\%]), Punctuation
 
         rule %r(\b(?i:(beginc\+\+.*?endc\+\+)))m, Str::Single
         rule %r(\b(?i:(embed.*?endembed)))m, Str::Single

data/lib/rouge/lexers/elixir.rb

@@ -14,6 +14,10 @@ module Rouge
 
       filenames '*.ex', '*.exs'
 
+      def self.detect?(text)
+        return true if text.shebang?('elixir')
+      end
+
       mimetypes 'text/x-elixir', 'application/x-elixir'
 
       state :root do
@@ -131,7 +135,7 @@ module Rouge
               rule %r/[\\#]/, toktype
             end
 
-            uniq_chars = "#{open}#{close}".squeeze
+            uniq_chars = [open, close].uniq.join
             rule %r/[^##{uniq_chars}\\]+/m, toktype
           end
         end

data/lib/rouge/lexers/gdscript.rb

@@ -12,7 +12,7 @@ module Rouge
       mimetypes 'text/x-gdscript', 'application/x-gdscript'
 
       def self.keywords
-        @keywords = %w(
+        @keywords ||= %w(
           and in not or as breakpoint class class_name extends is func setget
           signal tool const enum export onready static var break continue
           if elif else for pass return match while remote master puppet
@@ -22,13 +22,13 @@ module Rouge
 
       # Reserved for future implementation
       def self.keywords_reserved
-        @keywords_reserved = %w(
+        @keywords_reserved ||= %w(
           do switch case
         ).join('|')
       end
 
       def self.builtins
-        builtins = %w(
+        @builtins ||= %w(
           Color8 ColorN abs acos asin assert atan atan2 bytes2var ceil char
           clamp convert cos cosh db2linear decimals dectime deg2rad dict2inst
           ease exp floor fmod fposmod funcref hash inst2dict instance_from_id
@@ -41,7 +41,7 @@ module Rouge
       end
 
       def self.builtins_type
-        @builtins_type = %w(
+        @builtins_type ||= %w(
           bool int float String Vector2 Rect2 Transform2D Vector3 AABB
           Plane Quat Basis Transform Color RID Object NodePath Dictionary
           Array PoolByteArray PoolIntArray PoolRealArray PoolStringArray

data/lib/rouge/lexers/ghc_cmm.rb

@@ -22,11 +22,11 @@ module Rouge
       ws = %r(\s|//.*?\n|/[*](?:[^*]|(?:[*][^/]))*[*]+/)mx
 
       # Make sure that this is not a preprocessor macro, e.g. `#if` or `#define`.
-      id = %r((?!\#[a-zA-Z])[\w#\$%_']+)
+      id = %r((?!\#[a-zA-Z])[\w#\$%']+)
 
       complex_id = %r(
-        (?:[\w#$%_']|\(\)|\(,\)|\[\]|[0-9])*
-        (?:[\w#$%_']+)
+        (?:[\w#$%']|\(\)|\(,\)|\[\]|[0-9])*
+        (?:[\w#$%']+)
       )mx
 
       state :root do

data/lib/rouge/lexers/groovy.rb

@@ -23,7 +23,7 @@ module Rouge
 
       def self.declarations
         @declarations ||= Set.new %w(
-          abstract const enum extends final implements native private
+          abstract const extends final implements native private
           protected public static strictfp super synchronized throws
           transient volatile
         )
@@ -31,7 +31,7 @@ module Rouge
 
       def self.types
         @types ||= Set.new %w(
-          def boolean byte char double float int long short void
+          def var boolean byte char double float int long short void
         )
       end
 
@@ -56,7 +56,7 @@ module Rouge
         rule %r(//.*?$), Comment::Single
         rule %r(/[*].*?[*]/)m, Comment::Multiline
         rule %r/@\w[\w.]*/, Name::Decorator
-        rule %r/(class|interface|trait)\b/,  Keyword::Declaration, :class
+        rule %r/(class|interface|trait|enum|record)\b/,  Keyword::Declaration, :class
         rule %r/package\b/, Keyword::Namespace, :import
         rule %r/import\b/, Keyword::Namespace, :import
 

data/lib/rouge/lexers/hcl.rb

@@ -56,7 +56,7 @@ module Rouge
         @builtins ||= %w()
       end
 
-      id = /[$a-z_][a-z0-9_]*/io
+      id = /[$a-z_\-][a-z0-9_\-]*/io
 
       state :root do
         mixin :comments_and_whitespace
@@ -114,6 +114,7 @@ module Rouge
       state :hash do
         mixin :comments_and_whitespace
 
+        rule %r/[.,()\\\/*]/, Punctuation
         rule %r/\=/, Punctuation
         rule %r/\}/, Punctuation, :pop!
 
@@ -123,7 +124,7 @@ module Rouge
       state :array do
         mixin :comments_and_whitespace
 
-        rule %r/,/, Punctuation
+        rule %r/[.,()\\\/*]/, Punctuation
         rule %r/\]/, Punctuation, :pop!
 
         mixin :root

data/lib/rouge/lexers/irb.rb

@@ -23,7 +23,13 @@ module Rouge
       end
 
       def prompt_regex
-        /^.*?(irb|pry).*?[>"*]/
+        %r(
+          ^.*?
+          (
+            (irb|pry).*?[>"*] |
+            [>"*]>
+          )
+        )x
       end
 
       def allow_comments?

data/lib/rouge/lexers/javascript.rb

@@ -190,7 +190,14 @@ module Rouge
 
         rule %r/function(?=(\(.*\)))/, Keyword::Declaration # For anonymous functions
 
-        rule %r/(#{id})[ \t]*(?=(\(.*\)))/m, Name::Function
+        rule %r/(#{id})[ \t]*(?=(\(.*\)))/m do |m|
+          if self.class.keywords.include? m[1]
+            # "if" in "if (...)" or "switch" in "switch (...)" are recognized as keywords.
+            token Keyword
+          else
+            token Name::Function
+          end
+        end
 
         rule %r/[{}]/, Punctuation, :statement
 

data/lib/rouge/lexers/jinja.rb

@@ -14,25 +14,25 @@ module Rouge
                 'text/html+django', 'text/html+jinja'
 
       def self.keywords
-        @@keywords ||= %w(as context do else extends from ignore missing
-                          import include reversed recursive scoped
-                          autoescape endautoescape block endblock call endcall
-                          filter endfilter for endfor if endif macro endmacro
-                          set endset trans endtrans with endwith without)
+        @keywords ||= %w(as context do else extends from ignore missing
+                         import include reversed recursive scoped
+                         autoescape endautoescape block endblock call endcall
+                         filter endfilter for endfor if endif macro endmacro
+                         set endset trans endtrans with endwith without)
       end
 
       def self.tests
-        @@tests ||= %w(callable defined divisibleby equalto escaped even iterable
-                       lower mapping none number odd sameas sequence string
-                       undefined upper)
+        @tests ||= %w(callable defined divisibleby equalto escaped even iterable
+                      lower mapping none number odd sameas sequence string
+                      undefined upper)
       end
 
       def self.pseudo_keywords
-        @@pseudo_keywords ||= %w(true false none True False None)
+        @pseudo_keywords ||= %w(true false none True False None)
       end
 
       def self.word_operators
-        @@word_operators ||= %w(is in and or not)
+        @word_operators ||= %w(is in and or not)
       end
 
       state :root do

data/lib/rouge/lexers/julia.rb

@@ -252,15 +252,16 @@ module Rouge
         rule %r/\d+/, Literal::Number::Integer
       end
 
+      NAME_RE = %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/
 
       state :funcname do
-        rule %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/, Name::Function, :pop!
+        rule NAME_RE, Name::Function, :pop!
         rule %r/\([^\s\w{]{1,2}\)/, Operator, :pop!
         rule %r/[^\s\w{]{1,2}/, Operator, :pop!
       end
 
       state :typename do
-        rule %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/, Name::Class, :pop!
+        rule NAME_RE, Name::Class, :pop!
       end
 
       state :stringescape do

data/lib/rouge/lexers/kotlin.rb

@@ -24,7 +24,7 @@ module Rouge
         while yield
       )
 
-      name_chars = %r'[-_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
+      name_chars = %r'[-\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
 
       class_name = %r'`?[\p{Lu}]#{name_chars}`?'
       name = %r'`?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}]#{name_chars}`?'