rouge 3.18.0

data/lib/rouge/lexers/turtle.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Turtle < RegexLexer
+      title "Turtle/TriG"
+      desc "Terse RDF Triple Language, TriG"
+      tag 'turtle'
+      filenames '*.ttl', '*.trig'
+      mimetypes 'text/turtle', 'application/trig'
+
+      state :root do
+        rule %r/@base\b/, Keyword::Declaration
+        rule %r/@prefix\b/, Keyword::Declaration
+        rule %r/true\b/, Keyword::Constant
+        rule %r/false\b/, Keyword::Constant
+
+        rule %r/""".*?"""/m, Literal::String
+        rule %r/"([^"\\]|\\.)*"/, Literal::String
+        rule %r/'''.*?'''/m, Literal::String
+        rule %r/'([^'\\]|\\.)*'/, Literal::String
+
+        rule %r/#.*$/, Comment::Single
+
+        rule %r/@[^\s,.;]+/, Name::Attribute
+
+        rule %r/[+-]?[0-9]+\.[0-9]*E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?\.[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+
+        rule %r/[+-]?[0-9]*\.[0-9]+?/, Literal::Number::Float
+
+        rule %r/[+-]?[0-9]+/, Literal::Number::Integer
+
+        rule %r/\./, Punctuation
+        rule %r/,/, Punctuation
+        rule %r/;/, Punctuation
+        rule %r/\(/, Punctuation
+        rule %r/\)/, Punctuation
+        rule %r/\{/, Punctuation
+        rule %r/\}/, Punctuation
+        rule %r/\[/, Punctuation
+        rule %r/\]/, Punctuation
+        rule %r/\^\^/, Punctuation
+
+        rule %r/<[^>]*>/, Name::Label
+
+        rule %r/base\b/i, Keyword::Declaration
+        rule %r/prefix\b/i, Keyword::Declaration
+        rule %r/GRAPH\b/, Keyword
+        rule %r/a\b/, Keyword
+
+        rule %r/\s+/, Text::Whitespace
+
+        rule %r/[^:;<>#\@"\(\).\[\]\{\} ]+:/, Name::Namespace
+        rule %r/[^:;<>#\@"\(\).\[\]\{\} ]+/, Name
+      end
+    end
+  end
+end

data/lib/rouge/lexers/twig.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'jinja.rb'
+
+    class Twig < Jinja
+      title "Twig"
+      desc "Twig template engine (twig.sensiolabs.org)"
+
+      tag "twig"
+
+      filenames '*.twig'
+
+      mimetypes 'application/x-twig', 'text/html+twig'
+
+      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)
+      end
+
+      def self.tests
+        @@tests ||= %w(constant defined divisibleby empty even iterable null odd
+                       sameas)
+      end
+
+      def self.pseudo_keywords
+        @@pseudo_keywords ||= %w(true false none)
+      end
+
+      def self.word_operators
+        @@word_operators ||= %w(b-and b-or b-xor is in and or not)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/typescript.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'javascript.rb'
+    load_lexer 'typescript/common.rb'
+
+    class Typescript < Javascript
+      include TypescriptCommon
+
+      title "TypeScript"
+      desc "TypeScript, a superset of JavaScript"
+
+      tag 'typescript'
+      aliases 'ts'
+
+      filenames '*.ts', '*.d.ts'
+
+      mimetypes 'text/typescript'
+
+      prepend :root do
+        rule %r/[?][.]/, Punctuation
+      end
+
+      prepend :statement do
+        rule %r/(#{Javascript.id_regex})(\??)(\s*)(:)/ do
+          groups Name::Label, Punctuation, Text, Punctuation
+          push :expr_start
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    module TypescriptCommon
+      def self.keywords
+        @keywords ||= super + Set.new(%w(
+          is namespace static private protected public
+          implements readonly
+        ))
+      end
+
+      def self.declarations
+        @declarations ||= super + Set.new(%w(
+          type abstract
+        ))
+      end
+
+      def self.reserved
+        @reserved ||= super + Set.new(%w(
+          string any void number namespace module
+          declare default interface keyof
+        ))
+      end
+
+      def self.builtins
+        @builtins ||= super + %w(
+          Pick Partial Readonly Record
+        )
+      end
+    end
+  end
+end

data/lib/rouge/lexers/vala.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Vala < RegexLexer
+      tag 'vala'
+      filenames '*.vala'
+      mimetypes 'text/x-vala'
+
+      title "Vala"
+      desc 'A programming language similar to csharp.'
+
+      id = /@?[_a-z]\w*/i
+
+      keywords = %w(
+        abstract as async base break case catch const construct continue
+        default delegate delete do dynamic else ensures enum errordomain
+        extern false finally for foreach get global if in inline interface
+        internal is lock new null out override owned private protected
+        public ref requires return set signal sizeof static switch this
+        throw throws true try typeof unowned var value virtual void weak
+        while yield
+      )
+
+      keywords_type = %w(
+        bool char double float int int8 int16 int32 int64 long short size_t
+        ssize_t string unichar uint uint8 uint16 uint32 uint64 ulong ushort
+      )
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/^\s*\[.*?\]/, Name::Attribute
+
+        rule %r/(<\[)\s*(#{id}:)?/, Keyword
+        rule %r/\]>/, Keyword
+
+        rule %r/[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule %r/@"(\\.|.)*?"/, Str
+        rule %r/"(\\.|.)*?["\n]/, Str
+        rule %r/'(\\.|.)'/, Str::Char
+        rule %r/0x[0-9a-f]+[lu]?/i, Num
+        rule %r(
+          [0-9]
+          ([.][0-9]*)? # decimal
+          (e[+-][0-9]+)? # exponent
+          [fldu]? # type
+        )ix, Num
+        rule %r/\b(#{keywords.join('|')})\b/, Keyword
+        rule %r/\b(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule %r/class|struct/, Keyword, :class
+        rule %r/namespace|using/, Keyword, :namespace
+        rule %r/#{id}(?=\s*[(])/, Name::Function
+        rule id, Name
+
+        rule %r/#.*/, Comment::Preproc
+      end
+
+      state :class do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule %r/(?=[(])/, Text, :pop!
+        rule %r/(#{id}|[.])+/, Name::Namespace, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/varnish.rb

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Varnish < RegexLexer
+      title 'VCL: Varnish Configuration Language'
+      desc 'The configuration language for Varnish HTTP Cache (varnish-cache.org)'
+
+      tag 'vcl'
+      aliases 'varnishconf', 'varnish'
+      filenames '*.vcl'
+      mimetypes 'text/x-varnish', 'text/x-vcl'
+
+      SPACE = '[ \f\n\r\t\v]+'
+
+      # backend acl
+      def self.keywords
+        @keywords ||= Set.new %w[
+          vcl set unset include import if else elseif elif elsif director probe
+          backend acl
+
+          declare local
+          BOOL FLOAT INTEGER IP RTIME STRING TIME
+        ]
+      end
+
+      def self.functions
+        @functions ||= Set.new %w[
+          ban call hash_data new regsub regsuball return rollback
+          std.cache_req_body std.collect std.duration std.fileread std.healthy
+          std.integer std.ip std.log std.port std.querysort std.random std.real
+          std.real2time std.rollback std.set_ip_tos std.strstr std.syslog
+          std.time std.time2integer std.time2real std.timestamp std.tolower
+          std.toupper synth synthetic
+        ]
+      end
+
+      def self.variables
+        @variables ||= Set.new %w[
+          bereq bereq.backend bereq.between_bytes_timeout bereq.connect_timeout
+          bereq.first_byte_timeout bereq.method bereq.proto bereq.retries
+          bereq.uncacheable bereq.url bereq.xid beresp beresp.age
+          beresp.backend beresp.backend.ip beresp.backend.name beresp.do_esi
+          beresp.do_gunzip beresp.do_gzip beresp.do_stream beresp.grace
+          beresp.keep beresp.proto beresp.reason beresp.status
+          beresp.storage_hint beresp.ttl beresp.uncacheable beresp.was_304
+          client.identity client.ip local.ip now obj.age obj.grace obj.hits
+          obj.keep obj.proto obj.reason obj.status obj.ttl obj.uncacheable
+          remote.ip req req.backend_hint req.can_gzip req.esi req.esi_level
+          req.hash_always_miss req.hash_ignore_busy req.method req.proto
+          req.restarts req.ttl req.url req.xid resp resp.proto resp.reason
+          resp.status server.hostname server.identity server.ip
+        ]
+      end
+
+      # This is never used
+      # def self.routines
+      #   @routines ||= Set.new %w[
+      #     backend_error backend_fetch backend_response purge deliver fini hash
+      #     hit init miss pass pipe recv synth
+      #   ]
+      # end
+
+      state :root do
+        # long strings ({" ... "})
+        rule %r/\{".*?"}/m, Str::Single
+
+        # heredoc style long strings ({xyz"..."xyz})
+        rule %r/\{(\w+)".*?"(\1)\}/m, Str::Single
+
+        # comments
+        rule %r'/\*.*?\*/'m, Comment::Multiline
+        rule %r'(?://|#).*', Comment::Single
+
+        rule %r/true|false/, Keyword::Constant
+
+        # "wildcard variables"
+        var_prefix = Regexp.union(%w(beresp bereq resp req obj))
+        rule %r/(?:#{var_prefix})\.http\.[\w.-]+/ do
+          token Name::Variable
+        end
+
+        # local variables (var.*)
+        rule %r/(?:var)\.[\w.-]+/ do
+          token Name::Variable
+        end
+
+        rule %r/(sub)(#{SPACE})([\w-]+)/ do
+          groups Keyword, Text, Name::Function
+        end
+
+        # inline C (C{ ... }C)
+        rule %r/C\{/ do
+          token Comment::Preproc
+          push :inline_c
+        end
+
+        rule %r/\.?[a-z_][\w.-]*/i do |m|
+          next token Keyword if self.class.keywords.include? m[0]
+          next token Name::Function if self.class.functions.include? m[0]
+          next token Name::Variable if self.class.variables.include? m[0]
+          token Text
+        end
+
+        ## for number literals
+
+        decimal = %r/[0-9]+/
+        hex = %r/[0-9a-f]+/i
+
+        numeric = %r{
+          (?:
+            0x#{hex}
+            (?:\.#{hex})?
+            (?:p[+-]?#{hex})?
+          )
+          |
+          (?:
+            #{decimal}
+            (?:\.#{decimal})?
+            (?:e[+-]?#{decimal})?
+          )
+        }xi
+
+        # duration literals
+        duration_suffix = Regexp.union(%w(ms s m h d w y))
+        rule %r/#{numeric}#{duration_suffix}/, Num::Other
+
+        # numeric literals (integer / float)
+        rule numeric do |m|
+            case m[0]
+            when /^#{decimal}$/
+              token Num::Integer
+            when /^0x#{hex}$/
+              token Num::Integer
+            else
+              token Num::Float
+            end
+        end
+
+        # standard strings
+        rule %r/"/, Str::Double, :string
+
+        rule %r'[&|+-]{2}|[<=>!*/+-]=|<<|>>|!~|[-+*/%><=!&|~]', Operator
+
+        rule %r/[{}();.,]/, Punctuation
+
+        rule %r/\r\n?|\n/, Text
+        rule %r/./, Text
+      end
+
+      state :string do
+        rule %r/"/, Str::Double, :pop!
+        rule %r/\\[\\"nt]/, Str::Escape
+
+        rule %r/\r\n?|\n/, Str::Double
+        rule %r/./, Str::Double
+      end
+
+      state :inline_c do
+        rule %r/}C/, Comment::Preproc, :pop!
+        rule %r/.*?(?=}C)/m do
+          delegate C
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/vb.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class VisualBasic < RegexLexer
+      title "Visual Basic"
+      desc "Visual Basic"
+      tag 'vb'
+      aliases 'visualbasic'
+      filenames '*.vbs', '*.vb'
+      mimetypes 'text/x-visualbasic', 'application/x-visualbasic'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          AddHandler Alias ByRef ByVal CBool CByte CChar CDate CDbl CDec
+          CInt CLng CObj CSByte CShort CSng CStr CType CUInt CULng CUShort
+          Call Case Catch Class Const Continue Declare Default Delegate
+          Dim DirectCast Do Each Else ElseIf End EndIf Enum Erase Error
+          Event Exit False Finally For Friend Function Get Global GoSub
+          GoTo Handles If Implements Imports Inherits Interface Let
+          Lib Loop Me Module MustInherit MustOverride MyBase MyClass
+          Namespace Narrowing New Next Not NotInheritable NotOverridable
+          Nothing Of On Operator Option Optional Overloads Overridable
+          Overrides ParamArray Partial Private Property Protected Public
+          RaiseEvent ReDim ReadOnly RemoveHandler Resume Return Select Set
+          Shadows Shared Single Static Step Stop Structure Sub SyncLock
+          Then Throw To True Try TryCast Using Wend When While Widening
+          With WithEvents WriteOnly
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          Boolean Byte Char Date Decimal Double Integer Long Object
+          SByte Short Single String Variant UInteger ULong UShort
+        )
+      end
+
+      def self.operator_words
+        @operator_words ||= Set.new %w(
+          AddressOf And AndAlso As GetType In Is IsNot Like Mod Or OrElse
+          TypeOf Xor
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          Console ConsoleColor
+        )
+      end
+
+      id = /[a-z_]\w*/i
+      upper_id = /[A-Z]\w*/
+
+      state :whitespace do
+        rule %r/\s+/, Text
+        rule %r/\n/, Text, :bol
+        rule %r/rem\b.*?$/i, Comment::Single
+        rule %r(%\{.*?%\})m, Comment::Multiline
+        rule %r/'.*$/, Comment::Single
+      end
+
+      state :bol do
+        rule %r/\s+/, Text
+        rule %r/<.*?>/, Name::Attribute
+        rule(//) { :pop! }
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r(
+            [#]If\b .*? \bThen
+          | [#]ElseIf\b .*? \bThen
+          | [#]End \s+ If
+          | [#]Const
+          | [#]ExternalSource .*? \n
+          | [#]End \s+ ExternalSource
+          | [#]Region .*? \n
+          | [#]End \s+ Region
+          | [#]ExternalChecksum
+        )x, Comment::Preproc
+        rule %r/[.]/, Punctuation, :dotted
+        rule %r/[(){}!#,:]/, Punctuation
+        rule %r/Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text)/,
+          Keyword::Declaration
+        rule %r/End\b/, Keyword, :end
+        rule %r/(Dim|Const)\b/, Keyword, :dim
+        rule %r/(Function|Sub|Property)\b/, Keyword, :funcname
+        rule %r/(Class|Structure|Enum)\b/, Keyword, :classname
+        rule %r/(Module|Namespace|Imports)\b/, Keyword, :namespace
+
+        rule upper_id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.keywords_type.include? match
+            token Keyword::Type
+          elsif self.class.operator_words.include? match
+            token Operator::Word
+          elsif self.class.builtins.include? match
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        rule(
+          %r(&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>.]),
+          Operator
+        )
+
+        rule %r/"/, Str, :string
+        rule %r/#{id}[%&@!#\$]?/, Name
+        rule %r/#.*?#/, Literal::Date
+
+        rule %r/(\d+\.\d*|\d*\.\d+)(f[+-]?\d+)?/i, Num::Float
+        rule %r/\d+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule %r/&H[0-9a-f]+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule %r/&O[0-7]+([SILDFR]|US|UI|UL)?/, Num::Integer
+
+        rule %r/_\n/, Keyword
+      end
+
+      state :dotted do
+        mixin :whitespace
+        rule id, Name, :pop!
+      end
+
+      state :string do
+        rule %r/""/, Str::Escape
+        rule %r/"C?/, Str, :pop!
+        rule %r/[^"]+/, Str
+      end
+
+      state :dim do
+        mixin :whitespace
+        rule id, Name::Variable, :pop!
+        rule(//) { pop! }
+      end
+
+      state :funcname do
+        mixin :whitespace
+        rule id, Name::Function, :pop!
+      end
+
+      state :classname do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule %r/#{id}([.]#{id})*/, Name::Namespace, :pop!
+      end
+
+      state :end do
+        mixin :whitespace
+        rule %r/(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b/,
+          Keyword, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end