rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/xml.rb

@@ -7,14 +7,10 @@ module Rouge
       title "XML"
       desc %q(<desc for="this-lexer">XML</desc>)
       tag 'xml'
-      filenames *%w(*.xml *.xsl *.rss *.xslt *.xsd *.wsdl *.svg *.plist)
-      mimetypes *%w(
-        text/xml
-        application/xml
-        image/svg+xml
-        application/rss+xml
-        application/atom+xml
-      )
+      filenames '*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl', '*.svg',
+                '*.plist'
+      mimetypes 'text/xml', 'application/xml', 'image/svg+xml', 
+                'application/rss+xml', 'application/atom+xml'
 
       def self.detect?(text)
         return false if text.doctype?(/html/)
@@ -23,12 +19,12 @@ module Rouge
       end
 
       state :root do
-        rule /[^<&]+/, Text
-        rule /&\S*?;/, Name::Entity
-        rule /<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
-        rule /<!--/, Comment, :comment
-        rule /<\?.*?\?>/, Comment::Preproc
-        rule /<![^>]*>/, Comment::Preproc
+        rule %r/[^<&]+/, Text
+        rule %r/&\S*?;/, Name::Entity
+        rule %r/<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
+        rule %r/<!--/, Comment, :comment
+        rule %r/<\?.*?\?>/, Comment::Preproc
+        rule %r/<![^>]*>/, Comment::Preproc
 
         # open tags
         rule %r(<\s*[\w:.-]+)m, Name::Tag, :tag
@@ -38,20 +34,20 @@ module Rouge
       end
 
       state :comment do
-        rule /[^-]+/m, Comment
-        rule /-->/, Comment, :pop!
-        rule /-/, Comment
+        rule %r/[^-]+/m, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
       end
 
       state :tag do
-        rule /\s+/m, Text
-        rule /[\w.:-]+\s*=/m, Name::Attribute, :attr
+        rule %r/\s+/m, Text
+        rule %r/[\w.:-]+\s*=/m, Name::Attribute, :attr
         rule %r(/?\s*>), Name::Tag, :pop!
       end
 
       state :attr do
-        rule /\s+/m, Text
-        rule /".*?"|'.*?'|[^\s>]+/m, Str, :pop!
+        rule %r/\s+/m, Text
+        rule %r/".*?"|'.*?'|[^\s>]+/m, Str, :pop!
       end
     end
   end

data/lib/rouge/lexers/xojo.rb

@@ -34,26 +34,26 @@ module Rouge
         )
 
       state :root do
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
 
