rouge 1.1.0 → 1.2.0

data/Gemfile

@@ -7,6 +7,8 @@ gem 'wrong'
 
 gem 'rake'
 
+gem 'racc'
+
 # don't try to install redcarpet under jruby
 gem 'redcarpet', :platforms => :ruby
 

data/lib/rouge/cli.rb

@@ -42,6 +42,7 @@ module Rouge
       yield %|	help		#{Help.desc}|
       yield %|	style		#{Style.desc}|
       yield %|	list		#{List.desc}|
+      yield %|	version		#{Version.desc}|
       yield %||
       yield %|See `rougify help <command>` for more info.|
     end
@@ -80,6 +81,8 @@ module Rouge
 
     def self.class_from_arg(arg)
       case arg
+      when 'version', '--version'
+        Version
       when 'help'
         Help
       when 'highlight', 'hi'
@@ -91,6 +94,18 @@ module Rouge
       end
     end
 
+    class Version < CLI
+      def self.desc
+        "print the rouge version number"
+      end
+
+      def self.parse(*); new; end
+
+      def run
+        puts Rouge.version
+      end
+    end
+
     class Help < CLI
       def self.desc
         "print help info"

data/lib/rouge/demos/matlab

@@ -0,0 +1,6 @@
+A = cat( 3, [1 2 3; 9 8 7; 4 6 5], [0 3 2; 8 8 4; 5 3 5], ...
+                 [6 4 7; 6 8 5; 5 4 3]);
+% The EIG function is applied to each of the horizontal 'slices' of A.
+for i = 1:3
+    eig(squeeze(A(i,:,:)))
+end

data/lib/rouge/demos/ocaml

@@ -0,0 +1,12 @@
+(* Binary tree with leaves car­rying an integer. *)
+type tree = Leaf of int | Node of tree * tree
+
+let rec exists_leaf test tree =
+  match tree with
+  | Leaf v -> test v
+  | Node (left, right) ->
+      exists_leaf test left
+      || exists_leaf test right
+
+let has_even_leaf tree =
+  exists_leaf (fun n -> n mod 2 = 0) tree

data/lib/rouge/demos/scala

@@ -0,0 +1,3 @@
+class Greeter(name: String = "World") {
+  def sayHi() { println("Hi " + name + "!") }
+}

data/lib/rouge/demos/sml

@@ -0,0 +1,4 @@
+datatype shape
+   = Circle   of loc * real      (* center and radius *)
+   | Square   of loc * real      (* upper-left corner and side length; axis-aligned *)
+   | Triangle of loc * loc * loc (* corners *)

data/lib/rouge/demos/vb

@@ -0,0 +1,4 @@
+Private Sub Form_Load()
+    ' Execute a simple message box that says "Hello, World!"
+    MsgBox "Hello, World!"
+End Sub

data/lib/rouge/formatters/html.rb

@@ -46,7 +46,7 @@ module Rouge
         yield '</pre>' if @wrap
       end
 
-      def stream_tableized(tokens, &b)
+      def stream_tableized(tokens)
         num_lines = 0
         last_val = ''
         formatted = ''
@@ -86,30 +86,26 @@ module Rouge
         yield '</div>' if @wrap
       end
 
