rouge 4.7.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05371bcf7512316daaccf75a2f7c24da653b802892662c9956cbf7bcfe42f51
-  data.tar.gz: 6280b9bb9841c1bab6d563649a981c71ac996e248fe3d895bf0e38dbb4562ea0
+  metadata.gz: 9123349dc8d157c07642dd422b2ce6589c42728fcc9a204255b55c2cdac11a41
+  data.tar.gz: b077e0041bb215f3e3c33799e333c4983df1d98d35ecf0606e82563de05c2c0b
 SHA512:
-  metadata.gz: df0cb13e8befea6fa4d387753e245cc3ed9ace57471979cbf6869ddde69d6e2703ddc9dbfdff09da1b0e6c1b871abd9ec47325f2a5c034df5ad8cd0820dec39e
-  data.tar.gz: 32224ae94596fd50173264ab44a97d9928cc3b3f1fc2e3bb4fb1f40004e18637d8afd44cf3e482f028ac95157598f9b932238c3f593d4d3ac65ec4d4df486da7
+  metadata.gz: 3b94cebfc00d70f126ae1ee7675c123d1d2f6bbbdaba02b659c1f864392f457f7e934117f43a1f17691eefa1c3b2b160f2c2e43f368bcf39737a766d98d87e7e
+  data.tar.gz: d21221f27e9a98c1698a870fde934dc914e6cb7fea60ad782e2f3bcfa795ea7fc6eac2034193266e73ec8194f53f6c69d4a812467612536417bfb60bf39aec07

data/Gemfile

@@ -23,8 +23,10 @@ group :development do
   gem 'git'
   gem 'yard'
 
-  gem 'rubocop', '~> 1.0', '<= 1.11'
-  gem 'rubocop-performance'
+  gem 'rubocop'
+  gem 'rubocop-performance', '~> 1.26'
+  gem 'rubocop-minitest', '~> 0.38'
+  gem 'rubocop-rake', '~> 0.7'
 
   # docs
   gem 'github-markup'
@@ -32,10 +34,15 @@ group :development do
   # for visual tests
   gem 'sinatra'
 
-  # Ruby 3 no longer ships with a web server
-  gem 'puma' if RUBY_VERSION >= '3'
+  gem 'puma'
   gem 'shotgun'
 
   gem "mutex_m" if RUBY_VERSION >= '3.4'
   gem "base64" if RUBY_VERSION >= '3.4'
+
+  gem 'ostruct'
+  gem 'reline'
+  gem 'nokogiri'
+
+  gem 'svn-downloader'
 end

data/bin/rougify

@@ -1,10 +1,9 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'pathname'
-ROOT_DIR = Pathname.new(__FILE__).dirname.parent
-Kernel::load ROOT_DIR.join('lib/rouge.rb')
-Kernel::load ROOT_DIR.join('lib/rouge/cli.rb')
+require_relative "../lib/rouge"
+require_relative "../lib/rouge/cli"
+
 Signal.trap('PIPE', 'SYSTEM_DEFAULT') if Signal.list.include? 'PIPE'
 
 begin

data/lib/rouge/cli.rb

@@ -5,7 +5,6 @@
 # to use this module, require 'rouge/cli'.
 
 require 'rbconfig'
-require 'uri'
 
 module Rouge
   class FileReader
@@ -160,7 +159,7 @@ module Rouge
       end
 
       def run
-        @mode.doc.each(&method(:puts))
+        @mode.doc.each { |line| puts line }
       end
     end
 
@@ -213,7 +212,7 @@ module Rouge
       # 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/
+        return false if ENV['COLORTERM'] && ENV['COLORTERM'].include?('256')
 
         if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
           ENV['ConEmuANSI'] == 'ON' && !ENV['ANSICON']
@@ -345,10 +344,10 @@ module Rouge
 
       def run
         Formatter.enable_escape! if @escape
-        formatter.format(lexer.lex(input), &method(:print))
+        formatter.format(lexer.lex(input)) { |piece| print piece }
       end
 
