rouge 0.0.1 → 0.0.2

data/Gemfile

@@ -1 +1,12 @@
+source 'http://rubygems.org'
+
 gemspec
+
+gem 'minitest'
+gem 'sexp_processor', '~> 3.0'
+gem 'wrong', '~> 0.6.2'
+
+gem 'rake'
+
+# for visual tests
+gem 'sinatra'

data/lib/rouge.rb

@@ -1,2 +1,25 @@
+# stdlib
+require 'pathname'
+
 module Rouge
+  class << self
+    def highlight(text, lexer_name, formatter)
+      lexer = Lexer.find(lexer_name)
+      raise "unknown lexer #{lexer_name}" unless lexer
+
+      formatter.render(lexer.lex(text))
+    end
+  end
 end
+
+load_dir = Pathname.new(__FILE__).dirname
+load load_dir.join('rouge/token.rb')
+load load_dir.join('rouge/lexer.rb')
+load load_dir.join('rouge/lexers/shell.rb')
+load load_dir.join('rouge/lexers/javascript.rb')
+
+load load_dir.join('rouge/formatter.rb')
+load load_dir.join('rouge/formatters/html.rb')
+
+load load_dir.join('rouge/theme.rb')
+load load_dir.join('rouge/themes/thankful_eyes.rb')

data/lib/rouge/formatter.rb

@@ -0,0 +1,11 @@
+module Rouge
+  class Formatter
+    def render(tokens)
+      enum_for(:stream, tokens).to_a.join
+    end
+
+    def stream(tokens, &b)
+      raise 'abstract'
+    end
+  end
+end

data/lib/rouge/formatters/html.rb

@@ -0,0 +1,33 @@
+module Rouge
+  module Formatters
+    class HTML < Formatter
+      def initialize(opts={})
+        @css_class = opts[:css_class] || 'highlight'
+      end
+
+      def stream(tokens, &b)
+        yield "<pre class=#{@css_class.inspect}>"
+        tokens.each do |tok, val|
+          # TODO: properly html-encode val
+          val.gsub! '&', '&amp;'
+          val.gsub! '<', '&lt;'
+          val.gsub! '>', '&gt;'
+
+          case tok.shortname
+          when ''
+            yield val
+          when nil
+            raise "unknown token: #{tok.inspect}"
+          else
+            yield '<span class='
+            yield tok.shortname.inspect
+            yield '>'
+            yield val
+            yield '</span>'
+          end
+        end
+        yield '</pre>'
+      end
+    end
+  end
+end

data/lib/rouge/lexer.rb

