rouge 3.0.0 → 3.18.0

data/lib/rouge/plugins/redcarpet.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 # this file is not require'd from the root.  To use this plugin, run:
 #
@@ -8,13 +9,19 @@ module Rouge
   module Plugins
     module Redcarpet
       def block_code(code, language)
-        lexer = Lexer.find_fancy(language, code) || Lexers::PlainText
+        lexer =
+          begin
+            Lexer.find_fancy(language, code)
+          rescue Guesser::Ambiguous => e
+            e.alternatives.first
+          end
+        lexer ||= Lexers::PlainText
 
         # XXX HACK: Redcarpet strips hard tabs out of code blocks,
         # so we assume you're not using leading spaces that aren't tabs,
         # and just replace them here.
         if lexer.tag == 'make'
-          code.gsub! /^    /, "\t"
+          code.gsub! %r/^    /, "\t"
         end
 
         formatter = rouge_formatter(lexer)

data/lib/rouge/regex_lexer.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   # @abstract
@@ -101,21 +102,21 @@ module Rouge
         callback ||= case next_state
         when :pop!
           proc do |stream|
-            puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
+            puts "    yielding: #{tok.qualname}, #{stream[0].inspect}" if @debug
             @output_stream.call(tok, stream[0])
             puts "    popping stack: 1" if @debug
             @stack.pop or raise 'empty stack!'
           end
         when :push
           proc do |stream|
-            puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
+            puts "    yielding: #{tok.qualname}, #{stream[0].inspect}" if @debug
             @output_stream.call(tok, stream[0])
             puts "    pushing :#{@stack.last.name}" if @debug
             @stack.push(@stack.last)
           end
         when Symbol
           proc do |stream|
-            puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
+            puts "    yielding: #{tok.qualname}, #{stream[0].inspect}" if @debug
             @output_stream.call(tok, stream[0])
             state = @states[next_state] || self.class.get_state(next_state)
             puts "    pushing :#{state.name}" if @debug
@@ -123,7 +124,7 @@ module Rouge
           end
         when nil
           proc do |stream|
-            puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
+            puts "    yielding: #{tok.qualname}, #{stream[0].inspect}" if @debug
             @output_stream.call(tok, stream[0])
           end
         else
@@ -182,18 +183,18 @@ module Rouge
     # Define a new state for this lexer with the given name.
     # The block will be evaluated in the context of a {StateDSL}.
     def self.state(name, &b)
-      name = name.to_s
+      name = name.to_sym
       state_definitions[name] = StateDSL.new(name, &b)
     end
 
     def self.prepend(name, &b)
-      name = name.to_s
+      name = name.to_sym
       dsl = state_definitions[name] or raise "no such state #{name.inspect}"
       replace_state(name, dsl.prepended(&b))
     end
 
     def self.append(name, &b)
-      name = name.to_s
+      name = name.to_sym
       dsl = state_definitions[name] or raise "no such state #{name.inspect}"
       replace_state(name, dsl.appended(&b))
     end
@@ -203,7 +204,7 @@ module Rouge
       return name if name.is_a? State
 
       states[name.to_sym] ||= begin
-        defn = state_definitions[name.to_s] or raise "unknown state: #{name.inspect}"
+        defn = state_definitions[name.to_sym] or raise "unknown state: #{name.inspect}"
         defn.to_state(self)
       end
     end
@@ -262,6 +263,7 @@ module Rouge
 
       until stream.eos?
         if @debug
+          puts
           puts "lexer: #{self.class.tag}"
           puts "stack: #{stack.map(&:name).map(&:to_sym).inspect}"
           puts "stream: #{stream.peek(20).inspect}"
@@ -288,11 +290,11 @@ module Rouge
     def step(state, stream)
       state.rules.each do |rule|
         if rule.is_a?(State)
-          puts "  entering mixin #{rule.name}" if @debug
+          puts "  entering: mixin :#{rule.name}" if @debug
           return true if step(rule, stream)
-          puts "  exiting  mixin #{rule.name}" if @debug
+          puts "  exiting: mixin :#{rule.name}" if @debug
         else
-          puts "  trying #{rule.inspect}" if @debug
+          puts "  trying: #{rule.inspect}" if @debug
 
           # XXX HACK XXX
           # StringScanner's implementation of ^ is b0rken.
