rouge 3.13.0 → 3.18.0

data/lib/rouge/lexers/swift.rb

@@ -25,7 +25,7 @@ module Rouge
       )
 
       declarations = Set.new %w(
-        class deinit enum convenience extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate
+        class deinit enum convenience extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate some
       )
 
       constants = Set.new %w(
@@ -67,6 +67,7 @@ module Rouge
 
       state :root do
         mixin :whitespace
+        
         rule %r/\$(([1-9]\d*)?\d)/, Name::Variable
 
         rule %r{[()\[\]{}:;,?\\]}, Punctuation

data/lib/rouge/lexers/terraform.rb

@@ -81,9 +81,24 @@ module Rouge
         mixin :expression
       end
 
+      state :regexps do
+        rule %r/"\// do
+          token Str::Delimiter
+          goto :regexp_inner
+        end
+      end
+
+      state :regexp_inner do
+        rule %r/[^"\/\\]+/, Str::Regex
+        rule %r/\\./, Str::Regex
+        rule %r/\/"/, Str::Delimiter, :pop!
+        rule %r/["\/]/, Str::Regex
+      end
+
       id = /[$a-z_\-][a-z0-9_\-]*/io
 
       state :expression do
+        mixin :regexps
         mixin :primitives
         rule %r/\s+/, Text
 

data/lib/rouge/lexers/toml.rb

@@ -17,6 +17,12 @@ module Rouge
         rule %r/\s+/, Text
         rule %r/#.*?$/, Comment
         rule %r/(true|false)/, Keyword::Constant
+
+        rule %r/(\S+)(\s*)(=)(\s*)(\{)/ do |m|
+          groups Name::Namespace, Text, Operator, Text, Punctuation
+          push :inline
+        end
+
         rule %r/(?<!=)\s*\[[\S]+\]/, Name::Namespace
 
         rule %r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
@@ -33,7 +39,6 @@ module Rouge
           groups Name::Property, Text, Punctuation
           push :value
         end
-
       end
 
       state :value do
@@ -43,7 +48,10 @@ module Rouge
 
       state :content do
         mixin :basic
+        rule %r/"""/, Str, :mdq
         rule %r/"/, Str, :dq
+        rule %r/'''/, Str, :msq
+        rule %r/'/, Str, :sq
         mixin :esc_str
         rule %r/\,/, Punctuation
         rule %r/\[/, Punctuation, :array
@@ -51,8 +59,28 @@ module Rouge
 
       state :dq do
         rule %r/"/, Str, :pop!
+        rule %r/\n/, Error, :pop!
+        mixin :esc_str
+        rule %r/[^\\"\n]+/, Str
+      end
+
+      state :mdq do
+        rule %r/"""/, Str, :pop!
         mixin :esc_str
         rule %r/[^\\"]+/, Str
+        rule %r/"+/, Str
+      end
+
+      state :sq do
+        rule %r/'/, Str, :pop!
+        rule %r/\n/, Error, :pop!
+        rule %r/[^'\n]+/, Str
+      end
+
+      state :msq do
+        rule %r/'''/, Str, :pop!
+        rule %r/[^']+/, Str
+        rule %r/'+/, Str
       end
 
       state :esc_str do
@@ -63,6 +91,16 @@ module Rouge
         mixin :content
         rule %r/\]/, Punctuation, :pop!
       end
+
+      state :inline do
+        mixin :content
+
+        rule %r/(#{identifier})(\s*)(=)/ do
+          groups Name::Property, Text, Punctuation
+        end
+
+        rule %r/\}/, Punctuation, :pop!
+      end
     end
   end
 end

data/lib/rouge/lexers/typescript.rb

@@ -18,6 +18,17 @@ module Rouge
       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/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/verilog.rb

@@ -100,7 +100,7 @@ module Rouge
 
       state :whitespace do
         rule %r/\n+/m, Text, :bol
-        rule %r(//(\\.|.)*?\n), Comment::Single, :bol
+        rule %r(//(\\.|.)*?$), Comment::Single, :bol
         mixin :inline_whitespace
       end
 

data/lib/rouge/lexers/viml.rb

@@ -14,7 +14,7 @@ module Rouge
       mimetypes 'text/x-vim'
 
       def self.keywords
-        load File.join(__dir__, 'viml/keywords.rb')
+        load File.join(Lexers::BASE_DIR, 'viml/keywords.rb')
         self.keywords
       end
 

data/lib/rouge/lexers/vue.rb

@@ -58,6 +58,10 @@ module Rouge
         end
       end
 
+      prepend :tag do
+        rule %r/[a-zA-Z0-9_:#\[\]()*.-]+\s*=\s*/m, Name::Attribute, :attr
+      end
+
       state :style do
         rule %r/(<\s*\/\s*)(style)(\s*>)/ do
           groups Name::Tag, Keyword, Name::Tag
@@ -121,4 +125,3 @@ module Rouge
     end
   end
 end
-

data/lib/rouge/lexers/yang.rb

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class YANG < RegexLexer
+      title 'YANG'
+      desc "Lexer for the YANG 1.1 modeling language (RFC7950)"
+      tag 'yang'
+      filenames '*.yang'
+      mimetypes 'application/yang'
+
+      id = /[\w_-]+(?=[^\w\-\:])\b/
+
+      #Keywords from RFC7950 ; oriented at BNF style
+      def self.top_stmts_keywords
+        @top_stms_keywords ||= Set.new %w(
+          module submodule
+        )
+      end
+
+      def self.module_header_stmts_keywords
+        @module_header_stmts_keywords ||= Set.new %w(
+          belongs-to namespace prefix yang-version
+        )
+      end
+
+      def self.meta_stmts_keywords
+        @meta_stmts_keywords ||= Set.new %w(
+          contact description organization reference revision
+        )
+      end
+
+      def self.linkage_stmts_keywords
+        @linkage_stmts_keywords ||= Set.new %w(
+          import include revision-date
+        )
+      end
+
+      def self.body_stmts_keywords
+        @body_stms_keywords ||= Set.new %w(
+          action argument augment deviation extension feature grouping identity
+          if-feature input notification output rpc typedef
+        )
+      end
+
+      def self.data_def_stmts_keywords
+        @data_def_stms_keywords ||= Set.new %w(
+          anydata anyxml case choice config container deviate leaf leaf-list
+          list must presence refine uses when
+        )
+      end
+
+      def self.type_stmts_keywords
+        @type_stmts_keywords ||= Set.new %w(
+          base bit default enum error-app-tag error-message fraction-digits
+          length max-elements min-elements modifier ordered-by path pattern
+          position range require-instance status type units value yin-element
+        )
+      end
+
+      def self.list_stmts_keywords
+        @list_stmts_keywords ||= Set.new %w(
+          key mandatory unique
+        )
+      end
+
+      #RFC7950 other keywords
+      def self.constants_keywords
+        @constants_keywords ||= Set.new %w(
+          add current delete deprecated false invert-match max min
+          not-supported obsolete replace true unbounded user
+        )
+      end
+
+      #RFC7950 Built-In Types
+      def self.types
+        @types ||= Set.new %w(
+          binary bits boolean decimal64 empty enumeration identityref
+          instance-identifier int16 int32 int64 int8 leafref string uint16
+          uint32 uint64 uint8 union
+        )
+      end
+
+      state :comment do
+        rule %r/[^*\/]/, Comment
+        rule %r/\/\*/, Comment, :comment
+        rule %r/\*\//, Comment, :pop!
+        rule %r/[*\/]/, Comment
+      end
+
+      #Keyword::Reserved
+      #groups Name::Tag, Text::Whitespace
+      state :root do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/[\{\}\;]+/, Punctuation
+        rule %r/(?<![\-\w])(and|or|not|\+|\.)(?![\-\w])/, Operator
+
+        rule %r/"(?:\\"|[^"])*?"/, Str::Double #for double quotes
+        rule %r/'(?:\\'|[^'])*?'/, Str::Single #for single quotes
+
+        rule %r/\/\*/, Comment, :comment
+        rule %r/\/\/.*?$/, Comment
+
+        #match BNF stmt for `node-identifier` with [ prefix ":"]
+        rule %r/(?:^|(?<=[\s{};]))([\w.-]+)(:)([\w.-]+)(?=[\s{};])/ do
+          groups Name::Namespace, Punctuation, Name
+        end
+
+        #match BNF stmt `date-arg-str`
+        rule %r/([0-9]{4}\-[0-9]{2}\-[0-9]{2})(?=[\s\{\}\;])/, Name::Label
+        rule %r/([0-9]+\.[0-9]+)(?=[\s\{\}\;])/, Num::Float
+        rule %r/([0-9]+)(?=[\s\{\}\;])/, Num::Integer
+
+        rule id do |m|
+          name = m[0].downcase
+
+          if self.class.top_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.module_header_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.meta_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.linkage_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.body_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.data_def_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.type_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.list_stmts_keywords.include? name
+            token Keyword::Declaration
+          elsif self.class.types.include? name
+            token Keyword::Type
+          elsif self.class.constants_keywords.include? name
+            token Name::Constant
+          else
+            token Name
+          end
+        end
+
+        rule %r/[^;{}\s'"]+/, Name
+      end
+    end
+  end
+end