rouge 3.9.0 → 3.13.0

data/lib/rouge/lexers/common_lisp.rb

@@ -7,7 +7,7 @@ module Rouge
       title "Common Lisp"
       desc "The Common Lisp variant of Lisp (common-lisp.net)"
       tag 'common_lisp'
-      aliases 'cl', 'common-lisp', 'elisp', 'emacs-lisp'
+      aliases 'cl', 'common-lisp', 'elisp', 'emacs-lisp', 'lisp'
 
       filenames '*.cl', '*.lisp', '*.asd', '*.el' # used for Elisp too
       mimetypes 'text/x-common-lisp'

data/lib/rouge/lexers/coq.rb

@@ -58,7 +58,7 @@ module Rouge
 
       def self.keyopts
         @keyopts ||= Set.new %w(
-          := => -> /\\ \\/ _ ; :> :
+          := => -> /\\ \\/ _ ; :> : ⇒ → ↔ ⇔ ≔ ≡ ∀ ∃ ∧ ∨ ¬ ⊤ ⊥ ⊢ ⊨ ∈
         )
       end
 
@@ -115,14 +115,6 @@ module Rouge
         end
         rule %r(/\\), Operator
         rule %r/\\\//, Operator
-        rule operator do |m|
-          match = m[0]
-          if self.class.keyopts.include? match
-            token Punctuation
-          else
-            token Operator
-          end
-        end
 
         rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
         rule %r/\d[\d_]*/, Num::Integer
@@ -131,6 +123,17 @@ module Rouge
         rule %r/'/, Keyword
         rule %r/"/, Str::Double, :string
         rule %r/[~?]#{id}/, Name::Variable
+
+        rule %r/./ do |m|
+          match = m[0]
+          if self.class.keyopts.include? match
+            token Punctuation
+          elsif match =~ operator
+            token Operator
+          else
+            token Error
+          end
+        end
       end
 
       state :comment do

data/lib/rouge/lexers/csvs.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class CSVS < RegexLexer
+      tag 'csvs'
+      title "csvs"
+      desc 'The CSV Schema Language (digital-preservation.github.io)'
+      filenames '*.csvs'
+
+      state :root do
+        rule %r/\s+/m, Text
+
+        rule %r(//[\S\t ]*), Comment::Single
+        rule %r(/\*[^*]*\*/)m, Comment::Multiline
+
+        rule %r/(version)( )(\d+\.\d+)/ do
+          groups Keyword, Text::Whitespace, Num::Float
+        end
+
+        rule %r/T?\d{2}:\d{2}:\d{2}(\.\d{5})?(Z|(?:[-+]\d{2}:\d{2}))?/, Literal::Date
+        rule %r/\d{4}-\d{2}-\d{2}/, Literal::Date
+        rule %r/\d{2}\/\d{2}\/\d{4}/, Literal::Date
+
+        rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, Num::Float
+        rule %r/\d+/, Num::Integer
+
+        rule %r/@\w+/, Keyword::Pseudo
+
+        rule %r/[-.\w]+:/, Name::Variable
+        rule %r/^"[^"]+"/, Name::Variable
+        rule %r/\$([-.\w]+|("[^"]+"))\/?/, Name::Variable
+
+        rule %r/[A-Z]+/i, Keyword
+
+        rule %r/"[^"]*"/, Str::Double
+        rule %r/'[^\r\n\f']'/, Str::Char
+
+        rule %r/[,()*]/, Punctuation
+      end
+    end
+  end
+end

data/lib/rouge/lexers/eex.rb

@@ -7,8 +7,9 @@ module Rouge
       desc "Embedded Elixir"
 
       tag 'eex'
+      aliases 'leex'
 
-      filenames '*.eex'
+      filenames '*.eex', '*.leex'
 
       def initialize(opts={})
         @elixir_lexer = Elixir.new(opts)

data/lib/rouge/lexers/http.rb