@@ -302,14 +304,14 @@ module Rouge
           next if rule.beginning_of_line && !stream.beginning_of_line?
 
           if (size = stream.skip(rule.re))
-            puts "    got #{stream[0].inspect}" if @debug
+            puts "    got: #{stream[0].inspect}" if @debug
 
             instance_exec(stream, &rule.callback)
 
             if size.zero?
               @null_steps += 1
               if @null_steps > MAX_NULL_SCANS
-                puts "    too many scans without consuming the string!" if @debug
+                puts "    warning: too many scans without consuming the string!" if @debug
                 return false
               end
             else
@@ -351,20 +353,20 @@ module Rouge
       end
     end
 
-    # Delegate the lex to another lexer.  The #lex method will be called
-    # with `:continue` set to true, so that #reset! will not be called.
-    # In this way, a single lexer can be repeatedly delegated to while
-    # maintaining its own internal state stack.
+    # Delegate the lex to another lexer. We use the `continue_lex` method
+    # so that #reset! will not be called.  In this way, a single lexer
+    # can be repeatedly delegated to while maintaining its own internal
+    # state stack.
     #
     # @param [#lex] lexer
     #   The lexer or lexer class to delegate to
     # @param [String] text
     #   The text to delegate.  This defaults to the last matched string.
     def delegate(lexer, text=nil)
-      puts "    delegating to #{lexer.inspect}" if @debug
+      puts "    delegating to: #{lexer.inspect}" if @debug
       text ||= @current_stream[0]
 
-      lexer.lex(text, :continue => true) do |tok, val|
+      lexer.continue_lex(text) do |tok, val|
         puts "    delegated token: #{tok.inspect}, #{val.inspect}" if @debug
         yield_token(tok, val)
       end
@@ -387,7 +389,7 @@ module Rouge
         self.state
       end
 
-      puts "    pushing :#{push_state.name}" if @debug
+      puts "    pushing: :#{push_state.name}" if @debug
       stack.push(push_state)
     end
 
@@ -407,7 +409,7 @@ module Rouge
     def goto(state_name)
       raise 'empty stack!' if stack.empty?
 
-      puts "    going to state :#{state_name} " if @debug
+      puts "    going to: state :#{state_name} " if @debug
       stack[-1] = get_state(state_name)
     end
 
@@ -420,21 +422,21 @@ module Rouge
 
     # Check if `state_name` is in the state stack.
     def in_state?(state_name)
-      state_name = state_name.to_s
+      state_name = state_name.to_sym
       stack.any? do |state|
-        state.name == state_name.to_s
+        state.name == state_name.to_sym
       end
     end
 
     # Check if `state_name` is the state on top of the state stack.
     def state?(state_name)
-      state_name.to_s == state.name
+      state_name.to_sym == state.name
     end
 
   private
     def yield_token(tok, val)
       return if val.nil? || val.empty?
-      puts "    yielding #{tok.qualname}, #{val.inspect}" if @debug
+      puts "    yielding: #{tok.qualname}, #{val.inspect}" if @debug
       @output_stream.yield(tok, val)
     end
   end

data/lib/rouge/template_lexer.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   # @abstract

