rouge 3.15.0 → 3.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5da5e5d1e737275e6a41550af0aaa6af398cb8517b67717f07d9ad632c13e28a
-  data.tar.gz: 4dc38a2b67f0eeb0890143442c411be221e00fc78718c8f404d9dbf6f787b29a
+  metadata.gz: 5342709cd08d6095557fbe22c79544c6be522f2343ed53360ab57f96bb37c077
+  data.tar.gz: 25e1d81909ad22cece899eaf4d6c32ec1e0931611031f3ac8a37b6be3bceb497
 SHA512:
-  metadata.gz: 911cf95350e23be5bb1bfedbf178e3872a37d5930f201156fa7daff16a2bad5609043cae7a917a1aa8adf9b863b28538266217271693da8cbfe68aa20a2df82f
-  data.tar.gz: 5f363794c19033fd11c3a5360fbcf550536f8f5292962a0ab70e434d1f4f1aa5711c938c19ddf088b4eb76140e54e24029229524321048bc451950a006140f51
+  metadata.gz: e1244771613b6d0ec7523c834084974c4c9e6145a06d237e1bf937ffced73af0a7f7c4bf5efbf397b5bf943df7a66d4614cc601c82721f6b2d03425dc9118ecc
+  data.tar.gz: ba9ecdc95aae8f45745820720b167ac102c1ac6d9af431024090cb79dd7805fb2ba981207de97c052339388b2886d2eb79e036b9aa60aaa8b6bc869bef9b5468

data/lib/rouge.rb

@@ -72,6 +72,7 @@ load_relative 'rouge/formatters/html_linewise'
 load_relative 'rouge/formatters/html_line_table'
 load_relative 'rouge/formatters/html_inline'
 load_relative 'rouge/formatters/terminal256'
+load_relative 'rouge/formatters/terminal_truecolor'
 load_relative 'rouge/formatters/tex'
 load_relative 'rouge/formatters/null'
 

data/lib/rouge/cli.rb

@@ -4,6 +4,8 @@
 # not required by the main lib.
 # to use this module, require 'rouge/cli'.
 
+require 'rbconfig'
+
 module Rouge
   class FileReader
     attr_reader :input
@@ -200,9 +202,22 @@ module Rouge
         yield %[                            delimiters. implies --escape]
       end
 