@@ -42,7 +42,7 @@ module Rouge
         rule %r(
           (HTTPS?)(/)(\d(?:\.\d))([ ]+)  # http version
           (\d{3})([ ]+)?                 # status
-          ([^\r\n]+)?(\r?\n|$)           # status message
+          ([^\r\n]*)?(\r?\n|$)           # status message
         )x do
           groups(
             Keyword, Operator, Num, Text,

data/lib/rouge/lexers/jsl.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class JSL < RegexLexer
+      title "JSL"
+      desc "The JMP Scripting Language (JSL) (jmp.com)"
+
+      tag 'jsl'
+      filenames '*.jsl'
+
+      state :root do
+        rule %r/\s+/m, Text::Whitespace
+
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        # messages
+        rule %r/(<<)(.*?)(\(|;)/ do |m|
+          groups Operator, Name::Function, Punctuation
+        end
+
+        # covers built-in and custom functions
+        rule %r/([a-z_][\w\s'%.\\]*)(\()/i do |m|
+          groups Keyword, Punctuation
+        end
+
+        rule %r/\b[+-]?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+|\.)(?:e[+-]?[0-9]+)?i?\b/i, Num
+
+        rule %r/\d{2}(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d{2}(\d{2})?(:\d{2}:\d{2}(:\d{2}(\.\d*)?)?)?/i, Literal::Date
+
+        rule %r/::[a-z_][\w\s'%.\\]*/i, Name::Variable
+        rule %r/:\w+/, Name
+        rule %r/[a-z_][\w\s'%.\\]*/i, Name::Variable
+        rule %r/"(?:\\!"|[^"])*?"n/m, Name::Variable
+
+        rule %r/(")(\\\[)(.*?)(\]\\)(")/m do
+          groups Str::Double, Str::Escape, Str::Double, Str::Escape, Str::Double  # escaped string
+        end
+        rule %r/"/, Str::Double, :dq
+
+        rule %r/[-+*\/!%&<>\|=:]/, Operator
+        rule %r/[\[\](){},;]/, Punctuation
+      end
+
+      state :dq do
+        rule %r/\\![btrnNf0\\"]/, Str::Escape
+        rule %r/\\/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^\\"]*/m, Str::Double
+      end
+    end
+  end
+end

data/lib/rouge/lexers/json.rb

@@ -34,7 +34,7 @@ module Rouge
       end
 
       state :name do
-        rule %r/("(?:\\.|[^"\n])*?")(\s*)(:)/ do
+        rule %r/("(?:\\.|[^"\\\n])*?")(\s*)(:)/ do
           groups Name::Label, Text::Whitespace, Punctuation
         end
       end

data/lib/rouge/lexers/kotlin.rb

@@ -24,19 +24,12 @@ module Rouge
         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}]*'
-      name_backtick = %r'#{name}|`#{name}`'
+      name_chars = %r'[-_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
 
-      id = %r'(#{name_backtick})'
+      class_name = %r'`?[\p{Lu}]#{name_chars}`?'
+      name = %r'`?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}]#{name_chars}`?'
 
       state :root do
-        rule %r'(\))(\s*)(:)(\s+)(#{name_backtick})(<)' do
-          groups Punctuation, Text, Punctuation, Text, Name::Class, Punctuation
-          push :generic_parameters
-        end
-        rule %r'(\))(\s*)(:)(\s+)(#{name_backtick})' do
-          groups Punctuation, Text, Punctuation, Text, Name::Class
-        end
         rule %r'\b(companion)(\s+)(object)\b' do
           groups Keyword, Text, Keyword
         end
@@ -48,13 +41,6 @@ module Rouge
           groups Keyword, Text
           push :function
         end
-        rule %r'(#{name_backtick})(:)(\s+)(#{name_backtick})(<)' do
-          groups Name::Variable, Punctuation, Text, Name::Class, Punctuation
-          push :generic_parameters
-        end
-        rule %r'(#{name_backtick})(:)(\s+)(#{name_backtick})' do
-          groups Name::Variable, Punctuation, Text, Name::Class
-        end
         rule %r'\b(package|import)(\s+)' do
           groups Keyword, Text
           push :package
@@ -67,8 +53,8 @@ module Rouge
           groups Keyword::Declaration, Text
           push :property
         end
-        rule %r/\bfun\b/, Keyword
-        rule %r/\b(?:#{keywords.join('|')})\b/, Keyword
+        rule %r'\bfun\b', Keyword
+        rule %r'\b(?:#{keywords.join('|')})\b', Keyword
         rule %r'^\s*\[.*?\]', Name::Attribute
         rule %r'[^\S\n]+', Text
         rule %r'\\\n', Text # line continuation
@@ -85,43 +71,50 @@ module Rouge
         rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
         rule %r"'\\.'|'[^\\]'", Str::Char
         rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
-        rule %r/@#{id}/, Name::Decorator
-        rule id, Name
+        rule %r'(@#{class_name})', Name::Decorator
+        rule %r'(#{class_name})(<)' do
+          groups Name::Class, Punctuation
+          push :generic_parameters
+        end
+        rule class_name, Name::Class
+        rule %r'(#{name})(?=\s*[({])', Name::Function
+        rule name, Name
       end
 
       state :package do
-        rule %r/\S+/, Name::Namespace, :pop!
+        rule %r'\S+', Name::Namespace, :pop!
       end
 
       state :class do
-        rule id, Name::Class, :pop!
+        rule class_name, Name::Class, :pop!
       end
 
       state :function do
         rule %r'(<)', Punctuation, :generic_parameters
         rule %r'(\s+)', Text
-        rule %r'(#{name_backtick})(\.)' do
+        rule %r'(#{class_name})(\.)' do
           groups Name::Class, Punctuation
         end
-        rule id, Name::Function, :pop!
+        rule name, Name::Function, :pop!
       end
 
       state :generic_parameters do
-        rule id, Name::Class
+        rule class_name, Name::Class
+        rule %r'(<)', Punctuation, :generic_parameters
         rule %r'(,)', Punctuation
         rule %r'(\s+)', Text
         rule %r'(>)', Punctuation, :pop!
       end
 
       state :property do
-        rule id, Name::Property, :pop!
+        rule name, Name::Property, :pop!
       end
 
       state :destructure do
         rule %r'(,)', Punctuation
         rule %r'(\))', Punctuation, :pop!
         rule %r'(\s+)', Text
-        rule id, Name::Property
+        rule name, Name::Property
       end
 
       state :comment do

data/lib/rouge/lexers/liquid.rb

@@ -12,12 +12,12 @@ module Rouge
       state :root do
         rule %r/[^\{]+/, Text
 
-        rule %r/(\{%)(\s*)/ do
+        rule %r/(\{%-?)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :tag_or_block
         end
 
-        rule %r/(\{\{)(\s*)/ do
+        rule %r/(\{\{-?)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :output
         end
@@ -27,78 +27,70 @@ module Rouge
 
       state :tag_or_block do
         # builtin logic blocks
-        rule %r/(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
+        rule %r/(if|elsif|unless|case)\b/, Keyword::Reserved, :condition
+        rule %r/(when)\b/, Keyword::Reserved, :when
 
-        rule %r/(when)(\s+)/ do
-          groups Keyword::Reserved, Text::Whitespace
-          push :when
-        end
-
-        rule %r/(else)(\s*)(%\})/ do
+        rule %r/(else)(\s*)(-?%\})/ do
           groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
         # other builtin blocks
-        rule %r/(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
-          groups Name::Tag, Text::Whitespace, Name::Attribute, Text::Whitespace, Punctuation
+        rule %r/(capture|(?:in|de)crement)(\s+)([^\s%]+)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule %r/(comment)(\s*)(%\})/ do
+        rule %r/(comment)(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :comment
         end
 
-        rule %r/(raw)(\s*)(%\})/ do
+        rule %r/(raw)(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :raw
         end
 
-        rule %r/assign/, Name::Tag, :assign
-        rule %r/include/, Name::Tag, :include
-
         # end of block
-        rule %r/(end(?:case|unless|if))(\s*)(%\})/ do
+        rule %r/(end(?:if|unless|case))(\s*)(-?%\})/ do
           groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule %r/(end(?:[^\s%]+))(\s*)(%\})/ do
+        rule %r/(end(?:[^\s%]+))(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           pop!
         end
 
         # builtin tags
-        rule %r/(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
-          token Name::Tag, m[1]
-          token Text::Whitespace, m[2]
+        rule %r/(assign|echo)\b/, Name::Tag, :assign
+        rule %r/(include|render)\b/, Name::Tag, :include
 
-          if m[4] =~ /'[^']*'/
-            token Str::Single, m[4]
-          elsif m[4] =~ /"[^"]*"/
-            token Str::Double, m[4]
-          else
-            token Name::Attribute, m[4]
-          end
+        rule %r/(cycle)(\s+)(?:([^\s:]*)(\s*)(:))?(\s*)/ do |m|
+          token_class = case m[3]
+                        when %r/'[^']*'/ then Str::Single
+                        when %r/"[^"]*"/ then Str::Double
+                        else
+                          Name::Attribute
+                        end
 
-          token Punctuation, m[5]
-          token Text::Whitespace, m[6]
+          groups Name::Tag, Text::Whitespace, token_class,
+                 Text::Whitespace, Punctuation, Text::Whitespace
 
           push :variable_tag_markup
         end
 
         # iteration
         rule %r/
-          (for)(\s+)
+          (for|tablerow)(\s+)
           ([\w-]+)(\s+)
           (in)(\s+)
           (
-            (?: [^\s,\|'"] | (?:"[^"]*"|'[^']*') )+
+            (?: [^\s%,\|'"] | (?:"[^"]*"|'[^']*') )+
           )(\s*)
         /x do |m|
           groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
-                 Keyword::Reserved, Text::Whitespace
+                 Name::Tag, Text::Whitespace
 
           token_class = case m[7]
                         when %r/'[^']*'/ then Str::Single
@@ -119,105 +111,76 @@ module Rouge
       end
 
       state :output do
-        mixin :whitespace
-        mixin :generic
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
+        end
 
-        rule %r/\}\}/, Punctuation, :pop!
-        rule %r/\|/, Punctuation, :filters
+        mixin :end_of_tag
+        mixin :generic
       end
 
       state :filters do
-        mixin :whitespace
-
-        rule(/\}\}/) { token Punctuation; reset_stack }
-
-        rule %r/([^\s\|:]+)(:?)(\s*)/ do
-          groups Name::Function, Punctuation, Text::Whitespace
-          push :filter_markup
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
         end
-      end
-
-      state :filter_markup do
-        rule %r/\|/, Punctuation, :pop!
 
         mixin :end_of_tag
         mixin :end_of_block
-        mixin :default_param_markup
+        mixin :variable_param_markup
       end
 
       state :condition do
-        mixin :end_of_block
-        mixin :whitespace
-
-        rule %r/([=!><]=?)/, Operator
-
-        rule %r/\b(?:(!)|(not\b))/ do
-          groups Operator, Operator::Word
-        end
-
-        rule %r/(contains)/, Operator::Word
+        rule %r/([=!]=|[<>]=?)/, Operator
+        rule %r/(and|or|contains)\b/, Operator::Word
 
+        mixin :end_of_block
         mixin :generic
-        mixin :whitespace
       end
 
       state :when do
         mixin :end_of_block
-        mixin :whitespace
         mixin :generic
       end
 
-      state :operator do
-        rule %r/(\s*)((?:=|!|>|<)=?)(\s*)/ do
-          groups Text::Whitespace, Operator, Text::Whitespace
-          pop!
-        end
-
-        rule %r/(\s*)(\bcontains\b)(\s*)/ do
-          groups Text::Whitespace, Operator::Word, Text::Whitespace
-          pop!
-        end
-      end
-
       state :end_of_tag do
-        rule(/\}\}/) { token Punctuation; reset_stack }
+        rule(/-?\}\}/) { token Punctuation; reset_stack }
       end
 
       state :end_of_block do