data/lib/rouge/tex_theme_renderer.rb

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  class TexThemeRenderer
+    def initialize(theme, opts={})
+      @theme = theme
+      @prefix = opts.fetch(:prefix) { 'RG' }
+    end
+
+    # Our general strategy is this:
+    #
+    # * First, define the \RG{tokname}{content} command, which will
+    #   expand into \RG@tok@tokname{content}. We use \csname...\endcsname
+    #   to interpolate into a command.
+    #
+    # * Define the default RG* environment, which will enclose the whole
+    #   thing. By default this will simply set \ttfamily (select monospace font)
+    #   but it can be overridden with \renewcommand by the user to be
+    #   any other formatting.
+    #
+    # * Define all the colors using xcolors \definecolor command. First we define
+    #   every palette color with a name such as RG@palette@themneame@colorname.
+    #   Then we find all foreground and background colors that have literal html
+    #   colors embedded in them and define them with names such as
+    #   RG@palette@themename@000000. While html allows three-letter colors such
+    #   as #FFF, xcolor requires all six characters to be present, so we make sure
+    #   to normalize that as well as the case convention in #inline_name.
+    #
+    # * Define the token commands RG@tok@xx. These will take the content as the
+    #   argument and format it according to the theme, referring to the color
+    #   in the palette.
+    def render(&b)
+      yield <<'END'.gsub('RG', @prefix)
+\makeatletter
+\def\RG#1#2{\csname RG@tok@#1\endcsname{#2}}%
+\newenvironment{RG*}{\ttfamily}{\relax}%
+END
+
+      base = @theme.class.base_style
+      yield "\\definecolor{#{@prefix}@fgcolor}{HTML}{#{inline_name(base.fg || '#000000')}}"
+      yield "\\definecolor{#{@prefix}@bgcolor}{HTML}{#{inline_name(base.bg || '#FFFFFF')}}"
+
+      render_palette(@theme.palette, &b)
+
+      @theme.styles.each do |tok, style|
+        render_inline_pallete(style, &b)
+      end
+
+      Token.each_token do |tok|
+        style = @theme.class.get_own_style(tok)
+        style ? render_style(tok, style, &b) : render_blank(tok, &b)
+      end
+      yield '\makeatother'
+    end
+
+    def render_palette(palette, &b)
+      palette.each do |name, color|
+        hex = inline_name(color)
+
+        yield "\\definecolor{#{palette_name(name)}}{HTML}{#{hex}}%"
+      end
+    end
+
+    def render_inline_pallete(style, &b)
+      gen_inline(style[:fg], &b)
+      gen_inline(style[:bg], &b)
+    end
+
+    def inline_name(color)
+      color =~ /^#(\h+)/ or return nil
+
+      # xcolor does not support 3-character HTML colors,
+      # so we convert them here
+      case $1.size
+      when 6
+        $1
+      when 3
+        # duplicate every character: abc -> aabbcc
+        $1.gsub(/\h/, '\0\0')
+      else
+        raise "invalid HTML color: #{$1}"
+      end.upcase
+    end
+
+    def gen_inline(name, &b)
+      # detect inline colors
+      hex = inline_name(name)
+      return unless hex
+
+      @gen_inline ||= {}
+      @gen_inline[hex] ||= begin
+        yield "\\definecolor{#{palette_name(hex)}}{HTML}{#{hex}}%"
+      end
+    end
+
+    def camelize(name)
+      name.gsub(/_(.)/) { $1.upcase }
+    end
+
+    def palette_name(name)
+      name = inline_name(name) || name.to_s
+
+      "#{@prefix}@palette@#{camelize(@theme.name)}@#{camelize(name.to_s)}"
+    end
+
+    def token_name(tok)
+      "\\csname #@prefix@tok@#{tok.shortname}\\endcsname"
+    end
+
+    def render_blank(tok, &b)
+      out = "\\expandafter\\def#{token_name(tok)}#1{#1}"
+    end
+
+    def render_style(tok, style, &b)
+      out = String.new('')
+      out << "\\expandafter\\def#{token_name(tok)}#1{"
+      out << "\\fboxsep=0pt\\colorbox{#{palette_name(style[:bg])}}{" if style[:bg]
+      out << '\\textbf{' if style[:bold]
+      out << '\\textit{' if style[:italic]
+      out << "\\textcolor{#{palette_name(style[:fg])}}{" if style[:fg]
+      out << "#1"
+      # close the right number of curlies
+      out << "}" if style[:bold]
+      out << "}" if style[:italic]
+      out << "}" if style[:fg]
+      out << "}" if style[:bg]
+      out << "}%"
+      yield out
+    end
+  end
+end

data/lib/rouge/text_analyzer.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   class TextAnalyzer < String

data/lib/rouge/theme.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   class Theme
@@ -82,6 +83,10 @@ module Rouge
       self.class.get_style(token)
     end
 
+    def name
+      self.class.name
+    end
+
     class << self
       def style(*tokens)
         style = tokens.last.is_a?(Hash) ? tokens.pop : {}

data/lib/rouge/themes/base16.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Themes

