rouge 0.4.0 → 0.5.0

data/lib/rouge/template_lexer.rb

@@ -9,7 +9,7 @@ module Rouge
     def parent
       return @parent if instance_variable_defined? :@parent
       @parent = option(:parent) || 'html'
-      if @parent.is_a? String
+      if @parent.is_a? ::String
         lexer_class = Lexer.find(@parent)
         @parent = lexer_class.new(self.options)
       end

data/lib/rouge/theme.rb

@@ -1,5 +1,7 @@
 module Rouge
   class Theme
+    include Token::Tokens
+
     class Style < Hash
       def initialize(theme, hsh={})
         super()
@@ -75,18 +77,20 @@ module Rouge
         style = Style.new(self, style)
 
         tokens.each do |tok|
-          styles[tok.to_s] = style
+          styles[tok] = style
         end
       end
 
       def get_own_style(token)
-        token.ancestors do |anc|
-          return styles[anc.name] if styles[anc.name]
+        token.token_chain.each do |anc|
+          return styles[anc] if styles[anc]
         end
+
+        nil
       end
 
       def get_style(token)
-        get_own_style(token) || style['Text']
+        get_own_style(token) || styles[Token::Tokens::Text]
       end
 
       def name(n=nil)
@@ -140,15 +144,13 @@ module Rouge
       yield "#{@scope} table td { padding: 5px; }"
       yield "#{@scope} table .gutter { text-align: right; }"
 
-      styles.each do |tokname, style|
-        style.render(css_selector(Token[tokname]), &b)
+      styles.each do |tok, style|
+        style.render(css_selector(tok), &b)
       end
     end
 
     def style_for(tok)
-      styles.fetch(tok.name) do
-        tok.parent ? style_for(tok.parent) : Style.new(self)
-      end
+      self.class.get_style(tok)
     end
 
   private
@@ -175,7 +177,7 @@ module Rouge
 
       yield tok
       tok.sub_tokens.each do |(_, st)|
-        next if styles[st.name]
+        next if styles[st]
 
         inflate_token(st, &b)
       end

data/lib/rouge/themes/thankful_eyes.rb

@@ -20,50 +20,50 @@ module Rouge
       palette :backlit        => '#4df4ff'
       palette :schrill        => '#ffb000'
 
-      style 'Text', :fg => :unicorn, :bg => :krasna
-      style 'Generic.Lineno', :fg => :eggshell_cloud, :bg => :slate_blue
+      style Text, :fg => :unicorn, :bg => :krasna
+      style Generic::Lineno, :fg => :eggshell_cloud, :bg => :slate_blue
 
