rouge 0.1.0.rc1 → 0.1.0

data/lib/rouge/lexer.rb

@@ -214,119 +214,6 @@ module Rouge
       end
     end
 
-    class ScanState
-      def self.delegate(m, target)
-        define_method(m) do |*a, &b|
-          send(target).send(m, *a, &b)
-        end
-      end
-
-      attr_accessor :scanner
-      attr_accessor :stack
-      attr_accessor :lexer
-      def initialize(lexer, scanner=nil, stack=nil)
-        @lexer = lexer
-        @scanner = scanner
-        @stack = stack || [lexer.get_state(:root)]
-      end
-
-      def pop!
-        raise 'empty stack!' if stack.empty?
-
-        debug { "    popping stack" }
-        stack.pop
-      end
-
-      def push(state_name=nil, &b)
-        # use the top of the stack by default
-        if state_name || b
-          push_state = state.relative_state(state_name, &b)
-        else
-          push_state = self.state
-        end
-
-        debug { "    pushing #{push_state.name}" }
-        stack.push(push_state)
-      end
-
-      def in_state?(state_name)
-        stack.map(&:name).include? state_name.to_s
-      end
-
-      def state?(state_name)
-        state_name.to_s == state.name
-      end
-
-      delegate :debug, :lexer
-
-      delegate :[], :scanner
-      delegate :captures, :scanner
-      delegate :peek, :scanner
-      delegate :eos?, :scanner
-
-      def run_callback(&callback)
-        Enumerator.new do |y|
-          @output_stream = y
-          @group_count = 0
-          instance_exec(self, &callback)
-          @output_stream = nil
-        end
-      end
-
-      def token(tok, val=:__absent__)
-        val = scanner[0] if val == :__absent__
-        val ||= ''
-
-        raise 'no output stream' unless @output_stream
-
-        @output_stream << [Token[tok], val]
-      end
-
-      def group(tok)
-        token(tok, scanner[@group_count += 1])
-      end
-
-      def delegate(lexer, text=nil)
-        debug { "    delegating to #{lexer.inspect}" }
-        text ||= scanner[0]
-
-        lexer.lex(text, :continue => true) do |tok, val|
-          debug { "    delegated token: #{tok.inspect}, #{val.inspect}" }
-          token(tok, val)
-        end
-      end
-
-      def state
-        raise 'empty stack!' if stack.empty?
-        stack.last
-      end
-
-      MAX_NULL_STEPS = 5
-      def scan(re, &b)
-        @null_steps ||= 0
-
-        if @null_steps >= MAX_NULL_STEPS
-          debug { "    too many scans without consuming the string!" }
-          return false
-        end
-
-        scanner.scan(re)
-
-        if scanner.matched?
-          if scanner.matched_size == 0
-            @null_steps += 1
-          else
-            @null_steps = 0
-          end
-
-          yield self
-          return true
-        end
-
-        return false
-      end
-    end
-
     class StateDSL
       attr_reader :rules
       def initialize(rules)
@@ -391,56 +278,57 @@ module Rouge
       self.class.get_state(name)
     end
 
-    def scan_state
-      @scan_state ||= ScanState.new(self)
+    def stack
+      @stack ||= [get_state(:root)]
+    end
+
+    def state
+      stack.last or raise 'empty stack!'
     end
 
     def reset!
       @scan_state = nil
 
       self.class.start_procs.each do |pr|
-        scan_state.instance_eval(&pr)
+        instance_eval(&pr)
       end
     end
 
     def stream_tokens(stream, &b)
-      scan_state.scanner = stream
-
-      until scan_state.eos?
+      until stream.eos?
         debug { "lexer: #{self.class.tag}" }
-        debug { "stack: #{scan_state.stack.map(&:name).inspect}" }
-        debug { "stream: #{scan_state.scanner.peek(20).inspect}" }
-        success = step(get_state(scan_state.state), scan_state, &b)
+        debug { "stack: #{stack.map(&:name).inspect}" }
+        debug { "stream: #{stream.peek(20).inspect}" }
+        success = step(get_state(state), stream, &b)
 
         if !success
           debug { "    no match, yielding Error" }