-    private_class_method def self.parse_cgi(str)
+      private_class_method def self.parse_cgi(str)
         pairs = URI.decode_www_form(str).map { |k, v| [k.to_sym, v] }
         Hash[pairs]
       end
@@ -440,7 +439,7 @@ module Rouge
       end
 
       def run
-        @theme.render(&method(:puts))
+        @theme.render { |line| puts line }
       end
     end
 
@@ -511,13 +510,11 @@ module Rouge
     end
 
 
-  private_class_method def self.normalize_syntax(argv)
+    private_class_method def self.normalize_syntax(argv)
       out = []
       argv.each do |arg|
         case arg
-        when /^(--\w+)=(.*)$/
-          out << $1 << $2
-        when /^(-\w)(.+)$/
+        when /^(--\w+)=(.*)$/, /^(-\w)(.+)$/
           out << $1 << $2
         else
           out << arg

data/lib/rouge/demos/abap

@@ -1,6 +1,32 @@
-lo_obj ?= lo_obj->do_nothing( 'Char' && ` String` ).
+* Create a new object
+DATA(lo_obj) = new zcl_obj_factory(
+  EXPORTING
+    input = |some nice string|
+)
+DATA(lo_subobj) ?= lo_obj->do_nothing( 'Char' && ` String` ).
 
-SELECT SINGLE * FROM mara INTO ls_mara WHERE matkl EQ '1324'.
-LOOP AT lt_mara ASSIGNING <mara>.
-  CHECK <mara>-mtart EQ '0001'.
+" fetch material data
+SELECT SINGLE matnr, matkl, mtart, maktx
+  FROM mara 
+  INNER JOIN makt 
+    ON makt~matnr EQ mara~matnr
+  INTO @data(ls_mara) 
+  WHERE matkl EQ '1324'
+    AND spras EQ @sy-langu.
+
+LOOP AT lt_mara ASSIGNING FIELD-SYMBOL(<mara>).
+  CHECK <mara>-mtart = '0001'.
 ENDLOOP.
+
+CALL FUNCTION 'DO_NOTHING'
+  EXPORTING
+    input = 'input'
+  IMPORTING
+    output = 'output'
+  CHANGING
+    to_change = lv_some_variable  
+  TABLES
+    table_to_change = lt_some_table
+  EXCEPTIONS
+    ERROR = 1
+    OTHERS = 2.

data/lib/rouge/demos/dylan

@@ -0,0 +1,8 @@
+// Various keywords and constants
+define method demo(x :: <integer>, #key y = "demo") => ()
+  let z = #xFEE8 + #o277;
+  let w = '\n';
+  format-out("%d %s %d %c", x + 100, y, z, w);
+end method;
+
+demo(99, y: "hello");

data/lib/rouge/demos/kick_assembler

@@ -0,0 +1,14 @@
+BasicUpstart2(start)
+
+.const GET_CHAR = $ffe4
+
+start:
+  jsr get_char
+  rts
+
+// Routine
+get_char: {
+  jsr GET_CHAR
+  beq get_char
+  rts
+}

data/lib/rouge/demos/pdf

@@ -0,0 +1,29 @@
+%PDF-1.6
+%©©©©
+
+1 0 obj<</Type/Catalog/Pages 2 0 R/StructTreeRoot null/MarkInfo<</Marked false>>>>
+endobj
+2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>
+endobj
+3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[.0 0 200 200]/Contents 4 0 R/Resources<<>>>>
+endobj
+4 0 obj<</Length 60>>
+stream
+  +8 w 1 j
+  1.0 0 0 rg
+  0 0 1 RG
+  10 10 180 180 re B
+endstream
+endobj
+xref
+0 5
+0000000000 65535 f
+0000000021 00000 n
+0000000113 00000 n
+0000000165 00000 n
+0000000261 00000 n
+trailer
+<</Root 1 0 R/Size 5/ID[<18D6B641245C03F28E67D93AD879D6EC><18D6B641245C03F28E67D93AD879D6EC>]>>
+startxref
+371
+%%EOF

data/lib/rouge/demos/thrift

@@ -0,0 +1,15 @@
+namespace * tutorial
+
+include "shared.thrift"
+
+struct Work {
+  1: i32 num1 = 0,
+  2: i32 num2,
+  3: Operation op,
+  4: optional string comment,
+}
+
+service Calculator extends shared.SharedService {
+  i32 add(1: i32 num1, 2: i32 num2),
+  oneway void zip()
+}

data/lib/rouge/demos/veryl

@@ -0,0 +1,24 @@
+/// Module A
+module ModuleA #(
+    param ParamA: u32 = 10,
+) (
+    i_clk : input  clock            ,
+    i_rst : input  reset            ,
+    i_sel : input  logic            ,
+    i_data: input  logic<ParamA> [2],
+    o_data: output logic<ParamA>    ,
+) {
+    var r_data: logic<ParamA>;
+
+    always_ff {
+        if_reset {
+            r_data = 0;
+        } else if i_sel {
+            r_data = i_data[0];
+        } else {
+            r_data = i_data[1];
+        }
+    }
+
+    assign o_data = r_data;
+}