-      style 'Comment', :fg => :cool_as_ice, :italic => true
-      style 'Comment.Preproc', :fg => :go_get_it, :bold => true, :italic => true
-      style 'Error',
-            'Generic.Error', :fg => :aluminum1, :bg => :scarletred2
-      style 'Keyword', :fg => :sandy, :bold => true
-      style 'Operator',
-            'Punctuation', :fg => :backlit
-      style 'Generic.Deleted', :fg => :scarletred2
-      style 'Generic.Inserted', :fg => :go_get_it
-      style 'Generic.Emph', :italic => true
-      style 'Generic.Strong', :bold => true
-      style 'Generic.Traceback', :fg => :eggshell_cloud, :bg => :slate_blue
-      style 'Keyword.Constant', :fg => :pink_merengue, :bold => true
-      style 'Keyword.Namespace',
-            'Keyword.Pseudo',
-            'Keyword.Reserved',
-            'Generic.Heading',
-            'Generic.Subheading', :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 'Name.Label',
-            'Name.Tag', :fg => :schrill, :bold => true
-      style 'Literal.Number',
-            'Literal.Date',
-            'Literal.String.Symbol', :fg => :pink_merengue, :bold => true
-      style 'Literal.String', :fg => :dune, :bold => true
-      style 'Literal.String.Escape',
-            'Literal.String.Char',
-            'Literal.String.Interpol', :fg => :backlit, :bold => true
-      style 'Name.Builtin', :bold => true
-      style 'Name.Entity', :fg => '#999999', :bold => true
-      style 'Text.Whitespace', :fg => '#BBBBBB'
-      style 'Name.Function',
-            'Name.Property',
-            'Name.Attribute', :fg => :chilly
-      style 'Name.Variable', :fg => :chilly, :bold => true
+      style Comment, :fg => :cool_as_ice, :italic => true
+      style Comment::Preproc, :fg => :go_get_it, :bold => true, :italic => true
+      style Error,
+            Generic::Error, :fg => :aluminum1, :bg => :scarletred2
+      style Keyword, :fg => :sandy, :bold => true
+      style Operator,
+            Punctuation, :fg => :backlit
+      style Generic::Deleted, :fg => :scarletred2
+      style Generic::Inserted, :fg => :go_get_it
+      style Generic::Emph, :italic => true
+      style Generic::Strong, :bold => true
+      style Generic::Traceback, :fg => :eggshell_cloud, :bg => :slate_blue
+      style Keyword::Constant, :fg => :pink_merengue, :bold => true
+      style Keyword::Namespace,
+            Keyword::Pseudo,
+            Keyword::Reserved,
+            Generic::Heading,
+            Generic::Subheading, :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 Name::Label,
+            Name::Tag, :fg => :schrill, :bold => true
+      style Literal::Number,
+            Literal::Date,
+            Literal::String::Symbol, :fg => :pink_merengue, :bold => true
+      style Literal::String, :fg => :dune, :bold => true
+      style Literal::String::Escape,
+            Literal::String::Char,
+            Literal::String::Interpol, :fg => :backlit, :bold => true
+      style Name::Builtin, :bold => true
+      style Name::Entity, :fg => '#999999', :bold => true
+      style Text::Whitespace, :fg => '#BBBBBB'
+      style Name::Function,
+            Name::Property,
+            Name::Attribute, :fg => :chilly
+      style Name::Variable, :fg => :chilly, :bold => true
     end
   end
 end

data/lib/rouge/token.rb

@@ -1,183 +1,180 @@
 module Rouge
   class Token
-    attr_reader :name
-    attr_reader :parent
-    attr_accessor :shortname
-    alias to_s name
+    class << self
+      def name; @name; end
+      def parent; @parent; end
+      def shortname; @shortname; end
 
-    def make_single(name)
-      name = name.to_s
-      new_name = [self.name, name].compact.join('.')
+      def cache
+        @cache ||= {}
+      end
 
-      new_token = self.clone
-      parent = self
-      new_token.instance_eval do
-        @name = new_name
-        @parent = parent
-        @sub_tokens = {}
+      def sub_tokens
+        @sub_tokens ||= {}
       end
 
-      sub_tokens[name] = new_token
+      def [](qualname)
+        return qualname unless qualname.is_a? ::String
 
-      new_token
-    end
+        Token.cache[qualname]
+      end
 
-    def make(name, shortname=nil)
-      names = name.split('.')
-      names.inject(self) do |tok, name|
-        tok.make_single(name)
+      def inspect
+        "<Token #{qualname}>"
       end
-    end
 
-    def [](name)
-      name = name.to_s
+      def matches?(other)
+        other.token_chain.include? self
+      end
 
-      name.split('.').inject(self) do |tok, name|
-        tok.sub_tokens[name] || tok.make_single(name)
+      def token_chain
+        @token_chain ||= ancestors.take_while { |x| x != Token }.reverse
       end
-    end
 
-    def sub_tokens
-      @sub_tokens ||= {}
-    end
+      def qualname
+        @qualname ||= token_chain.map(&:name).join('.')
+      end
 
-    def ancestors(&b)
-      return enum_for(:ancestors) unless block_given?
+      def register!
+        Token.cache[self.qualname] = self
+        parent.sub_tokens[self.name] = self
+      end
 
-      if parent
-        yield self
-        parent.ancestors(&b)
+      def make_token(name, shortname, &b)
+        parent = self
+        Class.new(parent) do
+          @parent = parent
+          @name = name
+          @shortname = shortname
+          register!
+          class_eval(&b) if b
+        end
       end
-    end
 
-    def ===(other)
-      immediate = if self.class == other.class
-        self == other
-      else
-        self.name == other
+      def token(name, shortname, &b)
+        tok = make_token(name, shortname, &b)
+        const_set(name, tok)
       end
 
-      immediate || !!(other.parent && self === other.parent)
+      def each_token(&b)
+        Token.cache.each do |(_, t)|
+          b.call(t)
+        end
+      end
     end
 
