rouge 1.11.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0efe4d1a5c6a98c1b4a532ef1b703ee60ceb6a1c
-  data.tar.gz: 6fa2c0ac804354f3e058137869ab151b922c0864
+  metadata.gz: 53466ea8c28e8eaf9a27a2a850c2873033c8757b
+  data.tar.gz: ca08661ff885b0261350f79494eb0f80e41c0dd2
 SHA512:
-  metadata.gz: ab710b89b387ac5675cd31467023eff9600fd7131b51966fe72394569e1ec9f92f3bb70b8448a51e11de12bd83b9217b2b364d120ec5faa4e2a46626371d591d
-  data.tar.gz: 902c5c1d3c88a160b8e140b6f8140a53627e10334ba3e4b628c44da1c057406cc374e3e21f8cbb6b74cba04bcd5e58c54cc6714fa8fe83484ae2d0d47f73fbcd
+  metadata.gz: 15aca0cf78e5b401fd871359748dbb49a5e61e6b476ad9918515e4ac07546659e3586e6a63f8023d4b9429591c72ce67983c4746e65473f3372ba64d3adfd6df
+  data.tar.gz: 683aa07c60241f925b0e90a5a6a881962b59bebebe4db6195fbf94ce7ebc687c48e2cb02c2cd26b46a4a2db59ece1128cda9c6fb48a370dddb2455abf4c64651

data/lib/rouge.rb

@@ -54,6 +54,11 @@ end
 
 load load_dir.join('rouge/formatter.rb')
 load load_dir.join('rouge/formatters/html.rb')
+load load_dir.join('rouge/formatters/html_table.rb')
+load load_dir.join('rouge/formatters/html_pygments.rb')
+load load_dir.join('rouge/formatters/html_legacy.rb')
+load load_dir.join('rouge/formatters/html_linewise.rb')
+load load_dir.join('rouge/formatters/html_inline.rb')
 load load_dir.join('rouge/formatters/terminal256.rb')
 load load_dir.join('rouge/formatters/null.rb')
 

data/lib/rouge/cli.rb

@@ -181,6 +181,8 @@ module Rouge
       def self.parse(argv)
         opts = {
           :formatter => 'terminal256',
+          :theme => 'thankful_eyes',
+          :css_class => 'codehilite',
           :input_file => '-',
           :lexer_opts => {},
           :formatter_opts => {},
@@ -195,12 +197,14 @@ module Rouge
             opts[:mimetype] = argv.shift
           when '--lexer', '-l'
             opts[:lexer] = argv.shift
-          when '--formatter', '-f'
+          when '--formatter-preset', '-f'
             opts[:formatter] = argv.shift
+          when '--theme', '-t'
+            opts[:theme] = argv.shift
+          when '--css-class', '-c'
+            opts[:css_class] = argv.shift
           when '--lexer-opts', '-L'
             opts[:lexer_opts] = parse_cgi(argv.shift)
-          when '--formatter-opts', '-F'
-            opts[:formatter_opts] = parse_cgi(argv.shift)
           when /^--/
             error! "unknown option #{arg.inspect}"
           else
@@ -246,10 +250,17 @@ module Rouge
 
         @lexer_opts = opts[:lexer_opts]
 
-        formatter_class = Formatter.find(opts[:formatter]) \
-          or error! "unknown formatter #{opts[:formatter]}"
+        theme = Theme.find(opts[:theme]).new or error! "unknown theme #{opts[:theme]}"
 
-        @formatter = formatter_class.new(opts[:formatter_opts])
+        @formatter = case opts[:formatter]
+        when 'terminal256' then Formatters::Terminal256.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)
+        when 'html-table' then Formatters::HTMLTable.new(Formatters::HTML.new)
+        else
+          error! "unknown formatter preset #{opts[:formatter]}"
+        end
       end
 
       def run

data/lib/rouge/formatter.rb

@@ -25,6 +25,10 @@ module Rouge
       new(opts).format(tokens, &b)
     end
 
+    def initialize(opts={})
+      # pass
+    end
+
     # Format a token stream.
     def format(tokens, &b)
       return stream(tokens, &b) if block_given?
@@ -46,5 +50,26 @@ module Rouge
     def stream(tokens, &b)
       raise 'abstract'
     end
+
+  protected
+    def token_lines(tokens, &b)
+      return enum_for(:lines, tokens) unless block_given?
+
+      out = []
+      tokens.each do |tok, val|
+        val.scan /\n|[^\n]+/ do |s|
+          if s == "\n"
+            yield out
+            out = []
+          else
+            out << [tok, s]
+          end
+        end
+      end
+
+      # for inputs not ending in a newline
+      yield out if out.any?
+    end
+
   end
 end

data/lib/rouge/formatters/html.rb

@@ -9,109 +9,32 @@ module Rouge
     class HTML < Formatter
       tag 'html'
 
