rouge 3.20.0 → 3.25.0

data/lib/rouge/lexers/postscript.rb

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# Adapted from pygments PostScriptLexer
+module Rouge
+  module Lexers
+    class PostScript < RegexLexer
+      title "PostScript"
+      desc "The PostScript language (adobe.com/devnet/postscript.html)"
+      tag "postscript"
+      aliases "postscr", "postscript", "ps", "eps"
+      filenames "*.ps", "*.eps"
+      mimetypes "application/postscript"
+
+      def self.detect?(text)
+        return true if /^%!/ =~ text
+      end
+
+      delimiter = %s"()<>\[\]{}/%\s"
+      delimiter_end = Regexp.new("(?=[#{delimiter}])")
+      valid_name_chars = Regexp.new("[^#{delimiter}]")
+      valid_name = /#{valid_name_chars}+#{delimiter_end}/
+
+      # These keywords taken from
+      # <http://www.math.ubc.ca/~cass/graphics/manual/pdf/a1.pdf>
+      # Is there an authoritative list anywhere that doesn't involve
+      # trawling documentation?
+      keywords = %w/abs add aload arc arcn array atan begin
+        bind ceiling charpath clip closepath concat
+        concatmatrix copy cos currentlinewidth currentmatrix
+        currentpoint curveto cvi cvs def defaultmatrix
+        dict dictstackoverflow div dtransform dup end
+        exch exec exit exp fill findfont floor get
+        getinterval grestore gsave identmatrix idiv
+        idtransform index invertmatrix itransform length
+        lineto ln load log loop matrix mod moveto
+        mul neg newpath pathforall pathbbox pop print
+        pstack put quit rand rangecheck rcurveto repeat
+        restore rlineto rmoveto roll rotate round run
+        save scale scalefont setdash setfont setgray
+        setlinecap setlinejoin setlinewidth setmatrix
+        setrgbcolor shfill show showpage sin sqrt
+        stack stringwidth stroke strokepath sub syntaxerror
+        transform translate truncate typecheck undefined
+        undefinedfilename undefinedresult/
+
+      state :root do
+        # All comment types
+        rule %r'^%!.+?$', Comment::Preproc
+        rule %r'%%.*?$', Comment::Special
+        rule %r'(^%.*?$){2,}', Comment::Multiline
+        rule %r'%.*?$', Comment::Single
+
+        # String literals are awkward; enter separate state.
+        rule %r'\(', Str, :stringliteral
+
+        # References
+        rule %r'/#{valid_name}', Name::Variable
+
+        rule %r'[{}<>\[\]]', Punctuation
+
+        rule %r'(?:#{keywords.join('|')})#{delimiter_end}', Name::Builtin
+
+        # Conditionals / flow control
+        rule %r'(eq|ne|g[et]|l[et]|and|or|not|if(?:else)?|for(?:all)?)#{delimiter_end}', Keyword::Reserved
+        rule %r'(false|true)#{delimiter_end}', Keyword::Constant
+
+        # Numbers
+        rule %r'<[0-9A-Fa-f]+>#{delimiter_end}', Num::Hex
+        # Slight abuse: use Oct to signify any explicit base system
+        rule %r'[0-9]+\#(\-|\+)?([0-9]+\.?|[0-9]*\.[0-9]+|[0-9]+\.[0-9]*)((e|E)[0-9]+)?#{delimiter_end}', Num::Oct
+        rule %r'(\-|\+)?([0-9]+\.?|[0-9]*\.[0-9]+|[0-9]+\.[0-9]*)((e|E)[0-9]+)?#{delimiter_end}', Num::Float
+        rule %r'(\-|\+)?[0-9]+#{delimiter_end}', Num::Integer
+
+        # Names
+        rule valid_name, Name::Function      # Anything else is executed
+
+        rule %r'\s+', Text
+      end
+
+      state :stringliteral do
+        rule %r'[^()\\]+', Str
+        rule %r'\\', Str::Escape, :escape
+        rule %r'\(', Str, :stringliteral
+        rule %r'\)', Str, :pop!
+      end
+
+      state :escape do
+        rule %r'[0-8]{3}|n|r|t|b|f|\\|\(|\)', Str::Escape, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/powershell.rb