-    def inspect
-      parts = [name.inspect]
-      parts << shortname.inspect if shortname
-      "#<Token #{parts.join(' ')}>"
-    end
+    module Tokens
+      def self.token(name, shortname, &b)
+        tok = Token.make_token(name, shortname, &b)
+        const_set(name, tok)
+      end
 
-    class << self
-      def base
-        @base ||= new
+      # XXX IMPORTANT XXX
+      # For compatibility, this list must be kept in sync with
+      # pygments.token.STANDARD_TYPES
+      # please see https://github.com/jayferd/rouge/wiki/List-of-tokens
+      token :Text, '' do
+        token :Whitespace, 'w'
       end
 
-      def get(name)
-        return name if name.is_a? Token
+      token :Error, 'err'
+      token :Other, 'x'
+
+      token :Keyword, 'k' do
+        token :Constant,    'kc'
+        token :Declaration, 'kd'
+        token :Namespace,   'kn'
+        token :Pseudo,      'kp'
+        token :Reserved,    'kr'
+        token :Type,        'kt'
+        token :Variable,    'kv'
+      end
 
-        base[name]
+      token :Name, 'n' do
+        token :Attribute,    'na'
+        token :Builtin,      'nb' do
+          token :Pseudo,     'bp'
+        end
+        token :Class,        'nc'
+        token :Constant,     'no'
+        token :Decorator,    'nd'
+        token :Entity,       'ni'
+        token :Exception,    'ne'
+        token :Function,     'nf'
+        token :Property,     'py'
+        token :Label,        'nl'
+        token :Namespace,    'nn'
+        token :Other,        'nx'
+        token :Tag,          'nt'
+        token :Variable,     'nv' do
+          token :Class,      'vc'
+          token :Global,     'vg'
+          token :Instance,   'vi'
+        end
       end
 
-      alias [] get
+      token :Literal,      'l' do
+        token :Date,       'ld'
+
+        token :String,     's' do
+          token :Backtick, 'sb'
+          token :Char,     'sc'
+          token :Doc,      'sd'
+          token :Double,   's2'
+          token :Escape,   'se'
+          token :Heredoc,  'sh'
+          token :Interpol, 'si'
+          token :Other,    'sx'
+          token :Regex,    'sr'
+          token :Single,   's1'
+          token :Symbol,   'ss'
+        end
 
-      def token(name, shortname)
-        tok = get(name)
-        tok.shortname = shortname
-        tok
+        token :Number,     'm' do
+          token :Float,    'mf'
+          token :Hex,      'mh'
+          token :Integer,  'mi' do
+            token :Long,   'il'
+          end
+          token :Oct,      'mo'
+          token :Bin,      'mb'
+          token :Other,    'mx'
+        end
       end
 
-      def each_token(&b)
-        recurse = proc do |token|
-          b.call(token)
-          token.sub_tokens.each_value(&recurse)
-        end
+      token :Operator, 'o' do
+        token :Word,   'ow'
+      end
 
-        base.sub_tokens.each_value(&recurse)
+      token :Punctuation, 'p' do
+        token :Indicator, 'pi'
+      end
+
+      token :Comment,     'c' do
+        token :Doc,       'cd'
+        token :Multiline, 'cm'
+        token :Preproc,   'cp'
+        token :Single,    'c1'
+        token :Special,   'cs'
+      end
+
+      token :Generic,      'g' do
+        token :Deleted,    'gd'
+        token :Emph,       'ge'
+        token :Error,      'gr'
+        token :Heading,    'gh'
+        token :Inserted,   'gi'
+        token :Output,     'go'
+        token :Prompt,     'gp'
+        token :Strong,     'gs'
+        token :Subheading, 'gu'
+        token :Traceback,  'gt'
+        token :Lineno,     'gl'
       end
-    end
 
-    # XXX IMPORTANT XXX
-    # For compatibility, this list must be kept in sync with
-    # pygments.token.STANDARD_TYPES
-    # please see https://github.com/jayferd/rouge/wiki/List-of-tokens
-    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'
-
-    token 'Generic.Lineno',              'gl'
+      # convenience
+      Num = Literal::Number
+      Str = Literal::String
+    end
   end
 end