data/lib/rouge/themes/bw.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Themes
+    # A port of the bw style from Pygments.
+    # See https://bitbucket.org/birkenfeld/pygments-main/src/default/pygments/styles/bw.py
+    class BlackWhiteTheme < CSSTheme
+      name 'bw'
+
+      style Text,                        :fg => '#000000', :bg => '#ffffff'
+
+      style Comment,                     :italic => true
+      style Comment::Preproc,            :italic => false
+
+      style Keyword,                     :bold => true
+      style Keyword::Pseudo,             :bold => false
+      style Keyword::Type,               :bold => false
+
+      style Operator,                    :bold => true
+
+      style Name::Class,                 :bold => true
+      style Name::Namespace,             :bold => true
+      style Name::Exception,             :bold => true
+      style Name::Entity,                :bold => true
+      style Name::Tag,                   :bold => true
+
+      style Literal::String,             :italic => true
+      style Literal::String::Interpol,   :bold => true
+      style Literal::String::Escape,     :bold => true
+
+      style Generic::Heading,            :bold => true
+      style Generic::Subheading,         :bold => true
+      style Generic::Emph,               :italic => true
+      style Generic::Strong,             :bold => true
+      style Generic::Prompt,             :bold => true
+
+      style Error,                       :fg => '#FF0000'
+    end
+  end
+end

data/lib/rouge/themes/colorful.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Themes

data/lib/rouge/themes/github.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Themes

data/lib/rouge/themes/gruvbox.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 # TODO how are we going to handle soft/hard contrast?
 

data/lib/rouge/themes/igor_pro.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Themes

data/lib/rouge/themes/magritte.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Themes
+    class Magritte < CSSTheme
+      name 'magritte'
+
+      palette :dragon    => '#006c6c'
+      palette :black     => '#000000'
+      palette :forest    => '#007500'
+      palette :candy     => '#ff0089'
+      palette :wine      => '#7c0000'
+      palette :grape     => '#4c48fe'
+      palette :dark      => '#000707'
+      palette :cherry    => '#f22700'
+      palette :white     => '#ffffff'
+      palette :royal     => '#19003a'
+
+      palette :purple    => '#840084'
+      palette :chocolate => '#920241'
+      palette :lavender  => '#d8d9ff'
+      palette :eggshell  => '#f3ffff'
+      palette :yellow    => '#ffff3f'
+
+      palette :lightgray => '#BBBBBB'
+      palette :darkgray  => '#999999'
+
+      style Text,                         :fg => :dark, :bg => :eggshell
+      style Generic::Lineno,              :fg => :eggshell, :bg => :dark
+
+      # style Generic::Prompt,            :fg => :chilly, :bold => true
+
+      style Comment,                      :fg => :dragon, :italic => true
+      style Comment::Preproc,             :fg => :chocolate, :bold => true
+      style Error,                        :fg => :eggshell, :bg => :cherry
+      style Generic::Error,               :fg => :cherry, :italic => true, :bold => true
+      style Keyword,                      :fg => :royal, :bold => true
+      style Operator,                     :fg => :grape, :bold => true
+      style Punctuation,                  :fg => :grape
+      style Generic::Deleted,             :fg => :cherry
+      style Generic::Inserted,            :fg => :forest
+      style Generic::Emph,                :italic => true
+      style Generic::Strong,              :bold => true
+      style Generic::Traceback,           :fg => :black, :bg => :lavender
+      style Keyword::Constant,            :fg => :forest, :bold => true
+      style Keyword::Namespace,
+            Keyword::Pseudo,
+            Keyword::Reserved,
+            Generic::Heading,
+            Generic::Subheading,          :fg => :forest, :bold => true
+      style Keyword::Type,
+            Name::Constant,
+            Name::Class,
+            Name::Decorator,
+            Name::Namespace,
+            Name::Builtin::Pseudo,
+            Name::Exception,              :fg => :chocolate, :bold => true
+      style Name::Label,
+            Name::Tag,                    :fg => :purple, :bold => true
+      style Literal::Number,
+            Literal::Date,                :fg => :forest, :bold => true
+      style Literal::String::Symbol,      :fg => :forest
+      style Literal::String,              :fg => :wine, :bold => true
+      style Literal::String::Escape,
+            Literal::String::Char,
+            Literal::String::Interpol,    :fg => :purple, :bold => true
+      style Name::Builtin,                :bold => true
+      style Name::Entity,                 :fg => :darkgray, :bold => true
+      style Text::Whitespace,             :fg => :lightgray
+      style Generic::Output,              :fg => :royal
+      style Name::Function,
+            Name::Property,
+            Name::Attribute,              :fg => :candy
+      style Name::Variable,               :fg => :candy, :bold => true
+    end
+  end
+end