-          b.call(Token['Error'], scan_state.scanner.getch)
+          b.call(Token['Error'], stream.getch)
         end
       end
     end
 
-    def step(state, scan_state, &b)
+    def step(state, stream, &b)
       state.rules.each do |rule|
-        return true if run_rule(rule, scan_state, &b)
+        return true if run_rule(rule, stream, &b)
       end
 
       false
     end
 
-  private
-    def run_rule(rule, scan_state, &b)
+    def run_rule(rule, stream, &b)
       case rule
       when String
         debug { "  entering mixin #{rule}" }
-        res = step(get_state(rule), scan_state, &b)
+        res = step(get_state(rule), stream, &b)
         debug { "  exiting  mixin #{rule}" }
         res
       when Rule
         debug { "  trying #{rule.inspect}" }
-        scan_state.scan(rule.re) do |match|
-          debug { "    got #{match[0].inspect}" }
+        scan(stream, rule.re) do
+          debug { "    got #{stream[0].inspect}" }
 
-          scan_state.run_callback(&rule.callback).each do |tok, res|
+          run_callback(stream, &rule.callback).each do |tok, res|
             debug { "    yielding #{tok.to_s.inspect}, #{res.inspect}" }
             b.call(Token[tok], res)
           end
@@ -448,5 +336,91 @@ module Rouge
       end
     end
 
+    def run_callback(stream, &callback)
+      Enumerator.new do |y|
+        @output_stream = y
+        @group_count = 0
+        @last_matches = stream
+        instance_exec(stream, &callback)
+        @last_matches = nil
+        @output_stream = nil
+      end
+    end
+
+    MAX_NULL_STEPS = 5
+    def scan(scanner, re, &b)
+      @null_steps ||= 0
+
+      if @null_steps >= MAX_NULL_STEPS
+        debug { "    too many scans without consuming the string!" }
+        return false
+      end
+
+      scanner.scan(re)
+
+      if scanner.matched?
+        if scanner.matched_size == 0
+          @null_steps += 1
+        else
+          @null_steps = 0
+        end
+
+        yield self
+        return true
+      end
+
+      return false
+    end
+
+    def token(tok, val=:__absent__)
+      val = @last_matches[0] if val == :__absent__
+      val ||= ''
+
+      raise 'no output stream' unless @output_stream
+
+      @output_stream << [Token[tok], val]
+    end
+
+    def group(tok)
+      token(tok, @last_matches[@group_count += 1])
+    end
+
+    def delegate(lexer, text=nil)
+      debug { "    delegating to #{lexer.inspect}" }
+      text ||= @last_matches[0]
+
+      lexer.lex(text, :continue => true) do |tok, val|
+        debug { "    delegated token: #{tok.inspect}, #{val.inspect}" }
+        token(tok, val)
+      end
+    end
+
+    def push(state_name=nil, &b)
+      # use the top of the stack by default
+      if state_name || b
+        push_state = state.relative_state(state_name, &b)
+      else
+        push_state = self.state
+      end
+
+      debug { "    pushing #{push_state.name}" }
+      stack.push(push_state)
+    end
+
+    def pop!
+      raise 'empty stack!' if stack.empty?
+
+      debug { "    popping stack" }
+      stack.pop
+    end
+
+    def in_state?(state_name)
+      stack.map(&:name).include? state_name.to_s
+    end
+
+    def state?(state_name)
+      state_name.to_s == state.name
+    end
+
   end
 end

data/lib/rouge/lexers/erb.rb

@@ -10,8 +10,6 @@ module Rouge
         return 0.4 if text =~ /<%.*%>/
       end
 
-      attr_reader :parent
-      attr_reader :ruby_lexer
       def initialize(opts={})
         @parent = opts.delete(:parent) || 'html'
         if @parent.is_a? String