@@ -131,40 +131,57 @@ module Rouge
         rule %r/[:,]/, Punctuation
       end
 
-      state :hasht do
-        rule %r/\s+/, Text::Whitespace
-        rule %r/\}/, Punctuation, :pop!
+      state :expr do
+        mixin :comments
         rule %r/"/, Str::Double, :dq
         rule %r/'/, Str::Single, :sq
-        rule %r/\w+/, Name::Other
+        rule %r/@"/, Str::Heredoc, :heredoc
+        rule %r/@'.*?'@/m, Str::Heredoc
+        rule %r/\d*\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
+        rule %r/@\{/, Punctuation, :hasht
+        rule %r/@\(/, Punctuation, :array
+        rule %r/{/, Punctuation, :brace
+        rule %r/\[/, Punctuation, :bracket
+      end
+
+      state :hasht do
+        rule %r/\}/, Punctuation, :pop!
         rule %r/=/, Operator
-        rule %r/,/, Punctuation
+        rule %r/[,;]/, Punctuation
+        mixin :expr
+        rule %r/\w+/, Name::Other
         mixin :variable
       end
 
       state :array do
         rule %r/\s+/, Text::Whitespace
         rule %r/\)/, Punctuation, :pop!
-        rule %r/"/, Str::Double, :dq
-        rule %r/'/, Str::Single, :sq
-        rule %r/,/, Punctuation
+        rule %r/[,;]/, Punctuation
+        mixin :expr
         mixin :variable
       end
 
+      state :brace do
+        rule %r/[}]/, Punctuation, :pop!
+        mixin :root
+      end
+
       state :bracket do
         rule %r/\]/, Punctuation, :pop!
-        rule %r/[A-Za-z]\w+\./, Name::Constant
+        rule %r/[A-Za-z]\w+\./, Name
         rule %r/([A-Za-z]\w+)/ do |m|
           if ATTRIBUTES.include? m[0]
             token Name::Builtin::Pseudo
           else
-            token Keyword::Type
+            token Name
           end
         end
         mixin :root
       end
 
       state :parameters do