@@ -0,0 +1,238 @@
+module Rouge
+  class Lexer
+    class << self
+      def create(opts={}, &b)
+        new(opts, &b).send(:force_load!)
+      end
+
+      def find(name)
+        registry[name.to_s]
+      end
+
+      def register(name, lexer)
+        registry[name.to_s] = lexer
+      end
+
+    private
+      def registry
+        @registry ||= {}
+      end
+    end
+
+    def name(n=nil)
+      return @name if n.nil?
+
+      @name = n.to_s
+      aliases @name
+    end
+
+    def aliases(*args)
+      args.each { |arg| Lexer.register(arg, self) }
+    end
+
+    def initialize(opts={}, &b)
+      options opts
+      @lazy_load_proc = b
+    end
+
+    def default_options
+      {}
+    end
+
+    def options(o={})
+      (@options ||= default_options).merge!(o)
+
+      @options
+    end
+
+    def option(k, v=:absent)
+      if v == :absent
+        options[k.to_s]
+      else
+        options({ k.to_s => v })
+      end
+    end
+
+    def debug(&b)
+      puts(b.call) if option :debug
+    end
+
+    def get_tokens(stream)
+      lex(stream).to_a
+    end
+
+    def lex(stream, &b)
+      return enum_for(:lex, stream) unless block_given?
+
+      stream_tokens(stream, &b)
+    end
+
+    def stream_tokens(stream, &b)
+      raise 'abstract'
+    end
+
+  protected
+
+    def force_load!
+      return self if @force_load
+      @force_load = true
+      instance_eval &@lazy_load_proc
+
+      self
+    end
+  end
+
+  class RegexLexer < Lexer
+    class Rule
+      attr_reader :callback
+      attr_reader :next_lexer
+      attr_reader :re
+      def initialize(re, callback, next_lexer)
+        @orig_re = re
+        @re = Regexp.new %/\\A(?:#{re.source})/
+        @callback = callback
+        @next_lexer = next_lexer
+      end
+
+      def inspect
+        "#<Rule #{@orig_re.inspect}>"
+      end
+
+      def consume(stream, &b)
+        # TODO: I'm sure there is a much faster way of doing this.
+        # also, encapsulate the stream in its own class.
+        match = stream.match(@re)
+
+        if match
+          stream.slice!(0...$&.size)
+          yield match
+          return true
+        end
+
+        false
+      end
+    end
+
+    def initialize(parent=nil, opts={}, &defn)
+      if parent.is_a? Hash
+        opts = parent
+        parent = nil
+      end
+
+      @parent = parent
+      super(opts, &defn)
+    end
+
+    def lexer(name, opts={}, &defn)
+      @scope ||= {}
+      name = name.to_s
+
+      if block_given?
+        l = @scope[name] = RegexLexer.new(self, options.merge(opts), &defn)
+        l.instance_variable_set :@name, name
+        l
+      else
+        @scope[name] || @parent && @parent.lexer(name)
+      end
+    end
+
+    def mixin(lexer)
+      lexer = get_lexer(lexer)
+      lexer.force_load!
+
+      rules << lexer
+    end
+
+    def rules
+      force_load!
+      @rules ||= []
+    end
+
+    def rule(re, token=nil, next_lexer=nil, &callback)
+      if block_given?
+        next_lexer = token
+      else
+        if token.is_a? String
+          token = Token[token]
+        end
+
+        callback = proc { |match, &b| b.call token, match }
+      end
+
+      rules << Rule.new(re, callback, get_lexer(next_lexer))
+    end
+
+    def stream_tokens(stream, &b)
+      stream = stream.dup
+      stack = [self]
+
+      stream_with_stack(stream.dup, [self], &b)
+    end
+
+    def stream_with_stack(stream, stack, &b)
+      return true if stream.empty?
+
+      until stream.empty?
+        debug { "stack: #{stack.map(&:name).inspect}" }
+        debug { "parsing #{stream.slice(0..20).inspect}" }
+        success = stack.last.step(stream, stack, &b)
+
+        if !success
+          debug { "    no match, yielding Error" }
+          b.call(Token['Error'], stream.slice!(0..0))
+        end
+      end
+    end
+
+    def step(stream, stack, &b)
+      rules.each do |rule|
+        return true if run_rule(rule, stream, stack, &b)
+      end
+
+      false
+    end
+
+  private
+    def get_lexer(o)
+      case o
+      when RegexLexer, :pop!
+        o
+      else
+        lexer o
+      end
+    end
+
+    def run_rule(rule, stream, stack, &b)
+      case rule
+      when String, RegexLexer
+        lexer = get_lexer(rule)
+        debug { "  entering mixin #{lexer.name}" }
+        get_lexer(rule).step(stream, stack, &b)
+      when Rule
+        debug { "  trying #{rule.inspect}" }
+        rule.consume(stream) do |match|
+          debug { "    got #{match[0].inspect}" }
+
+          rule.callback.call(*match) do |tok, res|
+            if tok.is_a? String
+              tok = Token[tok]
+            end
+
+            debug { "    yielding #{tok.name.inspect}, #{res.inspect}" }
+            b.call(tok, res)
+          end
+
+          if rule.next_lexer == :pop!
+            debug { "    popping stack" }
+            stack.pop
+          elsif rule.next_lexer
+            lexer = get_lexer(rule.next_lexer)
+            debug { "    entering #{lexer.name}" }
+            stack.push lexer
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/rouge/lexers/javascript.rb

@@ -0,0 +1,83 @@
+module Rouge
+  module Lexers
+    JavascriptLexer = RegexLexer.create do
+      option :debug, true
+
+      name 'javascript'
+      aliases 'js'
+
+      lexer :comments_and_whitespace do
+        rule /\s+/, 'Text'
+        rule /<!--/, 'Comment' # really...?
+        rule %r(//.*?\n), 'Comment.Single'
+        rule %r(/\*.*?\*/), 'Comment.Multiline'
+      end
+
+      lexer :slash_starts_regex do
+        mixin :comments_and_whitespace
+        rule %r(
+          /(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/ # a nonempty regex
+          (?:[gim]+\b|\B) # regex flags
+        )x, 'Literal.String.Regex'
+
+        # if it's not matched by the above r.e., it's not
+        # a valid expression, so we use :bad_regex to eat until the
+        # end of the line.
+        rule %r(/), 'Literal.String.Regex', :bad_regex
+        rule //, 'Text', :pop!
+
+        lexer :bad_regex do
+          rule /[^\n]+/, 'Error', :pop!
+        end
+      end
+
+      keywords = %w(
+        for in while do break return continue switch case default if else
+        throw try catch finally new delete typeof instanceof void this
+      ).join('|')
+
+      declarations = %w(var let with function).join('|')
+
+      reserved = %w(
+        abstract boolean byte char class const debugger double enum export
+        extends final float goto implements import int interface long
+        native package private protected public short static super
+        synchronized throws transient volatile
+      ).join('|')
+
+      constants = %w(true false null NaN Infinity undefined).join('|')
+
+      builtins = %w(
+        Array Boolean Date Error Function Math netscape
+        Number Object Packages RegExp String sun decodeURI
+        decodeURIComponent encodeURI encodeURIComponent
+        Error eval isFinite isNaN parseFloat parseInt document this
+        window
+      ).join('|')
+
+      lexer :root do
+        rule %r(^(?=\s|/|<!--)), 'Text', :slash_starts_regex
+        mixin :comments_and_whitespace
+        rule %r(\+\+|--|~|&&|\?|\|\||\\(?=\n)|<<|>>>?|===|!==),
+          'Operator', :slash_starts_regex
+        rule %r([-<>+*%&|\^/!=]=?), 'Operator', :slash_starts_regex
+        rule /[{(\[;,]/, 'Punctuation', :slash_starts_regex
+        rule /[})\].]/, 'Punctuation'
+        rule /(?:#{keywords})\b/, 'Keyword', :slash_starts_regex
+        rule /(?:#{declarations})\b/, 'Keyword.Declaration', :slash_starts_regex
+        rule /(?:#{reserved})\b/, 'Keyword.Reserved'
+        rule /(?:#{constants})\b/, 'Keyword.Constant'
+        rule /(?:#{builtins})\b/, 'Name.Builtin'
+        rule /[$a-zA-Z_][a-zA-Z0-9_]*/, 'Name.Other'
+
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, 'Number.Float'
+        rule /0x[0-9a-fA-F]+/, 'Number.Hex'
+        rule /[0-9]+/, 'Number.Integer'
+        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String.Double'
+        rule /'(\\\\|\\'|[^'])*'/, 'Literal.String.Single'
+      end
+
+      mixin :root
+    end
+  end
+end

data/lib/rouge/lexers/shell.rb

@@ -0,0 +1,109 @@
+module Rouge
+  module Lexers
+    ShellLexer = RegexLexer.create do
+      name 'shell'
+      aliases 'bash', 'zsh', 'ksh', 'sh'
+
+      KEYWORDS = %w(
+        if fi else while do done for then return function case
+        select continue until esac elif
+      ).join('|')
+
+      BUILTINS = %w(
+        alias bg bind break builtin caller cd command compgen
+        complete declare dirs disown echo enable eval exec exit
+        export false fc fg getopts hash help history jobs kill let
+        local logout popd printf pushd pwd read readonly set shift
+        shopt source suspend test time times trap true type typeset
+        ulimit umask unalias unset wait
+      ).join('|')
+
+      lexer :basic do
+        rule /#.*\n/, 'Comment'
+
+        rule /\b(#{KEYWORDS})\s*\b/, 'Keyword'
+
+        rule /\b(#{BUILTINS})\s*\b(?!\.)/, 'Name.Builtin'
+
+        rule /(\b\w+)(=)/ do |_, var, eq, &out|
+          out.call 'Name.Variable', var
+          out.call 'Operator', eq
+        end
+
+        rule /[\[\]{}()=]/, 'Operator'
+        rule /&&|\|\|/, 'Operator'
+        # rule /\|\|/, 'Operator'
+
+        rule /<<</, 'Operator' # here-string
+        rule /<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2/, 'Literal.String'
+      end
+
+      lexer :double_quotes do
+        rule /"/, 'Literal.String.Double', :pop!
+        rule /\\./, 'Literal.String.Escape'
+        mixin :interp
+        rule /[^"`\\$]+/, 'Literal.String.Double'
+      end
+
+      lexer :data do
+        # TODO: this should be its own sublexer so we can capture
+        # interpolation and such
+        rule /$?"/, 'Literal.String.Double', :double_quotes
+
+        # single quotes are much easier than double quotes - we can
+        # literally just scan until the next single quote.
+        # POSIX: Enclosing characters in single-quotes ( '' )
+        # shall preserve the literal value of each character within the
+        # single-quotes. A single-quote cannot occur within single-quotes.
+        rule /$?'[^']*'/, 'Literal.String.Single'
+
+        rule /;/, 'Text'
+        rule /\s+/, 'Text'
+        rule /[^=\s\[\]{}()$"\'`\\<]+/, 'Text'
+        rule /\d+(?= |\Z)/, 'Number'
+        rule /</, 'Text'
+        mixin :interp
+      end
+
+      lexer :curly do
+        rule /}/, 'Keyword', :pop!
+        rule /:-/, 'Keyword'
+        rule /[a-zA-Z0-9_]+/, 'Name.Variable'
+        rule /[^}:"'`$]+/, 'Punctuation'
+        mixin :root
+      end
+
+      lexer :paren do
+        rule /\)/, 'Keyword', :pop!
+        mixin :root
+      end
+
+      lexer :math do
+        rule /\)\)/, 'Keyword', :pop!
+        rule %r([-+*/%^|&]|\*\*|\|\|), 'Operator'
+        rule /\d+/, 'Number'
+        mixin :root
+      end
+
+      lexer :backticks do
+        rule /`/, 'Literal.String.Backtick', :pop!
+        mixin :root
+      end
+
+      lexer :interp do
+        rule /\$\(\(/, 'Keyword', :math
+        rule /\$\(/, 'Keyword', :paren
+        rule /\${#?/, 'Keyword', :curly
+        rule /`/, 'Literal.String.Backtick', :backticks
+        rule /\$#?(\w+|.)/, 'Name.Variable'
+      end
+
+      lexer :root do
+        mixin :basic
+        mixin :data
+      end
+
+      mixin :root
+    end
+  end
+end

data/lib/rouge/theme.rb

@@ -0,0 +1,112 @@
+module Rouge
+  class Theme
+    class << self
+      def styles
+        @styles ||= {}
+      end
+
+      def main_style
+        @main_style ||= {}
+      end
+
+      def style(*tokens)
+        opts = {}
+        opts = tokens.pop if tokens.last.is_a? Hash
+
+        if tokens.empty?
+          @main_style = opts
+        end
+
+        tokens.each do |tok|
+          styles[tok.to_s] = opts
+        end
+      end
+
+      def name(n=nil)
+        return @name if n.nil?
+
+        @name = n.to_s
+        registry[@name] = self
+      end
+
+      def find(n)
+        registry[n.to_s]
+      end
+
+      def registry
+        @registry ||= {}
+      end
+    end
+  end
+
+  class CSSTheme < Theme
+    def initialize(opts={})
+      @opts = opts
+    end
+
+    def render
+      out = []
+      stream { |line| out << line }
+      out.join("\n")
+    end
+
+    def stream(&b)
+      return enum_for(:stream) unless block_given?
+
+      self.class.styles.each do |tokname, style|
+        stream_single(Token[tokname], style, &b)
+      end
+
+      render_stanza('.highlight', self.class.main_style, &b)
+    end
+
+  private
+    def stream_single(tok, style, &b)
+      render_stanza(css_selector(tok), style, &b)
+    end
+
+    def render_stanza(selector, style, &b)
+      return if style.empty?
+
+      yield "#{selector} {"
+      yield "  color: #{style[:fg]};" if style[:fg]
+      yield "  background-color: #{style[:bg]};" if style[:bg]
+      yield "  font-weight: bold;" if style[:bold]
+      yield "  font-style: italic;" if style[:italic]
+      yield "  text-decoration: underline;" if style[:underline]
+
+      (style[:rules] || []).each do |rule|
+        yield "  #{rule};"
+      end
+
+      yield "}"
+    end
+
+    def css_selector(token)
+      tokens = [token]
+      parent = token.parent
+
+      inflate_token(token).map do |tok|
+        base = ".highlight"
+        base << " .#{tok.shortname}" unless tok.shortname.empty?
+
+        base
+      end.join(', ')
+    end
+
+    # yield all of the tokens that should be styled the same
+    # as the given token.  Essentially this recursively all of
+    # the subtokens, except those which are more specifically
+    # styled.
+    def inflate_token(tok, &b)
+      return enum_for(:inflate_token, tok) unless block_given?
+
+      yield tok
+      tok.sub_tokens.each_value do |st|
+        next if self.class.styles.include? st.name
+
+        inflate_token(st, &b)
+      end
+    end
+  end
+end

data/lib/rouge/themes/thankful_eyes.rb

@@ -0,0 +1,65 @@
+module Rouge
+  module Themes
+    class ThankfulEyes < CSSTheme
+      # pallette, from GTKSourceView's ThankfulEyes
+      cool_as_ice =    '#6c8b9f'
+      slate_blue =     '#4e5d62'
+      eggshell_cloud = '#dee5e7'
+      krasna =         '#122b3b'
+      aluminum1 =      '#fefeec'
+      scarletred2 =    '#cc0000'
+      butter3 =        '#c4a000'
+      go_get_it =      '#b2fd6d'
+      chilly =         '#a8e1fe'
+      unicorn =        '#faf6e4'
+      sandy =          '#f6dd62'
+      pink_merengue =  '#f696db'
+      dune =           '#fff0a6'
+      backlit =        '#4df4ff'
+      schrill =        '#ffb000'
+
+      style :fg => unicorn, :bg => krasna
+
+      style 'Comment', :fg => cool_as_ice
+      style 'Error',
+            'Generic.Error', :fg => aluminum1, :bg => scarletred2
+      style 'Keyword', :fg => sandy, :bold => true
+      style 'Operator', :fg => backlit, :bold => true
+      style 'Comment.Preproc',
+            'Comment.Multiline',
+            'Comment.Single',
+            'Comment.Special', :fg => cool_as_ice, :italic => true
+      style 'Generic.Deleted', :fg => scarletred2
+      style 'Generic.Emph', :italic => true
+      style 'Generic.Subheading', :fg => '#800080', :bold => true
+      style 'Generic.Traceback', :fg => '#0040D0'
+      style 'Keyword.Constant', :fg => pink_merengue, :bold => true
+      style 'Keyword.Namespace',
+            'Keyword.Pseudo',
+            'Keyword.Reserved', :fg => schrill, :bold => true
+      style 'Keyword.Type',
+            'Name.Constant',
+            'Name.Class',
+            'Name.Decorator',
+            'Name.Namespace',
+            'Name.Builtin.Pseudo',
+            'Name.Exception', :fg => go_get_it, :bold => true
+      style 'Literal.Number', :fg => pink_merengue, :bold => true
+      style 'Literal.String', :fg => dune, :bold => true
+      style 'Literal.String.Escape',
+            'Literal.String.Char',
+            'Literal.String.Interpol',
+            'Literal.String.Other',
+            'Literal.String.Symbol', :fg => backlit, :bold => true
+      style 'Name.Attribute', :fg => '#7D9029'
+      style 'Name.Builtin', :fg => sandy
+      style 'Name.Entity', :fg => '#999999', :bold => true
+      style 'Name.Label', :fg => '#A0A000'
+      style 'Name.Tag', :fg => '#008000', :bold => true
+      style 'Text.Whitespace', :fg => '#BBBBBB'
+      style 'Name.Variable',
+            'Name.Function', :fg => chilly
+
+    end
+  end
+end

data/lib/rouge/token.rb

@@ -0,0 +1,168 @@
+module Rouge
+  class Token
+    attr_reader :name
+    attr_reader :parent
+    attr_accessor :shortname
+
+    def make_single(name)
+      name = name.to_s
+      new_name = [self.name, name].compact.join('.')
+
+      new_token = self.clone
+      parent = self
+      new_token.instance_eval do
+        @name = new_name
+        @parent = parent
+        @sub_tokens = {}
+      end
+
+      sub_tokens[name] = new_token
+
+      new_token
+    end
+
+    def make(name, shortname=nil)
+      names = name.split('.')
+      names.inject(self) do |tok, name|
+        tok.make_single(name)
+      end
+    end
+
+    def [](name)
+      name = name.to_s
+
+      name.split('.').inject(self) do |tok, name|
+        tok.sub_tokens[name] || tok.make_single(name)
+      end
+    end
+
+    def sub_tokens
+      @sub_tokens ||= {}
+    end
+
+    def ===(other)
+      immediate = if self.class == other.class
+        self == other
+      else
+        self.name == other
+      end
+
+      immediate || !!(other.parent && self === other.parent)
+    end
+
+    def inspect
+      parts = [name.inspect]
+      parts << shortname.inspect if shortname
+      "#<Token #{parts.join(' ')}>"
+    end
+
+    class << self
+      def base
+        @base ||= new
+      end
+
+      def get(name)
+        base[name]
+      end
+
+      def token(name, shortname)
+        tok = get(name)
+        tok.shortname = shortname
+        tok
+      end
+
+      alias [] get
+
+      def each_token(&b)
+        recurse = proc do |token|
+          b.call(token)
+          token.sub_tokens.each_value(&recurse)
+        end
+
+        base.sub_tokens.each_value(&recurse)
+      end
+    end
+
+    # XXX IMPORTANT XXX
+    # For compatibility, this list must be kept in sync with
+    # pygments.token.STANDARD_TYPES
+    token 'Text',                        ''
+    token 'Text.Whitespace',             'w'
+    token 'Error',                       'err'
+    token 'Other',                       'x'
+
+    token 'Keyword',                     'k'
+    token 'Keyword.Constant',            'kc'
+    token 'Keyword.Declaration',         'kd'
+    token 'Keyword.Namespace',           'kn'
+    token 'Keyword.Pseudo',              'kp'
+    token 'Keyword.Reserved',            'kr'
+    token 'Keyword.Type',                'kt'
+
+    token 'Name',                        'n'
+    token 'Name.Attribute',              'na'
+    token 'Name.Builtin',                'nb'
+    token 'Name.Builtin.Pseudo',         'bp'
+    token 'Name.Class',                  'nc'
+    token 'Name.Constant',               'no'
+    token 'Name.Decorator',              'nd'
+    token 'Name.Entity',                 'ni'
+    token 'Name.Exception',              'ne'
+    token 'Name.Function',               'nf'
+    token 'Name.Property',               'py'
+    token 'Name.Label',                  'nl'
+    token 'Name.Namespace',              'nn'
+    token 'Name.Other',                  'nx'
+    token 'Name.Tag',                    'nt'
+    token 'Name.Variable',               'nv'
+    token 'Name.Variable.Class',         'vc'
+    token 'Name.Variable.Global',        'vg'
+    token 'Name.Variable.Instance',      'vi'
+
+    token 'Literal',                     'l'
+    token 'Literal.Date',                'ld'
+
+    token 'Literal.String',              's'
+    token 'Literal.String.Backtick',     'sb'
+    token 'Literal.String.Char',         'sc'
+    token 'Literal.String.Doc',          'sd'
+    token 'Literal.String.Double',       's2'
+    token 'Literal.String.Escape',       'se'
+    token 'Literal.String.Heredoc',      'sh'
+    token 'Literal.String.Interpol',     'si'
+    token 'Literal.String.Other',        'sx'
+    token 'Literal.String.Regex',        'sr'
+    token 'Literal.String.Single',       's1'
+    token 'Literal.String.Symbol',       'ss'
+
+    token 'Literal.Number',              'm'
+    token 'Literal.Number.Float',        'mf'
+    token 'Literal.Number.Hex',          'mh'
+    token 'Literal.Number.Integer',      'mi'
+    token 'Literal.Number.Integer.Long', 'il'
+    token 'Literal.Number.Oct',          'mo'
+
+    token 'Operator',                    'o'
+    token 'Operator.Word',               'ow'
+
+    token 'Punctuation',                 'p'
+
+    token 'Comment',                     'c'
+    token 'Comment.Multiline',           'cm'
+    token 'Comment.Preproc',             'cp'
+    token 'Comment.Single',              'c1'
+    token 'Comment.Special',             'cs'
+
+    token 'Generic',                     'g'
+    token 'Generic.Deleted',             'gd'
+    token 'Generic.Emph',                'ge'
+    token 'Generic.Error',               'gr'
+    token 'Generic.Heading',             'gh'
+    token 'Generic.Inserted',            'gi'
+    token 'Generic.Output',              'go'
+    token 'Generic.Prompt',              'gp'
+    token 'Generic.Strong',              'gs'
+    token 'Generic.Subheading',          'gu'
+    token 'Generic.Traceback',           'gt'
+  end
+end

data/lib/rouge/version.rb

@@ -1,5 +1,5 @@
 module Rouge
   def self.version
-    "0.0.1"
+    "0.0.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-30 00:00:00.000000000 Z
+date: 2012-09-01 00:00:00.000000000 Z
 dependencies: []
 description: see the description for now
 email:
@@ -19,7 +19,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
+- lib/rouge/lexers/shell.rb
+- lib/rouge/lexers/javascript.rb
+- lib/rouge/themes/thankful_eyes.rb
+- lib/rouge/token.rb
+- lib/rouge/formatters/html.rb
 - lib/rouge/version.rb
+- lib/rouge/formatter.rb
+- lib/rouge/lexer.rb
+- lib/rouge/theme.rb
 - lib/rouge.rb
 homepage: http://github.com/jayferd/rouge
 licenses: []