data/lib/rouge/eager.rb

@@ -0,0 +1,3 @@
+require_relative "../rouge"
+
+Rouge.eager_load!

data/lib/rouge/formatters/html.rb

@@ -9,9 +9,16 @@ module Rouge
         '&' => '&',
         '<' => '&lt;',
         '>' => '&gt;',
+        "\r" => "",
       }.freeze
 
-      ESCAPE_REGEX = /[&<>]/.freeze
+      ESCAPE_REGEX = /[&<>\r]/.freeze
+
+      def self.assert_html_formatter!(formatter)
+        return formatter if formatter.respond_to?(:span)
+
+        raise ArgumentError.new("Expected an instance of Rouge::Formatters::HTML, got #{formatter.class}. Try HTML, HTMLDebug, or HTMLInline.")
+      end
 
       tag 'html'
 

data/lib/rouge/formatters/html_debug.rb

@@ -0,0 +1,16 @@
+module Rouge
+  module Formatters
+    class HTMLDebug < HTML
+      tag 'html_debug'
+
+      def safe_span(tok, safe_val)
+        safer_val = safe_val.gsub('"', '&quot;')
+
+        title = "#{tok.qualname}(#{safer_val})"
+        shortname = tok.shortname
+
+        %(<span title="#{title}" class="#{shortname}">#{safe_val}</span>)
+      end
+    end
+  end
+end

data/lib/rouge/formatters/html_legacy.rb

@@ -1,6 +1,11 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+# [jneen] This is an example implementation only. You may use it as-is, but please do
+# not submit patches that alter the behaviour or options of this formatter for the
+# convenience of your application. You are highly encouraged to write your own
+# formatter for your application instead.
+
 module Rouge
   module Formatters
     # Transforms a token stream into HTML output.
@@ -22,6 +27,7 @@ module Rouge
       # Content will be wrapped in a tag (`div` if tableized, `pre` if
       # not) with the given `:css_class` unless `:wrap` is set to `false`.
       def initialize(opts={})
+        warn '[DEPRECATED] Rouge::Formatters::HTMLLegacy is deprecated and will be removed soon. Please use one of the other formatters, or write your own.'
         @formatter = opts[:inline_theme] ? HTMLInline.new(opts[:inline_theme])
                    : HTML.new
 
@@ -29,13 +35,21 @@ module Rouge
         @formatter = HTMLTable.new(@formatter, opts) if opts[:line_numbers]
 
         if opts.fetch(:wrap, true)
-          @formatter = HTMLPygments.new(@formatter, opts.fetch(:css_class, 'codehilite'))
+          @pygments_wrap = opts.fetch(:css_class, 'codehilite')
         end
       end
 
       # @yield the html output.
       def stream(tokens, &b)
+        if @pygments_wrap
+          yield %(<div class="highlight"><pre class="#{@pygments_wrap}"><code>)
+        end
+
         @formatter.stream(tokens, &b)
+
+        if @pygments_wrap
+          yield "</code></pre></div>"
+        end
       end
     end
   end

data/lib/rouge/formatters/html_legacy_table.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# [jneen] This is an example implementation only. You may use it as-is, but please do
+# not submit patches that alter the behaviour or options of this formatter for the
+# convenience of your application. You are highly encouraged to write your own
+# formatter for your application instead.
+
+module Rouge
+  module Formatters
+    class HTMLLegacyTable < Formatter
+      def initialize(inner, opts={})
+        warn '[DEPRECATED] using a wrapped or line-managed delegator for HTMLTable is deprecated, and will be removed soon. Please use HTML, HTMLInline, or HTMLDebug, or write your own formatter.'
+
+        @inner = inner
+        @start_line = opts.fetch(:start_line, 1)
+        @line_format = opts.fetch(:line_format, '%i')
+        @table_class = opts.fetch(:table_class, 'rouge-table')
+        @gutter_class = opts.fetch(:gutter_class, 'rouge-gutter')
+        @code_class = opts.fetch(:code_class, 'rouge-code')
+      end
+
+      def style(scope)
+        yield "#{scope} .#{@table_class} { border-spacing: 0 }"
+        yield "#{scope} .#{@gutter_class} { text-align: right }"
+      end
+
+      def stream(tokens, &b)
+        last_val = nil
+        num_lines = tokens.reduce(0) {|count, (_, val)| count + (last_val = val).count("\n") }
+        formatted = @inner.format(tokens)
+
+        unless last_val && last_val.end_with?("\n")
+          num_lines += 1
+          formatted << "\n" unless formatted.end_with?("\n")
+        end
+
+        # generate a string of newline-separated line numbers for the gutter
+        formatted_line_numbers = (@start_line..(@start_line + num_lines - 1)).map do |i|
+          sprintf(@line_format, i)
+        end.join("\n") << "\n"
+
+        buffer = [%(<table class="#@table_class"><tbody><tr>)]
+        # the "gl" class applies the style for Generic.Lineno
+        buffer << %(<td class="#@gutter_class gl" aria-hidden="true">)
+        buffer << %(<pre class="lineno">#{formatted_line_numbers}</pre>)
+        buffer << '</td>'
+        buffer << %(<td class="#@code_class"><pre><code>)
+        buffer << formatted
+        buffer << '</code></pre></td>'
+        buffer << '</tr></tbody></table>'
+
+        yield buffer.join
+      end
+    end
+  end
+end

data/lib/rouge/formatters/html_line_highlighter.rb

@@ -1,22 +1,29 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+# [jneen] This is an example implementation only. You may use it as-is, but please do
+# not submit patches that alter the behaviour or options of this formatter for the
+# convenience of your application. You are highly encouraged to write your own
+# formatter for your application instead.
+
 module Rouge
   module Formatters
     class HTMLLineHighlighter < Formatter
       tag 'html_line_highlighter'
 
       def initialize(delegate, opts = {})
-        @delegate = delegate
+        @delegate = HTML.assert_html_formatter!(delegate)
         @highlight_line_class = opts.fetch(:highlight_line_class, 'hll')
         @highlight_lines = opts[:highlight_lines] || []
       end
 
       def stream(tokens)
         token_lines(tokens).with_index(1) do |line_tokens, lineno|
-          line = %(#{@delegate.format(line_tokens)}\n)
-          line = %(<span class="#{@highlight_line_class}">#{line}</span>) if @highlight_lines.include? lineno
-          yield line
+          should_highlight = @highlight_lines.include?(lineno)
+          yield %(<span class=#{@highlight_line_class.inspect}>) if should_highlight
+          line_tokens.each { |tok, val| yield @delegate.span(tok, val) }
+          yield "\n"
+          yield %(</span>) if should_highlight
         end
       end
     end

data/lib/rouge/formatters/html_line_table.rb

@@ -1,6 +1,11 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+# [jneen] This is an example implementation only. You may use it as-is, but please do
+# not submit patches that alter the behaviour or options of this formatter for the
+# convenience of your application. You are highly encouraged to write your own
+# formatter for your application instead.
+
 module Rouge
   module Formatters
     class HTMLLineTable < Formatter
@@ -22,7 +27,7 @@ module Rouge
       # @option opts [String] :code_class Class name for rendered code cell.
       #   Defaults to `"rouge-code"`.
       def initialize(formatter, opts={})
-        @formatter    = formatter
+        @formatter    = HTML.assert_html_formatter!(formatter)
         @start_line   = opts.fetch :start_line,   1
         @table_class  = opts.fetch :table_class,  'rouge-line-table'
         @gutter_class = opts.fetch :gutter_class, 'rouge-gutter'
@@ -39,9 +44,9 @@ module Rouge
           buffer << %(style="-moz-user-select: none;-ms-user-select: none;)
           buffer << %(-webkit-user-select: none;user-select: none;">)
           buffer << %(<pre>#{lineno}</pre></td>)
-          buffer << %(<td class="#@code_class"><pre>)
+          buffer << %(<td class="#@code_class"><pre><code>)
           @formatter.stream(line_tokens) { |formatted| buffer << formatted }
-          buffer << "\n</pre></td></tr>"
+          buffer << "\n</code></pre></td></tr>"
         end
         buffer << %(</tbody></table>)
         yield buffer.join

data/lib/rouge/formatters/html_linewise.rb

@@ -1,11 +1,18 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+# [jneen] This is an example implementation only. You may use it as-is, but please do
+# not submit patches that alter the behaviour or options of this formatter for the
+# convenience of your application. You are highly encouraged to write your own
+# formatter for your application instead.
+
 module Rouge
   module Formatters
     class HTMLLinewise < Formatter
+      tag 'html_linewise'
+
       def initialize(formatter, opts={})
-        @formatter = formatter
+        @formatter = HTML.assert_html_formatter!(formatter)
         @tag_name = opts.fetch(:tag_name, 'div')
         @class_format = opts.fetch(:class, 'line-%i')
       end
@@ -13,7 +20,9 @@ module Rouge
       def stream(tokens, &b)
         token_lines(tokens).with_index(1) do |line_tokens, lineno|
           yield %(<#{@tag_name} class="#{sprintf @class_format, lineno}">)
-          @formatter.stream(line_tokens) {|formatted| yield formatted }
+          line_tokens.each do |tok, val|
+            yield @formatter.span(tok, val)
+          end
           yield %(\n</#{@tag_name}>)
         end
       end

data/lib/rouge/formatters/html_pygments.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
+# [jneen] This is an example implementation only. You may use it as-is, but please do
+# not submit patches that alter the behaviour or options of this formatter for the
+# convenience of your application. You are highly encouraged to write your own
+# formatter for your application instead.
+
 module Rouge
   module Formatters
     class HTMLPygments < Formatter
       def initialize(inner, css_class='codehilite')
-        @inner = inner
+        @inner = HTML.assert_html_formatter!(inner)
         @css_class = css_class
       end
 

data/lib/rouge/formatters/html_table.rb

@@ -1,13 +1,27 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+# [jneen] This is an example implementation only. You may use it as-is, but please do
+# not submit patches that alter the behaviour or options of this formatter for the
+# convenience of your application. You are highly encouraged to write your own
+# formatter for your application instead.
+
 module Rouge
   module Formatters
     class HTMLTable < Formatter
       tag 'html_table'
 
+      def self.new(inner, opts={})
+        if !inner.is_a?(HTML) && inner.is_a?(Formatter)
+          require_relative 'html_legacy_table'
+          return HTMLLegacyTable.new(inner, opts)
+        end
+
+        super(inner, opts)
+      end
+
       def initialize(inner, opts={})
-        @inner = inner
+        @inner = HTML.assert_html_formatter!(inner)
         @start_line = opts.fetch(:start_line, 1)
         @line_format = opts.fetch(:line_format, '%i')
         @table_class = opts.fetch(:table_class, 'rouge-table')
@@ -16,35 +30,47 @@ module Rouge
       end
 
       def style(scope)
-        yield %(#{scope} .rouge-table { border-spacing: 0 })
-        yield %(#{scope} .rouge-gutter { text-align: right })
+        yield "#{scope} .#{@table_class} { border-spacing: 0 }"
+        yield "#{scope} .#{@gutter_class} { text-align: right }"
       end
 
       def stream(tokens, &b)
-        last_val = nil
-        num_lines = tokens.reduce(0) {|count, (_, val)| count + (last_val = val).count(?\n) }
-        formatted = @inner.format(tokens)
-        unless last_val && last_val.end_with?(?\n)
+        num_lines = 0
+        last_val = ''
+        formatted = String.new('')
+
+        tokens.each do |tok, val|
+          last_val = val
+          num_lines += val.scan(/\n/).size
+          formatted << @inner.span(tok, val)
+        end
+
+        # add an extra line for non-newline-terminated strings
+        if last_val[-1] != "\n"
           num_lines += 1
-          formatted << ?\n
+          yield @inner.span(Token::Tokens::Text::Whitespace, "\n")
         end
 
         # generate a string of newline-separated line numbers for the gutter>
-        formatted_line_numbers = (@start_line..(@start_line + num_lines - 1)).map do |i|
-          sprintf(@line_format, i)
-        end.join(?\n) << ?\n
+        last_line = num_lines + @start_line
+        formatted_line_numbers = (@start_line...last_line).map do |i|
+          sprintf("#{@line_format}", i) << "\n"
+        end.join('')
+
+        numbers = %(<pre class="lineno">#{formatted_line_numbers}</pre>)
+
+        yield %(<table class="#@table_class"><tbody><tr>)
 
-        buffer = [%(<table class="#@table_class"><tbody><tr>)]
         # the "gl" class applies the style for Generic.Lineno
-        buffer << %(<td class="#@gutter_class gl">)
-        buffer << %(<pre class="lineno">#{formatted_line_numbers}</pre>)
-        buffer << '</td>'
-        buffer << %(<td class="#@code_class"><pre>)
-        buffer << formatted
-        buffer << '</pre></td>'
-        buffer << '</tr></tbody></table>'
-
-        yield buffer.join
+        yield %(<td class="#@gutter_class gl" aria-hidden="true">)
+        yield numbers
+        yield '</td>'
+
+        yield %(<td class="#@code_class"><pre>)
+        yield formatted
+        yield '</pre></td>'
+
+        yield "</tr></tbody></table>"
       end
     end
   end

data/lib/rouge/formatters/terminal256.rb

@@ -7,6 +7,9 @@ module Rouge
     class Terminal256 < Formatter
       tag 'terminal256'
 
+      # max distance between two colors, #000000 to #ffffff
+      MAX_DISTANCE = 257 * 257 * 3
+
       # @private
       attr_reader :theme
 
@@ -138,9 +141,6 @@ module Rouge
           hexes.map { |h| h.to_i(16) }
         end
 
-        # max distance between two colors, #000000 to #ffffff
-        MAX_DISTANCE = 257 * 257 * 3
-
         def self.closest_color(r, g, b)
           @@colors_cache ||= {}
           key = (r << 16) + (g << 8) + b

data/lib/rouge/formatters/tex.rb

@@ -28,7 +28,7 @@ module Rouge
         "\t" => '{\tab}',
       }
 
-      ESCAPE_REGEX = /[#{ESCAPE.keys.map(&Regexp.method(:escape)).join}]/om
+      ESCAPE_REGEX = /[#{ESCAPE.keys.map { |k| Regexp.escape(k) }.join}]/om
 
       def initialize(opts={})
         @prefix = opts.fetch(:prefix) { 'RG' }

data/lib/rouge/guesser.rb

@@ -35,7 +35,7 @@ module Rouge
       best_score = opts[:threshold]
 
       lexers.each do |lexer|
-        score = scorer.call(lexer)
+        score = yield(lexer)
 
         next if score.nil?