+        rule %r/`./m, Str::Escape
         rule %r/\s*?\n/, Text::Whitespace, :pop!
         rule %r/[;(){}\]]/, Punctuation, :pop!
         rule %r/[|=]/, Operator, :pop!
@@ -173,20 +190,15 @@ module Rouge
         mixin :root
       end
 
-      state :root do
+      state :comments do
         rule %r/\s+/, Text::Whitespace
-
-        rule %r/#requires\s-version \d(?:\.\d+)?/, Comment::Preproc
         rule %r/#.*/, Comment
         rule %r/<#/, Comment::Multiline, :multiline
+      end
 
-        rule %r/"/, Str::Double, :dq
-        rule %r/'/, Str::Single, :sq
-        rule %r/@"/, Str::Heredoc, :heredoc
-        rule %r/@'.*?'@/m, Str::Heredoc
-
-        rule %r/\d*\.\d+/, Num::Float
-        rule %r/\d+/, Num::Integer
+      state :root do
+        mixin :comments
+        rule %r/#requires\s-version \d(?:\.\d+)?/, Comment::Preproc
 
         rule %r/\.\.(?=\.?\d)/, Operator
         rule %r/(?:#{OPERATORS})\b/i, Operator
@@ -203,27 +215,27 @@ module Rouge
         rule %r/-{1,2}\w+/, Name::Tag
 
         rule %r/(\.)?([-\w]+)(\[)/ do |m|
-          groups Operator, Name::Function, Punctuation
+          groups Operator, Name, Punctuation
           push :bracket
         end
 
-        rule %r/([\/\\~\w][-.:\/\\~\w]*)(\n)?/ do |m|
-          groups Name::Function, Text::Whitespace
+        rule %r/([\/\\~[a-z]][-.:\/\\~\w]*)(\n)?/i do |m|
+          groups Name, Text::Whitespace
           push :parameters
         end
 
-        rule %r/(\.)?([-\w]+)(?:(\()|(\n))?/ do |m|
+        rule %r/(\.)([-\w]+)(?:(\()|(\n))?/ do |m|
           groups Operator, Name::Function, Punctuation, Text::Whitespace
           push :parameters unless m[3].nil?
         end
 
-        rule %r/[-+*\/%=!.&|]/, Operator
-        rule %r/@\{/, Punctuation, :hasht
-        rule %r/@\(/, Punctuation, :array
-        rule %r/\[/, Punctuation, :bracket
-        rule %r/[{}(),:;]/, Punctuation
+        rule %r/\?/, Name::Function, :parameters
 
+        mixin :expr
         mixin :variable
+
+        rule %r/[-+*\/%=!.&|]/, Operator
+        rule %r/[{}(),:;]/, Punctuation
       end
     end
   end

data/lib/rouge/lexers/q.rb

@@ -118,7 +118,7 @@ module Rouge
       end
 
       state :bottom do
-        rule %r/.*\z/m, Comment::Multiline
+        rule %r/.+\z/m, Comment::Multiline
       end
     end
   end

data/lib/rouge/lexers/rego.rb

@@ -9,36 +9,51 @@ module Rouge
             tag 'rego'
             filenames '*.rego'
 
+            def self.constants
+              @constants ||= Set.new %w(
+                true false null
+              )
+            end
+
+            def self.operators
+              @operators ||= Set.new %w(
+                as default else import not package some with
+              )
+            end
+
             state :basic do
               rule %r/\s+/, Text
               rule %r/#.*/, Comment::Single
-      
+
               rule %r/[\[\](){}|.,;!]/, Punctuation
-      
+
               rule %r/"[^"]*"/, Str::Double
-      
+
               rule %r/-?\d+\.\d+([eE][+-]?\d+)?/, Num::Float
               rule %r/-?\d+([eE][+-]?\d+)?/, Num
 
               rule %r/\\u[0-9a-fA-F]{4}/, Num::Hex
               rule %r/\\["\/bfnrt]/, Str::Escape
             end
-      
-            state :atoms do
-              rule %r/(true|false|null)/, Keyword::Constant
-              rule %r/[[:word:]]*/, Str::Symbol
-            end
-      
+
             state :operators do
               rule %r/(=|!=|>=|<=|>|<|\+|-|\*|%|\/|\||&|:=)/, Operator
-              rule %r/(default|not|package|import|as|with|else|some)/, Operator
               rule %r/[\/:?@^~]+/, Operator
             end
-      
+
             state :root do
               mixin :basic
               mixin :operators
-              mixin :atoms
+
+              rule %r/[[:word:]]+/ do |m|
+                if self.class.constants.include? m[0]
+                  token Keyword::Constant
+                elsif self.class.operators.include? m[0]
+                  token Operator::Word
+                else
+                  token Name
+                end
+              end
             end
         end
     end

data/lib/rouge/lexers/ruby.rb

@@ -374,7 +374,7 @@ module Rouge
       end
 
       state :method_call do
-        rule %r(/) do
+        rule %r(/|%) do
           token Operator
           goto :expr_start
         end

data/lib/rouge/lexers/rust.rb

@@ -22,8 +22,8 @@ module Rouge
 
       def self.keywords
         @keywords ||= %w(
-          as assert async await break const copy do drop else enum extern fail false
-          fn for if impl let log loop match mod move mut priv pub pure
+          as assert async await break const continue copy do drop else enum extern
+          fail false fn for if impl let log loop match mod move mut priv pub pure
           ref return self static struct true trait type unsafe use where
           while box
         )
@@ -99,7 +99,9 @@ module Rouge
         rule %r/[*\/!@~&+%^<>=\?-]|\.{2,3}/, Operator
 
         rule %r/([.]\s*)?#{id}(?=\s*[(])/m, Name::Function
+        rule %r/[.]\s*await\b/, Keyword
         rule %r/[.]\s*#{id}/, Name::Property
+        rule %r/[.]\s*\d+/, Name::Attribute
         rule %r/(#{id})(::)/m do
           groups Name::Namespace, Punctuation
         end
@@ -167,7 +169,7 @@ module Rouge
         flt = /f32|f64/
 
         rule %r(
-          [0-9]+
+          [0-9_]+
           (#{dot}  #{exp}? #{flt}?
           |#{dot}? #{exp}  #{flt}?
           |#{dot}? #{exp}? #{flt}

data/lib/rouge/lexers/sass/common.rb

@@ -29,6 +29,7 @@ module Rouge
         end
 
         rule %r/@#{id}/, Keyword, :selector
+        rule %r/&/, Keyword, :selector
 
         # $variable: assignment
         rule %r/([$]#{id})([ \t]*)(:)/ do

data/lib/rouge/lexers/smarty.rb

@@ -41,7 +41,7 @@ module Rouge
         end
 
 
-        rule(/.*?(?={[\/a-zA-Z0-9$#*"'])|.*/m) { delegate parent }
+        rule(/.+?(?={[\/a-zA-Z0-9$#*"'])/m) { delegate parent }
         rule(/.+/m) { delegate parent }
       end
 

data/lib/rouge/lexers/ssh.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class SSH < RegexLexer
+      tag 'ssh'
+
+      title "SSH Config File"
+      desc 'A lexer for SSH configuration files'
+      filenames 'ssh_config'
+
+      state :root do
+        rule %r/[a-z0-9]+/i, Keyword, :statement
+        mixin :base
+      end
+
+      state :statement do
+        rule %r/\n/, Text, :pop!
+        rule %r/(?:yes|no|confirm|ask|always|auto|none|force)\b/, Name::Constant
+
+        rule %r/\d+/, Num
+        rule %r/[^#\s;{}$\\]+/, Text
+        mixin :base
+      end
+
+      state :base do
+        rule %r/\s+/, Text
+        rule %r/#.*/, Comment::Single
+      end
+    end
+  end
+end

data/lib/rouge/lexers/systemd.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class SystemD < RegexLexer
+      tag 'systemd'
+      aliases 'unit-file'
+      filenames '*.service'
+      mimetypes 'text/x-systemd-unit'
+      desc 'A lexer for systemd unit files'
+
+      state :root do
+        rule %r/\s+/, Text
+        rule %r/[;#].*/, Comment
+        rule %r/\[.*?\]$/, Keyword
+        rule %r/(.*?)(=)(.*)(\\\n)/ do
+          groups Name::Tag, Punctuation, Text, Str::Escape
+          push :continuation
+        end
+        rule %r/(.*?)(=)(.*)/ do
+          groups Name::Tag, Punctuation, Text
+        end
+      end
+
+      state :continuation do
+        rule %r/(.*?)(\\\n)/ do
+          groups Text, Str::Escape
+        end
+        rule %r/(.*)'/, Text, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/twig.rb

@@ -17,10 +17,10 @@ module Rouge
 
       def self.keywords
         @@keywords ||= %w(as do extends flush from import include use else starts
-                          ends with without autoescape endautoescape block endblock
-                          embed endembed filter endfilter for endfor if endif
-                          macro endmacro sandbox endsandbox set endset
-                          spaceless endspaceless verbatim endverbatim)
+                          ends with without autoescape endautoescape block
+                          endblock embed endembed filter endfilter for endfor
+                          if endif macro endmacro sandbox endsandbox set endset
+                          spaceless endspaceless)
       end
 
       def self.tests

data/lib/rouge/lexers/velocity.rb

@@ -63,7 +63,7 @@ module Rouge
         rule %r/0[xX][0-9a-fA-F]+[Ll]?/, Num::Hex
         rule %r/\b[0-9]+\b/, Num::Integer
         rule %r/(true|false|null)\b/, Keyword::Constant
-        rule %r/[(\[]/, Punctuation, :push!
+        rule %r/[(\[]/, Punctuation, :push
         rule %r/[)\]}]/, Punctuation, :pop!
       end
     end