-      # @option opts [String] :css_class ('highlight')
-      # @option opts [true/false] :line_numbers (false)
-      # @option opts [Rouge::CSSTheme] :inline_theme (nil)
-      # @option opts [true/false] :wrap (true)
-      #
-      # Initialize with options.
-      #
-      # If `:inline_theme` is given, then instead of rendering the
-      # tokens as <span> tags with CSS classes, the styles according to
-      # the given theme will be inlined in "style" attributes.  This is
-      # useful for formats in which stylesheets are not available.
-      #
-      # 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={})
-        @css_class = opts.fetch(:css_class, 'highlight')
-        @css_class = " class=#{@css_class.inspect}" if @css_class
-
-        @line_numbers = opts.fetch(:line_numbers, false)
-        @start_line = opts.fetch(:start_line, 1)
-        @inline_theme = opts.fetch(:inline_theme, nil)
-        @inline_theme = Theme.find(@inline_theme).new if @inline_theme.is_a? String
-
-        @wrap = opts.fetch(:wrap, true)
-      end
-
       # @yield the html output.
       def stream(tokens, &b)
-        if @line_numbers
-          stream_tableized(tokens, &b)
-        else
-          stream_untableized(tokens, &b)
-        end
+        tokens.each { |tok, val| yield span(tok, val) }
       end
 
-    private
-      def stream_untableized(tokens, &b)
-        yield "<pre#@css_class><code>" if @wrap
-        tokens.each{ |tok, val| span(tok, val, &b) }
-        yield "</code></pre>\n" if @wrap
+      def span(tok, val)
+        safe_span(tok, val.gsub(/[&<>]/, TABLE_FOR_ESCAPE_HTML))
       end
 
-      def stream_tableized(tokens)
-        num_lines = 0
-        last_val = ''
-        formatted = ''
-
-        tokens.each do |tok, val|
-          last_val = val
-          num_lines += val.scan(/\n/).size
-          span(tok, val) { |str| formatted << str }
-        end
+      def safe_span(tok, safe_val)
+        if tok == Token::Tokens::Text
+          safe_val
+        else
+          shortname = tok.shortname \
+            or raise "unknown token: #{tok.inspect} for #{safe_val.inspect}"
 
-        # add an extra line for non-newline-terminated strings
-        if last_val[-1] != "\n"
-          num_lines += 1
-          span(Token::Tokens::Text::Whitespace, "\n") { |str| formatted << str }
+          "<span class=\"#{shortname}\">#{safe_val}</span>"
         end
-
-        # generate a string of newline-separated line numbers for the gutter>
-        numbers = %<<pre class="lineno">#{(@start_line..num_lines+@start_line-1)
-          .to_a.join("\n")}</pre>>
-
-        yield "<div#@css_class>" if @wrap
-        yield '<table style="border-spacing: 0"><tbody><tr>'
-
-        # the "gl" class applies the style for Generic.Lineno
-        yield '<td class="gutter gl" style="text-align: right">'
-        yield numbers
-        yield '</td>'
-
-        yield '<td class="code">'
-        yield '<pre>'
-        yield formatted
-        yield '</pre>'
-        yield '</td>'
-
-        yield "</tr></tbody></table>\n"
-        yield "</div>\n" if @wrap
       end
 
+    private
       TABLE_FOR_ESCAPE_HTML = {
         '&' => '&amp;',
         '<' => '&lt;',
         '>' => '&gt;',
       }
-
-      def span(tok, val)
-        val = val.gsub(/[&<>]/, TABLE_FOR_ESCAPE_HTML)
-        shortname = tok.shortname or raise "unknown token: #{tok.inspect} for #{val.inspect}"
-
-        if shortname.empty?
-          yield val
-        else
-          if @inline_theme
-            rules = @inline_theme.style_for(tok).rendered_rules
-
-            yield "<span style=\"#{rules.to_a.join(';')}\">#{val}</span>"
-          else
-            yield "<span class=\"#{shortname}\">#{val}</span>"
-          end
-        end
-      end
     end
   end
 end

data/lib/rouge/formatters/html_inline.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Formatters
+    class HTMLInline < HTML
+      tag 'html_inline'
+
+      def initialize(theme)
+        @theme = theme
+      end
+
+      def safe_span(tok, safe_val)
+        return safe_val if tok == Token::Tokens::Text
+
+        rules = @theme.style_for(tok).rendered_rules
+
+        "<span style=\"#{rules.to_a.join(';')}\">#{safe_val}</span>"
+      end
+    end
+  end
+end
+