+      # There is no consistent way to do this, but this is used elsewhere,
+      # and we provide explicit opt-in and opt-out with $COLORTERM
+      def self.supports_truecolor?
+        return true if %w(24bit truecolor).include?(ENV['COLORTERM'])
+        return false if ENV['COLORTERM'] && ENV['COLORTERM'] =~ /256/
+
+        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+          ENV['ConEmuANSI'] == 'ON' && !ENV['ANSICON']
+        else
+          ENV['TERM'] !~ /(^rxvt)|(-color$)/
+        end
+      end
+
       def self.parse(argv)
         opts = {
-          :formatter => 'terminal256',
+          :formatter => supports_truecolor? ? 'terminal-truecolor' : 'terminal256',
           :theme => 'thankful_eyes',
           :css_class => 'codehilite',
           :input_file => '-',
@@ -299,8 +314,10 @@ module Rouge
 
         theme = Theme.find(opts[:theme]).new or error! "unknown theme #{opts[:theme]}"
 
+        # TODO: document this in --help
         @formatter = case opts[:formatter]
         when 'terminal256' then Formatters::Terminal256.new(theme)
+        when 'terminal-truecolor' then Formatters::TerminalTruecolor.new(theme)
         when 'html' then Formatters::HTML.new
         when 'html-pygments' then Formatters::HTMLPygments.new(Formatters::HTML.new, opts[:css_class])
         when 'html-inline' then Formatters::HTMLInline.new(theme)

data/lib/rouge/demos/nasm

@@ -10,12 +10,12 @@
 extern irq_handler
 
 irq_common_stub:
-    pusha           ; Pushes edi,esi,ebp,esp,ebx,edx,ecx,eax
-    mov ax, ds      ; Lower 16-bits of eax = ds.
-    push eax        ; save the data segment descriptor
-    mov ax, 0x10    ; load the kernel data segment descriptor
-    mov edx, eax
-    call irq_handler
+    pusha             ; push all general-purpose registers
+    mov   ax, ds      ; lower 16-bits of eax = ds
+    push  eax         ; save the data segment descriptor
+    mov   ax, 0x10    ; load the kernel data segment descriptor
+    mov   edx, eax
+    call  irq_handler
 
 %assign i 0
 %rep 8

data/lib/rouge/demos/varnish

@@ -0,0 +1,55 @@
+vcl 4.0;
+
+backend server1 {
+      .host = "server1.example.com";
+      .probe = {
+              .url = "/";
+              .timeout = 1s;
+              .interval = 5s;
+              .window = 5;
+              .threshold = 3;
+      }
+}
+
+sub vcl_hit {
+    # Called when a cache lookup is successful.
+
+    if (obj.ttl >= 0s) {
+        # A pure unadultered hit, deliver it
+        return (deliver);
+    }
+
+    # https://www.varnish-cache.org/docs/trunk/users-guide/vcl-grace.html
+    # When several clients are requesting the same page Varnish will send one request to the backend and place the others on hold while fetching one copy from the backend. In some products this is called request coalescing and Varnish does this automatically.
+    # If you are serving thousands of hits per second the queue of waiting requests can get huge. There are two potential problems - one is a thundering herd problem - suddenly releasing a thousand threads to serve content might send the load sky high. Secondly - nobody likes to wait. To deal with this we can instruct Varnish to keep the objects in cache beyond their TTL and to serve the waiting requests somewhat stale content.
+
+# if (!std.healthy(req.backend_hint) && (obj.ttl + obj.grace > 0s)) {
+#     return (deliver);
+# } else {
+#     return (fetch);
+# }
+
+    # We have no fresh fish. Lets look at the stale ones.
+    if (std.healthy(req.backend_hint)) {
+        # Backend is healthy. Limit age to 10s.
+        if (obj.ttl + 10s > 0s) {
+            #set req.http.grace = "normal(limited)";
+            return (deliver);
+        } else {
+            # No candidate for grace. Fetch a fresh object.
+            return(fetch);
+        }
+    } else {
+        # backend is sick - use full grace
+            if (obj.ttl + obj.grace > 0s) {
+            #set req.http.grace = "full";
+            return (deliver);
+        } else {
+            # no graced object.
+            return (fetch);
+        }
+    }
+
+    # fetch & deliver once we get the result
+    return (fetch); # Dead code, keep as a safeguard
+}

data/lib/rouge/formatters/terminal256.rb

@@ -24,10 +24,7 @@ module Rouge
 
       def stream(tokens, &b)
         tokens.each do |tok, val|
-          escape = escape_sequence(tok)
-          yield escape.style_string
-          yield val.gsub("\n", "#{escape.reset_string}\n#{escape.style_string}")
-          yield escape.reset_string
+          escape_sequence(tok).stream_value(val, &b)
         end
       end
 
@@ -85,6 +82,14 @@ module Rouge
           @bg = style.bg && self.class.color_index(style.bg)
         end
 
+
+        def stream_value(val, &b)
+          yield style_string
+          yield val.gsub("\e", "\\e")
+                   .gsub("\n", "#{reset_string}\n#{style_string}")
+          yield reset_string
+        end
+
         def style_string
           @style_string ||= begin
             attrs = []
@@ -157,12 +162,23 @@ module Rouge
         end
       end
 
+      class Unescape < EscapeSequence
+        def initialize(*) end
+        def style_string(*) '' end
+        def reset_string(*) '' end
+        def stream_value(val) yield val end
+      end
+
     # private
       def escape_sequence(token)
-        return '' if escape?(token)
+        return Unescape.new if escape?(token)
         @escape_sequences ||= {}
         @escape_sequences[token.qualname] ||=
-          EscapeSequence.new(get_style(token))
+          make_escape_sequence(get_style(token))
+      end
+
+      def make_escape_sequence(style)
+        EscapeSequence.new(style)
       end
 
       def get_style(token)

data/lib/rouge/formatters/terminal_truecolor.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+module Rouge
+  module Formatters
+    class TerminalTruecolor < Terminal256
+      tag 'terminal_truecolor'
+
+      class TruecolorEscapeSequence < Terminal256::EscapeSequence
+        def style_string
+          @style_string ||= begin
+            out = String.new('')
+            out << escape(['48', '2', *get_rgb(style.bg)]) if style.bg
+            out << escape(['38', '2', *get_rgb(style.fg)]) if style.fg
+            out << escape(['1']) if style[:bold] || style[:italic]
+            out
+          end
+        end
+
+        def get_rgb(color)
+          color = $1 if color =~ /#(\h+)/
+
+          case color.size
+          when 3 then color.chars.map { |c| c.to_i(16) * 2 }
+          when 6 then color.scan(/../).map { |cc| cc.to_i(16) }
+          else
+            raise "invalid color: #{color.inspect}"
+          end
+        end
+      end
+
+      # @override
+      def make_escape_sequence(style)
+        TruecolorEscapeSequence.new(style)
+      end
+    end
+  end
+end

data/lib/rouge/lexer.rb

@@ -209,7 +209,8 @@ module Rouge
       # Determine if a lexer has a method named +:detect?+ defined in its
       # singleton class.
       def detectable?
-        @detectable ||= methods(false).include?(:detect?)
+        return @detectable if defined?(@detectable)
+        @detectable = singleton_methods(false).include?(:detect?)
       end
 
     protected

data/lib/rouge/lexers/d.rb

@@ -35,9 +35,9 @@ module Rouge
       )
 
       keywords_pseudo = %w(
-        __FILE__ __MODULE__ __LINE__ __FUNCTION__ __PRETTY_FUNCTION__
-         __DATE__ __EOF__ __TIME__ __TIMESTAMP__ __VENDOR__
-        __VERSION__
+        __FILE__ __FILE_FULL_PATH__ __MODULE__ __LINE__ __FUNCTION__
+        __PRETTY_FUNCTION__ __DATE__ __EOF__ __TIME__ __TIMESTAMP__
+        __VENDOR__ __VERSION__
       )
 
       state :whitespace do