-        rule /rem\b.*?$/i, Comment::Single
-        rule /\/\/.*$/, Comment::Single
-        rule /\#tag Note.*\#tag EndNote/m, Comment::Preproc
-        rule /\s*[#].*$/x, Comment::Preproc
+        rule %r/rem\b.*?$/i, Comment::Single
+        rule %r(//.*$), Comment::Single
+        rule %r/\#tag Note.*\#tag EndNote/m, Comment::Preproc
+        rule %r/\s*[#].*$/x, Comment::Preproc
 
-        rule /".*?"/, Literal::String::Double
-        rule /[(){}!#,:]/, Punctuation
+        rule %r/".*?"/, Literal::String::Double
+        rule %r/[(){}!#,:]/, Punctuation
 
-        rule /\b(?:#{keywords.join('|')})\b/i, Keyword
-        rule /\b(?:#{keywords_type.join('|')})\b/i, Keyword::Declaration
+        rule %r/\b(?:#{keywords.join('|')})\b/i, Keyword
+        rule %r/\b(?:#{keywords_type.join('|')})\b/i, Keyword::Declaration
 
-        rule /\b(?:#{operator_words.join('|')})\b/i, Operator
-        rule /[+-]?(\d+\.\d*|\d*\.\d+)/i, Literal::Number::Float
-        rule /[+-]?\d+/, Literal::Number::Integer
-        rule /&[CH][0-9a-f]+/i, Literal::Number::Hex
-        rule /&O[0-7]+/i, Literal::Number::Oct
+        rule %r/\b(?:#{operator_words.join('|')})\b/i, Operator
+        rule %r/[+-]?(\d+\.\d*|\d*\.\d+)/i, Literal::Number::Float
+        rule %r/[+-]?\d+/, Literal::Number::Integer
+        rule %r/&[CH][0-9a-f]+/i, Literal::Number::Hex
+        rule %r/&O[0-7]+/i, Literal::Number::Oct
 
-        rule /\b[\w\.]+\b/i, Text
+        rule %r/\b[\w\.]+\b/i, Text
         rule(%r(<=|>=|<>|[=><\+\-\*\/\\]), Operator)
       end
     end

data/lib/rouge/lexers/yaml.rb

@@ -78,38 +78,38 @@ module Rouge
       start { reset_indent }
 
       state :basic do
-        rule /#.*$/, Comment::Single
+        rule %r/#.*$/, Comment::Single
       end
 
       state :root do
         mixin :basic
 
-        rule /\n+/, Text
+        rule %r/\n+/, Text
 
         # trailing or pre-comment whitespace
-        rule /[ ]+(?=#|$)/, Text
+        rule %r/[ ]+(?=#|$)/, Text
 
-        rule /^%YAML\b/ do
+        rule %r/^%YAML\b/ do
           token Name::Tag
           reset_indent
           push :yaml_directive
         end
 
-        rule /^%TAG\b/ do
+        rule %r/^%TAG\b/ do
           token Name::Tag
           reset_indent
           push :tag_directive
         end
 
         # doc-start and doc-end indicators
-        rule /^(?:---|\.\.\.)(?= |$)/ do
+        rule %r/^(?:---|\.\.\.)(?= |$)/ do
           token Name::Namespace
           reset_indent
           push :block_line
         end
 
         # indentation spaces
-        rule /[ ]*(?!\s|$)/ do |m|
+        rule %r/[ ]*(?!\s|$)/ do |m|
           text, err = save_indent(m[0])
           token Text, text
           token Error, err
@@ -120,7 +120,7 @@ module Rouge
       state :indentation do
         rule(/\s*?\n/) { token Text; pop! 2 }
         # whitespace preceding block collection indicators
-        rule /[ ]+(?=[-:?](?:[ ]|$))/ do |m|
+        rule %r/[ ]+(?=[-:?](?:[ ]|$))/ do |m|
           token Text
           continue_indent(m[0])
         end
@@ -138,8 +138,8 @@ module Rouge
       # indented line in the block context
       state :block_line do
         # line end
-        rule /[ ]*(?=#|$)/, Text, :pop!
-        rule /[ ]+/, Text
+        rule %r/[ ]*(?=#|$)/, Text, :pop!
+        rule %r/[ ]+/, Text
         # tags, anchors, and aliases
         mixin :descriptors
         # block collections and scalars
@@ -148,7 +148,7 @@ module Rouge
         mixin :flow_nodes
 
         # a plain scalar
-        rule /(?=#{plain_scalar_start}|[?:-][^ \t\n\r\f\v])/ do
+        rule %r/(?=#{plain_scalar_start}|[?:-][^ \t\n\r\f\v])/ do
           token Name::Variable
           push :plain_scalar_in_block_context
         end
@@ -156,7 +156,7 @@ module Rouge
 
       state :descriptors do
         # a full-form tag
-        rule /!<[0-9A-Za-z;\/?:@&=+$,_.!~*'()\[\]%-]+>/, Keyword::Type
+        rule %r/!<[0-9A-Za-z;\/?:@&=+$,_.!~*'()\[\]%-]+>/, Keyword::Type
 
         # a tag in the form '!', '!suffix' or '!handle!suffix'
         rule %r(
@@ -165,21 +165,21 @@ module Rouge
         )x, Keyword::Type
 
         # an anchor
-        rule /&[\w-]+/, Name::Label
+        rule %r/&[\w-]+/, Name::Label
 
         # an alias
-        rule /\*[\w-]+/, Name::Variable
+        rule %r/\*[\w-]+/, Name::Variable
       end
 
       state :block_nodes do
         # implicit key
-        rule /((?:\w[\w -]*)?)(:)(?=\s|$)/ do |m|
+        rule %r/((?:\w[\w -]*)?)(:)(?=\s|$)/ do |m|
           groups Name::Attribute, Punctuation::Indicator
           set_indent m[0], :implicit => true
         end
 
         # literal and folded scalars
-        rule /[\|>]/ do
+        rule %r/[\|>]/ do
           token Punctuation::Indicator
           push :block_scalar_content
           push :block_scalar_header
@@ -187,39 +187,39 @@ module Rouge
       end
 
       state :flow_nodes do
-        rule /\[/, Punctuation::Indicator, :flow_sequence
-        rule /\{/, Punctuation::Indicator, :flow_mapping
-        rule /'/, Str::Single, :single_quoted_scalar
-        rule /"/, Str::Double, :double_quoted_scalar
+        rule %r/\[/, Punctuation::Indicator, :flow_sequence
+        rule %r/\{/, Punctuation::Indicator, :flow_mapping
+        rule %r/'/, Str::Single, :single_quoted_scalar
+        rule %r/"/, Str::Double, :double_quoted_scalar
       end
 
       state :flow_collection do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         mixin :basic
-        rule /[?:,]/, Punctuation::Indicator
+        rule %r/[?:,]/, Punctuation::Indicator
         mixin :descriptors
         mixin :flow_nodes
 
-        rule /(?=#{plain_scalar_start})/ do
+        rule %r/(?=#{plain_scalar_start})/ do
           push :plain_scalar_in_flow_context
         end
       end
 
       state :flow_sequence do
-        rule /\]/, Punctuation::Indicator, :pop!
+        rule %r/\]/, Punctuation::Indicator, :pop!
         mixin :flow_collection
       end
 
       state :flow_mapping do
-        rule /\}/, Punctuation::Indicator, :pop!
+        rule %r/\}/, Punctuation::Indicator, :pop!
         mixin :flow_collection
       end
 
       state :block_scalar_content do
-        rule /\n+/, Text
+        rule %r/\n+/, Text
 
         # empty lines never dedent, but they might be part of the scalar.
-        rule /^[ ]+$/ do |m|
+        rule %r/^[ ]+$/ do |m|
           text = m[0]
           indent_size = text.size
 
@@ -231,7 +231,7 @@ module Rouge
 
         # TODO: ^ doesn't actually seem to affect the match at all.
         # Find a way to work around this limitation.
-        rule /^[ ]*/ do |m|
+        rule %r/^[ ]*/ do |m|
           token Text
 
           indent_size = m[0].size
@@ -246,7 +246,7 @@ module Rouge
           end
         end
 
-        rule /[^\n\r\f\v]+/, Name::Constant
+        rule %r/[^\n\r\f\v]+/, Name::Constant
       end
 
       state :block_scalar_header do
@@ -271,46 +271,46 @@ module Rouge
 
       state :ignored_line do
         mixin :basic
-        rule /[ ]+/, Text
-        rule /\n/, Text, :pop!
+        rule %r/[ ]+/, Text
+        rule %r/\n/, Text, :pop!
       end
 
       state :quoted_scalar_whitespaces do
         # leading and trailing whitespace is ignored
-        rule /^[ ]+/, Text
-        rule /[ ]+$/, Text
+        rule %r/^[ ]+/, Text
+        rule %r/[ ]+$/, Text
 
-        rule /\n+/m, Text
+        rule %r/\n+/m, Text
 
-        rule /[ ]+/, Name::Variable
+        rule %r/[ ]+/, Name::Variable
       end
 
       state :single_quoted_scalar do
         mixin :quoted_scalar_whitespaces
-        rule /\\'/, Str::Escape
-        rule /'/, Str, :pop!
-        rule /[^\s']+/, Str
+        rule %r/\\'/, Str::Escape
+        rule %r/'/, Str, :pop!
+        rule %r/[^\s']+/, Str
       end
 
       state :double_quoted_scalar do
-        rule /"/, Str, :pop!
+        rule %r/"/, Str, :pop!
         mixin :quoted_scalar_whitespaces
         # escapes
-        rule /\\[0abt\tn\nvfre "\\N_LP]/, Str::Escape
-        rule /\\(?:x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+        rule %r/\\[0abt\tn\nvfre "\\N_LP]/, Str::Escape
+        rule %r/\\(?:x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
           Str::Escape
-        rule /[^ \t\n\r\f\v"\\]+/, Str
+        rule %r/[^ \t\n\r\f\v"\\]+/, Str
       end
 
       state :plain_scalar_in_block_context_new_line do
-        rule /^[ ]+\n/, Text
-        rule /\n+/m, Text
-        rule /^(?=---|\.\.\.)/ do
+        rule %r/^[ ]+\n/, Text
+        rule %r/\n+/m, Text
+        rule %r/^(?=---|\.\.\.)/ do
           pop! 3
         end
 
         # dedent detection
-        rule /^[ ]*/ do |m|
+        rule %r/^[ ]*/ do |m|
           token Text
           pop!
 
@@ -327,34 +327,34 @@ module Rouge
 
       state :plain_scalar_in_block_context do
         # the : indicator ends a scalar
-        rule /[ ]*(?=:[ \n]|:$)/, Text, :pop!
-        rule /[ ]*:/, Str
-        rule /[ ]+(?=#)/, Text, :pop!
-        rule /[ ]+$/, Text
+        rule %r/[ ]*(?=:[ \n]|:$)/, Text, :pop!
+        rule %r/[ ]*:/, Str
+        rule %r/[ ]+(?=#)/, Text, :pop!
+        rule %r/[ ]+$/, Text
         # check for new documents or dedents at the new line
-        rule /\n+/ do
+        rule %r/\n+/ do
           token Text
           push :plain_scalar_in_block_context_new_line
         end
 
-        rule /[ ]+/, Str
+        rule %r/[ ]+/, Str
         rule SPECIAL_VALUES, Name::Constant
         # regular non-whitespace characters
-        rule /[^\s:]+/, Str
+        rule %r/[^\s:]+/, Str
       end
 
       state :plain_scalar_in_flow_context do
-        rule /[ ]*(?=[,:?\[\]{}])/, Text, :pop!
-        rule /[ ]+(?=#)/, Text, :pop!
-        rule /^[ ]+/, Text
-        rule /[ ]+$/, Text
-        rule /\n+/, Text
-        rule /[ ]+/, Name::Variable
-        rule /[^\s,:?\[\]{}]+/, Name::Variable
+        rule %r/[ ]*(?=[,:?\[\]{}])/, Text, :pop!
+        rule %r/[ ]+(?=#)/, Text, :pop!
+        rule %r/^[ ]+/, Text
+        rule %r/[ ]+$/, Text
+        rule %r/\n+/, Text
+        rule %r/[ ]+/, Name::Variable
+        rule %r/[^\s,:?\[\]{}]+/, Name::Variable
       end
 
       state :yaml_directive do
-        rule /([ ]+)(\d+\.\d+)/ do
+        rule %r/([ ]+)(\d+\.\d+)/ do
           groups Text, Num
           goto :ignored_line
         end

data/lib/rouge/plugins/redcarpet.rb

@@ -15,7 +15,7 @@ module Rouge
         # 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/tex_theme_renderer.rb

@@ -0,0 +1,128 @@
+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)}}"
+      yield "\\definecolor{#{@prefix}@bgcolor}{HTML}{#{inline_name(base.bg)}}"
+
+      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 = "\\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