-        rule(/%\}/) { token Punctuation; reset_stack }
+        rule(/-?%\}/) { token Punctuation; reset_stack }
       end
 
       # states for unknown markup
       state :param_markup do
         mixin :whitespace
+        mixin :keyword
         mixin :string
+        mixin :number
 
         rule %r/([^\s=:]+)(\s*)(=|:)/ do
           groups Name::Attribute, Text::Whitespace, Operator
         end
 
-        rule %r/(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
-          groups Punctuation, Text::Whitespace, Text, Text::Whitespace, Punctuation
-        end
-
-        mixin :number
-        mixin :keyword
-
-        rule %r/,/, Punctuation
+        rule %r/[,:]/, Punctuation
       end
 
       state :default_param_markup do
         mixin :param_markup
-        rule %r/./, Text
+
+        rule %r/\S+/, Text
       end
 
       state :variable_param_markup do
         mixin :param_markup
         mixin :variable
-        rule %r/./, Text
+
+        rule %r/\S+/, Text
       end
 
       state :tag_markup do
+        rule %r/(reversed)\b/, Name::Attribute
+
         mixin :end_of_block
         mixin :default_param_markup
       end
@@ -229,12 +192,14 @@ module Rouge
 
       # states for different values types
       state :keyword do
-        rule %r/\b(false|true)\b/, Keyword::Constant
+        rule %r/(false|true|nil)\b/, Keyword::Constant
       end
 
       state :variable do
-        rule %r/\.(?=\w)/, Punctuation
-        rule %r/[a-zA-Z_]\w*\??/, Name::Variable
+        rule %r/(empty|blank|forloop\.[^\s%}\|:]+)\b/, Name::Builtin
+        rule %r/\.(?=\w)|\[|\]/, Punctuation
+        rule %r/(first|last|size)\b/, Name::Function
+        rule %r/[a-zA-Z_][\w-]*\??/, Name::Variable
       end
 
       state :string do