@@ -24,6 +22,11 @@ module Rouge
         super(opts)
       end
 
+      start do
+        @parent.reset!
+        @ruby_lexer.reset!
+      end
+
       open  = /<%%|<%=|<%#|<%-|<%/
       close = /%%>|-%>|%>/
 
@@ -33,7 +36,7 @@ module Rouge
         rule open, 'Comment.Preproc', :ruby
 
         rule /.+?(?=#{open})|.+/m do
-          delegate lexer.parent
+          delegate @parent
         end
       end
 
@@ -46,7 +49,7 @@ module Rouge
         rule close, 'Comment.Preproc', :pop!
 
         rule /.+?(?=#{close})|.+/m do
-          delegate lexer.ruby_lexer
+          delegate @ruby_lexer
         end
       end
     end

data/lib/rouge/lexers/make.rb

@@ -20,15 +20,16 @@ module Rouge
 
       line = /(?:\\.|\\\n|[^\\\n])*/m
 
-      attr_reader :shell
       def initialize(opts={})
         super
         @shell = Shell.new(opts)
       end
 
+      start { @shell.reset! }
+
       state :root do
         rule /^(?:[\t ]+.*\n|\n)+/ do
-          delegate lexer.shell
+          delegate @shell
         end
 
         # rule /\$\((?:.*\\\n|.*\n)+/ do
@@ -86,14 +87,14 @@ module Rouge
           push :shell_line
         end
 
-        rule(//) { lexer.shell.reset!; pop! }
+        rule(//) { @shell.reset!; pop! }
       end
 
       state :shell do
         # macro interpolation
         rule /\$\(\s*[a-z_]\w*\s*\)/i, 'Name.Variable'
-        rule(/.+?(?=\$\(|\)|\n)/m) { delegate lexer.shell }
-        rule(/\$\(|\)|\n/) { delegate lexer.shell }
+        rule(/.+?(?=\$\(|\)|\n)/m) { delegate @shell }
+        rule(/\$\(|\)|\n/) { delegate @shell }
       end
 
       state :shell_line do

data/lib/rouge/lexers/php.rb

@@ -32,7 +32,7 @@ module Rouge
       end
 
       start do
-        push :php if lexer.start_inline?
+        push :php if start_inline?
       end
 
       keywords = %w(

data/lib/rouge/themes/thankful_eyes.rb

@@ -28,7 +28,7 @@ module Rouge
             'Generic.Error', :fg => :aluminum1, :bg => :scarletred2
       style 'Keyword', :fg => :sandy, :bold => true
       style 'Operator',
-            'Punctuation', :fg => :backlit, :bold => true
+            'Punctuation', :fg => :backlit
       style 'Generic.Deleted', :fg => :scarletred2
       style 'Generic.Inserted', :fg => :go_get_it
       style 'Generic.Emph', :italic => true
@@ -44,17 +44,17 @@ module Rouge
             'Name.Class',
             'Name.Decorator',
             'Name.Namespace',
-            'Name.Label',
             'Name.Builtin.Pseudo',
-            'Name.Exception',
-            'Name.Tag', :fg => :go_get_it, :bold => true
+            'Name.Exception', :fg => :go_get_it, :bold => true
+      style 'Name.Label',
+            'Name.Tag', :fg => :schrill, :bold => true
       style 'Literal.Number',
             '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', :fg => :sandy
+      style 'Name.Builtin', :bold => true
       style 'Name.Entity', :fg => '#999999', :bold => true
       style 'Text.Whitespace', :fg => '#BBBBBB'
       style 'Name.Function',

data/lib/rouge/version.rb

@@ -1,5 +1,5 @@
 module Rouge
   def self.version
-    "0.1.0.rc1"
+    "0.1.0"
   end
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc1
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Jay Adkisson
@@ -88,9 +88,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: rouge
 rubygems_version: 1.8.23