-      def span(tok, val, &b)
-        # TODO: properly html-encode val
-        val = CGI.escape_html(val)
+      TABLE_FOR_ESCAPE_HTML = {
+        '&' => '&amp;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+      }
 
-        case tok.shortname
-        when ''
+      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
-        when nil
-          raise "unknown token: #{tok.inspect} for #{val.inspect}"
         else
           if @inline_theme
             rules = @inline_theme.style_for(tok).rendered_rules
 
-            yield '<span style='
-            yield rules.to_a.join(';').inspect
-            yield '>'
+            yield "<span style=\"#{rules.to_a.join(';')}\">#{val}</span>"
           else
-            yield '<span class='
-            yield tok.shortname.inspect
-            yield '>'
+            yield "<span class=\"#{shortname}\">#{val}</span>"
           end
-
-          yield val
-          yield '</span>'
         end
       end
     end

data/lib/rouge/formatters/terminal256.rb

@@ -83,7 +83,7 @@ module Rouge
             attrs = []
 
             attrs << ['38', '5', fg.to_s] if fg
-            attrs << ['45', '5', bg.to_s] if bg
+            attrs << ['48', '5', bg.to_s] if bg
             attrs << '01' if style[:bold]
             attrs << '04' if style[:italic] # underline, but hey, whatevs
             escape(attrs)
@@ -155,7 +155,7 @@ module Rouge
       end
 
       def get_style(token)
-        return text_style if token == Token::Tokens::Text
+        return text_style if token.ancestors.include? Token::Tokens::Text
 
         theme.get_own_style(token) || text_style
       end

data/lib/rouge/lexer.rb

@@ -322,6 +322,8 @@ module Rouge
     #   tried and each stream consumed.  Try it, it's pretty useful.
     def initialize(opts={})
       options(opts)
+
+      @debug = option(:debug)
     end
 
     # get and/or specify the options for this lexer.
@@ -340,25 +342,21 @@ module Rouge
       end
     end
 
+    # @deprecated
+    # Instead of `debug { "foo" }`, simply `puts "foo" if @debug`.
+    #
     # Leave a debug message if the `:debug` option is set.  The message
     # is given as a block because some debug messages contain calculated
     # information that is unnecessary for lexing in the real world.
     #
+    # Calls to this method should be guarded with "if @debug" for best
+    # performance when debugging is turned off.
+    #
     # @example
-    #   debug { "hello, world!" }
-    def debug(&b)
-      # This method is a hotspot, unfortunately.
-      #
-      # For performance reasons, the "debug" option of a lexer cannot
-      # be changed once it has begun lexing.  This method will redefine
-      # itself on the first call to a noop if "debug" is not set.
-      if option(:debug)
-        def self.debug; puts yield; end
-      else
-        def self.debug; end
-      end
-
-      debug(&b)
+    #   debug { "hello, world!" } if @debug
+    def debug
+      warn "Lexer#debug is deprecated.  Simply puts if @debug instead."
+      puts yield if @debug
     end
 
     # @abstract

data/lib/rouge/lexers/coffeescript.rb

@@ -80,14 +80,12 @@ module Rouge
         rule /[-=]>/, Name::Function
 
         rule /(@)([ \t]*)(#{id})/ do
-          group Name::Variable::Instance; group Text
-          group Name::Attribute
+          groups Name::Variable::Instance, Text, Name::Attribute
           push :slash_starts_regex
         end
 
         rule /([.])([ \t]*)(#{id})/ do
-          group Punctuation; group Text
-          group Name::Attribute
+          groups Punctuation, Text, Name::Attribute
           push :slash_starts_regex
         end
 

data/lib/rouge/lexers/common_lisp.rb

@@ -264,15 +264,13 @@ module Rouge
 
         # complex
         rule /(#c)(\()/i do
-          group Num
-          group Punctuation
+          groups Num, Punctuation
           push :root
         end
 
         # arrays and structures
         rule /(#(?:\d+a|s))(\()/i do
-          group Literal::Other
-          group Punctuation
+          groups Literal::Other, Punctuation
           push :root
         end
 

data/lib/rouge/lexers/erlang.rb

@@ -75,13 +75,10 @@ module Rouge
         rule(/<</, Name::Label)
         rule(/>>/, Name::Label)
         rule %r{(#{atom_re})(:)} do
-          group Name::Namespace
-          group Punctuation
+          groups Name::Namespace, Punctuation
         end
         rule %r{(?:^|(?<=:))(#{atom_re})(\s*)(\()} do
-          group Name::Function
-          group Text
-          group Punctuation
+          groups Name::Function, Text, Punctuation
         end
         rule(%r{[+-]?#{base_re}#[0-9a-zA-Z]+}, Num::Integer)
         rule(/[+-]?\d+/, Num::Integer)
@@ -104,17 +101,11 @@ module Rouge
 
       state :directive do
         rule %r{(define)(\s*)(\()(#{macro_re})} do
-          group Name::Entity
-          group Text
-          group Punctuation
-          group Name::Constant
+          groups Name::Entity, Text, Punctuation, Name::Constant
           pop!
         end
         rule %r{(record)(\s*)(\()(#{macro_re})} do
-          group Name::Entity
-          group Text
-          group Punctuation
-          group Name::Label
+          groups Name::Entity, Text, Punctuation, Name::Label
           pop!
         end
         rule(atom_re, Name::Entity, :pop!)

data/lib/rouge/lexers/factor.rb

@@ -166,64 +166,65 @@ module Rouge
         rule /\s+/m, Text
 
         rule /(:|::|MACRO:|MEMO:|GENERIC:|HELP:)(\s+)(\S+)/m do
-          group Keyword; group Text
-          group Name::Function
+          groups Keyword, Text, Name::Function
         end
 
         rule /(M:|HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)/m do
-          group Keyword; group Text
-          group Name::Class; group Text
-          group Name::Function
+          groups Keyword, Text, Name::Class, Text, Name::Function
         end
 
         rule /\((?=\s)/, Name::Function, :stack_effect
         rule /;(?=\s)/, Keyword
 
         rule /(USING:)((?:\s|\\\s)+)/m do
-          group Keyword::Namespace; group Text
+          groups Keyword::Namespace, Text
           push :import
         end
 
         rule /(IN:|USE:|UNUSE:|QUALIFIED:|QUALIFIED-WITH:)(\s+)(\S+)/m do
-          group Keyword::Namespace; group Text; group Name::Namespace
+          groups Keyword::Namespace, Text, Name::Namespace
         end
 
         rule /(FROM:|EXCLUDE:)(\s+)(\S+)(\s+)(=>)/m do
-          group Keyword::Namespace; group Text
-          group Name::Namespace; group Text
-          group Punctuation
+          groups Keyword::Namespace, Text, Name::Namespace, Text, Punctuation
         end
 
         rule /(?:ALIAS|DEFER|FORGET|POSTPONE):/, Keyword::Namespace
 
         rule /(TUPLE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
-          group Keyword; group Text
-          group Name::Class; group Text
-          group Punctuation; group Text
-          group Name::Class
+          groups(
+            Keyword, Text,
+            Name::Class, Text,
+            Punctuation, Text,
+            Name::Class
+          )
           push :slots
         end
 
         rule /(TUPLE:)(\s+)(\S+)/m do
-          group Keyword; group Text; group Name::Class
+          groups Keyword, Text, Name::Class
           push :slots
         end
 
         rule /(UNION:|INTERSECTION:)(\s+)(\S+)/m do
-          group Keyword; group Text; group Name::Class
+          groups Keyword, Text, Name::Class
         end
 
         rule /(PREDICATE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
-          group Keyword; group Text
-          group Name::Class; group Text
-          group Punctuation; group Text
-          group Name::Class
+          groups(
+            Keyword, Text,
+            Name::Class, Text,
+            Punctuation, Text,
+            Name::Class
+          )
         end
 
         rule /(C:)(\s+)(\S+)(\s+)(\S+)/m do
-          group Keyword; group Text
-          group Name::Function; group Text
-          group Name::Class
+          groups(
+            Keyword, Text,
+            Name::Function, Text,
+            Name::Class
+          )
         end
 
         rule %r(
@@ -234,7 +235,7 @@ module Rouge
         rule /(?:<PRIVATE|PRIVATE>)/, Keyword::Namespace
 
         rule /(MAIN:)(\s+)(\S+)/ do
-          group Keyword::Namespace; group Text; group Name::Function
+          groups Keyword::Namespace, Text, Name::Function
         end
 
         # strings

data/lib/rouge/lexers/gherkin.rb

@@ -54,17 +54,17 @@ module Rouge
           reset_stack
 
           keyword = m[1]
-          if self.class.keywords[:element].include? keyword
-            group Keyword::Namespace; push :description
+          keyword_tok = if self.class.keywords[:element].include? keyword
+            push :description; Keyword::Namespace
           elsif self.class.keywords[:feature].include? keyword
-            group Keyword::Declaration; push :feature_description
+            push :feature_description; Keyword::Declaration
           elsif self.class.keywords[:examples].include? keyword
-            group Name::Namespace; push :example_description
+            push :example_description; Name::Namespace
           else
-            group Error
+            Error
           end
 
-          group Punctuation
+          groups keyword_tok, Punctuation
         end
       end
 

data/lib/rouge/lexers/groovy.rb

@@ -60,8 +60,7 @@ module Rouge
         rule %r(/(\\\\|\\"|[^/])*/), Str
         rule /'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, Str::Char
         rule /(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
-          group Operator
-          group Name::Attribute
+          groups Operator, Name::Attribute
         end
 
         rule /[a-zA-Z_][a-zA-Z0-9_]*:/, Name::Label

data/lib/rouge/lexers/haml.rb

@@ -82,7 +82,7 @@ module Rouge
         rule %r(
           (/) (\[#{dot}*?\]) (#{dot}*\n)
         )x do
-          group Comment; group Comment::Special; group Comment
+          groups Comment, Comment::Special, Comment
           pop!
         end
 
@@ -115,7 +115,7 @@ module Rouge
           @filter_lexer = self.filters[filter_name]
           @filter_lexer.reset! unless @filter_lexer.nil?
 
-          debug { "    haml: filter #{filter_name.inspect} #{@filter_lexer.inspect}" }
+          puts "    haml: filter #{filter_name.inspect} #{@filter_lexer.inspect}" if @debug
         end
 
         mixin :eval_or_plain

data/lib/rouge/lexers/haskell.rb

@@ -88,32 +88,32 @@ module Rouge
         rule /\bqualified\b/, Keyword
         # import X as Y
         rule /([A-Z][\w.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)/ do
-          group Name::Namespace # X
-          group Text
-          group Keyword # as
-          group Text
-          group Name # Y
+          groups(
+            Name::Namespace, # X
+            Text, Keyword, # as
+            Text, Name # Y
+          )
           pop!
         end
 
         # import X hiding (functions)
         rule /([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()/ do
-          group Name::Namespace # X
-          group Text
-          group Keyword # hiding
-          group Text
-          group Punctuation # (
-          pop!
-          push :funclist
+          groups(
+            Name::Namespace, # X
+            Text, Keyword, # hiding
+            Text, Punctuation # (
+          )
+          goto :funclist
         end
 
         # import X (functions)
         rule /([A-Z][\w.]*)(\s+)(\()/ do
-          group Name::Namespace # X
-          group Text
-          group Punctuation # (
-          pop!
-          push :funclist
+          groups(
+            Name::Namespace, # X
+            Text,
+            Punctuation # (
+          )
+          goto :funclist
         end
 
         rule /[\w.]+/, Name::Namespace, :pop!
@@ -123,9 +123,7 @@ module Rouge
         rule /\s+/, Text
         # module Foo (functions)
         rule /([A-Z][\w.]*)(\s+)(\()/ do
-          group Name::Namespace
-          group Text
-          group Punctuation
+          groups Name::Namespace, Text, Punctuation
           push :funclist
         end