@@ -243,21 +208,17 @@ module Rouge
       end
 
       state :number do
+        rule %r/-/, Operator
         rule %r/\d+\.\d+/, Num::Float
         rule %r/\d+/, Num::Integer
       end
 
-      state :array_index do
-        rule %r/\[/, Punctuation
-        rule %r/\]/, Punctuation
-      end
-
       state :generic do
-        mixin :array_index
+        mixin :whitespace
         mixin :keyword
         mixin :string
-        mixin :variable
         mixin :number
+        mixin :variable
       end
 
       state :whitespace do
@@ -265,18 +226,20 @@ module Rouge
       end
 
       state :comment do
-        rule %r/(\{%)(\s*)(endcomment)(\s*)(%\})/ do
+        rule %r/[^\{]+/, Comment
+
+        rule %r/(\{%-?)(\s*)(endcomment)(\s*)(-?%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule %r/./, Comment
+        rule %r/\{/, Comment
       end
 
       state :raw do
         rule %r/[^\{]+/, Text
 
-        rule %r/(\{%)(\s*)(endraw)(\s*)(%\})/ do
+        rule %r/(\{%-?)(\s*)(endraw)(\s*)(-?%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
@@ -285,27 +248,38 @@ module Rouge
       end
 
       state :assign do
-        mixin :whitespace
-        mixin :end_of_block
+        rule %r/=/, Operator
 
-        rule %r/(\s*)(=)(\s*)/ do
-          groups Text::Whitespace, Operator, Text::Whitespace
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
         end
 
-        rule %r/\|/, Punctuation, :filters
-
+        mixin :end_of_block
         mixin :generic
       end
 
       state :include do
-        mixin :whitespace
-
-        rule %r/([^\.]+)(\.)(html|liquid)/ do
-          groups Name::Attribute, Punctuation, Name::Attribute
+        rule %r/(\{\{-?)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :output_embed
         end
 
+        rule %r/(with|for)\b/, Name::Tag
+        rule %r/[^\s\.]+(\.[^\s\.]+)+\b/, Name::Other
+
         mixin :variable_tag_markup
       end
+
+      state :output_embed do
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/-?\}\}/, Punctuation, :pop!
+
+        mixin :variable_param_markup
+      end
     end
   end
 end