data/lib/rouge/formatters/html_legacy.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*- #
+
+# stdlib
+require 'cgi'
+
+module Rouge
+  module Formatters
+    # Transforms a token stream into HTML output.
+    class HTMLLegacy < Formatter
+      tag 'html_legacy'
+
+      # @option opts [String] :css_class ('highlight')
+      # @option opts [true/false] :line_numbers (false)
+      # @option opts [Rouge::CSSTheme] :inline_theme (nil)
+      # @option opts [true/false] :wrap (true)
+      #
+      # Initialize with options.
+      #
+      # If `:inline_theme` is given, then instead of rendering the
+      # tokens as <span> tags with CSS classes, the styles according to
+      # the given theme will be inlined in "style" attributes.  This is
+      # useful for formats in which stylesheets are not available.
+      #
+      # 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={})
+        @formatter = opts[:inline_theme] ? HTMLInline.new(opts[:inline_theme])
+                   : HTML.new
+
+
+        @formatter = HTMLTable.new(@formatter, opts) if opts[:line_numbers]
+
+        if opts.fetch(:wrap, true)
+          @formatter = HTMLPygments.new(@formatter, opts.fetch(:css_class, 'codehilite'))
+        end
+      end
+
+      # @yield the html output.
+      def stream(tokens, &b)
+        @formatter.stream(tokens, &b)
+      end
+    end
+  end
+end

data/lib/rouge/formatters/html_linewise.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Formatters
+    class HTMLLinewise < Formatter
+      def initialize(formatter, opts={})
+        @formatter = formatter
+        @class_format = opts.fetch(:class, 'line-%i')
+      end
+
+      def stream(tokens, &b)
+        token_lines(tokens) do |line|
+          yield "<div class=#{next_line_class}>"
+          line.each do |tok, val|
+            yield @formatter.span(tok, val)
+          end
+          yield '</div>'
+        end
+      end
+
+      def next_line_class
+        @lineno ||= 0
+        sprintf(@class_format, @lineno += 1).inspect
+      end
+    end
+  end
+end

data/lib/rouge/formatters/html_pygments.rb

@@ -0,0 +1,16 @@
+module Rouge
+  module Formatters
+    class HTMLPygments < Formatter
+      def initialize(inner, css_class='codehilite')
+        @inner = inner
+        @css_class = css_class
+      end
+
+      def stream(tokens, &b)
+        yield %<<pre class="#@css_class"><code>>
+        @inner.stream(tokens, &b)
+        yield "</code></pre>"
+      end
+    end
+  end
+end

data/lib/rouge/formatters/html_table.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Formatters
+    class HTMLTable < Formatter
+      tag 'html_table'
+
+      def initialize(inner, opts={})
+        @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} .rouge-table { border-spacing: 0 }"
+        yield "#{scope} .rouge-gutter { text-align: right }"
+      end
+
+      def stream(tokens, &b)
+        num_lines = 0
+        last_val = ''
+        formatted = ''
+
+        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
+          @inner.span(Token::Tokens::Text::Whitespace, "\n") { |str| formatted << str }
+        end
+
+        # generate a string of newline-separated line numbers for the gutter>
+        formatted_line_numbers = (@start_line..num_lines+@start_line-1).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>>
+
+        # the "gl" class applies the style for Generic.Lineno
+        yield %<<td class="#@gutter_class gl">>
+        yield numbers
+        yield '</td>'
+
+        yield %<<td class="#@code_class"><pre>>
+        yield formatted
+        yield '</pre></td>'
+
+        yield "</tr></tbody></table>\n"
+      end
+    end
+  end
+end

data/lib/rouge/formatters/terminal256.rb

@@ -4,17 +4,13 @@ module Rouge
   module Formatters
     # A formatter for 256-color terminals
     class Terminal256 < Formatter
-      tag 'terminal256'
-
       # @private
       attr_reader :theme
 
-
-      # @option opts :theme
-      #   (default is thankful_eyes) the theme to render with.
-      def initialize(opts={})
-        @theme = opts[:theme] || 'thankful_eyes'
-        @theme = Theme.find(@theme) if @theme.is_a? String
+      # @argument theme
+      #   the theme to render with.
+      def initialize(theme=nil)
+        @theme = theme || Themes::ThankfulEyes
       end
 
       def stream(tokens, &b)

data/lib/rouge/plugins/redcarpet.rb

@@ -23,7 +23,7 @@ module Rouge
 
       # override this method for custom formatting behavior
       def rouge_formatter(lexer)
-        Formatters::HTML.new(:css_class => "highlight #{lexer.tag}")
+        Formatters::HTMLLegacy.new(:css_class => "highlight #{lexer.tag}")
       end
     end
   end

data/lib/rouge/version.rb

@@ -2,6 +2,6 @@
 
 module Rouge
   def self.version
-    "1.11.1"
+    "2.0.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 1.11.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Jeanine Adkisson
@@ -126,6 +126,11 @@ files:
 - lib/rouge/demos/yaml
 - lib/rouge/formatter.rb
 - lib/rouge/formatters/html.rb
+- lib/rouge/formatters/html_inline.rb
+- lib/rouge/formatters/html_legacy.rb
+- lib/rouge/formatters/html_linewise.rb
+- lib/rouge/formatters/html_pygments.rb
+- lib/rouge/formatters/html_table.rb
 - lib/rouge/formatters/null.rb
 - lib/rouge/formatters/terminal256.rb
 - lib/rouge/guesser.rb