data/lib/rouge/lexers/java.rb

@@ -23,9 +23,9 @@ module Rouge
 
       types = %w(boolean byte char double float int long short var void)
 
-      id = /[a-zA-Z_][a-zA-Z0-9_]*/
-      const_name = /[A-Z][A-Z0-9_]*\b/
-      class_name = /[A-Z][a-zA-Z0-9]*\b/
+      id = /[[:alpha:]_][[:word:]]*/
+      const_name = /[[:upper:]][[:upper:][:digit:]_]*\b/
+      class_name = /[[:upper:]][[:alnum:]]*\b/
 
       state :root do
         rule %r/[^\S\n]+/, Text
@@ -50,10 +50,9 @@ module Rouge
         rule %r/@#{id}/, Name::Decorator
         rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
         rule %r/(?:#{types.join('|')})\b/, Keyword::Type
-        rule %r/package\b/, Keyword::Namespace
         rule %r/(?:true|false|null)\b/, Keyword::Constant
         rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
-        rule %r/import\b/, Keyword::Namespace, :import
+        rule %r/(?:import|package)\b/, Keyword::Namespace, :import
         rule %r/"(\\\\|\\"|[^"])*"/, Str
         rule %r/'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
         rule %r/(\.)(#{id})/ do

data/lib/rouge/lexers/lua.rb

@@ -72,7 +72,10 @@ module Rouge
 
         rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
           name = m[0]
-          if self.builtins.include?(name)
+          if name == "gsub"
+            token Name::Builtin
+            push :gsub
+          elsif self.builtins.include?(name)
             token Name::Builtin
           elsif name =~ /\./
             a, b = name.split('.', 2)
@@ -98,6 +101,41 @@ module Rouge
         rule %r(\(), Punctuation, :pop!
       end
 
+      state :gsub do
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/[(,]/, Punctuation
+        rule %r/\s+/, Text
+        rule %r/"/, Str::Regex, :regex
+      end
+
+      state :regex do
+        rule %r(") do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r/\[\^?/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_end do
+        rule %r/[$]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        rule %r(/), Str::Escape
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/(\\)(.)/ do |m|
+          groups Str::Escape, Str::Regex
+        end
+        rule %r/./, Str::Regex
+      end
+
       state :escape_sqs do
         mixin :string_escape
         mixin :sqs

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

@@ -10,7 +10,7 @@ module Rouge
         @at_keywords ||= %w(
           selector private protected public encode synchronized try
           throw catch finally end property synthesize dynamic optional
-          interface implementation import
+          interface implementation import autoreleasepool
         )
       end
 
@@ -44,7 +44,7 @@ module Rouge
             elsif base.at_builtins.include? m[1]
               token base::Name::Builtin
             else
-              token Error
+              token base::Error
             end
           end
 

data/lib/rouge/lexers/powershell.rb

@@ -201,6 +201,11 @@ module Rouge
         rule %r/(?:#{KEYWORDS})\b(?![-.])/i, Keyword::Reserved
 
         rule %r/-{1,2}\w+/, Name::Tag
+        
+        rule %r/(\.)?([-\w]+)(\[)/ do |m|
+          groups Operator, Name::Function, Punctuation
+          push :bracket
+        end
 
         rule %r/([\/\\~\w][-.:\/\\~\w]*)(\n)?/ do |m|
           groups Name::Function, Text::Whitespace

data/lib/rouge/lexers/rust.rb

@@ -159,6 +159,7 @@ module Rouge
         )x, Str::Char
 
         rule %r/"/, Str, :string
+        rule %r/r(#*)".*?"\1/m, Str
 
         # numbers
         dot = /[.][0-9_]+/
@@ -185,16 +186,7 @@ module Rouge
       state :string do
         rule %r/"/, Str, :pop!
         rule escapes, Str::Escape
-        rule %r/%%/, Str::Interpol
-        rule %r(
-          %
-          ( [0-9]+ [$] )?  # Parameter
-          [0#+-]*          # Flag
-          ( [0-9]+ [$]? )? # Width
-          ( [.] [0-9]+ )?  # Precision
-          [bcdfiostuxX?]   # Type
-        )x, Str::Interpol
-        rule %r/[^%"\\]+/m, Str
+        rule %r/[^"\\]+/m, Str
       end
     end
   end

data/lib/rouge/lexers/shell.rb

@@ -64,7 +64,7 @@ module Rouge
         # here-string
         rule %r/<<</, Operator
 
-        rule %r/(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
+        rule %r/(<<-?)(\s*)(['"]?)(\\?)(\w+)(\3)/ do |m|
           groups Operator, Text, Str::Heredoc, Str::Heredoc, Name::Constant, Str::Heredoc
           @heredocstr = Regexp.escape(m[5])
           push :heredoc

data/lib/rouge/lexers/toml.rb

@@ -48,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
@@ -56,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

data/lib/rouge/lexers/typescript.rb

@@ -18,6 +18,13 @@ module Rouge
       filenames '*.ts', '*.d.ts'
 
       mimetypes 'text/typescript'
+
+      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,131 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Varnish < RegexLexer
+      title 'Varnish'
+      desc 'The Varnish (high-performance web accelerator) configuration language'
+
+      tag 'varnish'
+      aliases 'varnishconf', 'VCL'
+      filenames '*.vcl'
+      mimetypes 'text/x-varnish'
+
+      LNUM = '[0-9]+'
+      DNUM = '([0-9]*"."[0-9]+)|([0-9]+"."[0-9]*)'
+      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
+        ]
+      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
+
+        # comments
+        rule %r'/\*.*?\*/'m, Comment::Multiline
+        rule %r'(?://|#).*', Comment::Single
+
+        rule %r/true|false/, Keyword::Constant
+
+        # "wildcard variables"
+        rule %r/(?:(?:be)?re(?:sp|q)|obj)\.http\.[\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_.-]+/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
+
+        # duration
+        rule %r/(?:#{LNUM}|#{DNUM})(?:ms|[smhdwy])/, Num::Other
+        # size in bytes
+        rule %r/#{LNUM}[KMGT]?B/, Num::Other
+        # literal numeric values (integer/float)
+        rule %r/#{LNUM}/, Num::Integer
+        rule %r/#{DNUM}/, Num::Float
+
+        # 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/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "3.15.0"
+    "3.16.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 3.15.0
+  version: 3.16.0
 platform: ruby
 authors:
 - Jeanine Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-14 00:00:00.000000000 Z
+date: 2020-02-11 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -193,6 +193,7 @@ files:
 - lib/rouge/demos/twig
 - lib/rouge/demos/typescript
 - lib/rouge/demos/vala
+- lib/rouge/demos/varnish
 - lib/rouge/demos/vb
 - lib/rouge/demos/verilog
 - lib/rouge/demos/vhdl
@@ -214,6 +215,7 @@ files:
 - lib/rouge/formatters/html_table.rb
 - lib/rouge/formatters/null.rb
 - lib/rouge/formatters/terminal256.rb
+- lib/rouge/formatters/terminal_truecolor.rb
 - lib/rouge/formatters/tex.rb
 - lib/rouge/guesser.rb
 - lib/rouge/guessers/disambiguation.rb
@@ -405,6 +407,7 @@ files:
 - lib/rouge/lexers/typescript.rb
 - lib/rouge/lexers/typescript/common.rb
 - lib/rouge/lexers/vala.rb
+- lib/rouge/lexers/varnish.rb
 - lib/rouge/lexers/vb.rb
 - lib/rouge/lexers/verilog.rb
 - lib/rouge/lexers/vhdl.rb