tdparser 1.5.0 → 1.6.0

data/lib/tdparser/stack_parser.rb

@@ -0,0 +1,29 @@
+module TDParser
+  class StackParser < CompositeParser # :nodoc:
+    attr_reader :stack
+
+    def initialize(parser, stack)
+      @stack = stack
+      super(parser)
+    end
+
+    def call(tokens, buff)
+      x = @parsers[0].call(tokens, buff)
+      @stack.push(x)
+      x
+    end
+
+    def ==(other)
+      super(other) &&
+        (@stack == other.stack)
+    end
+
+    def same?(_r)
+      false
+    end
+
+    def to_s
+      "<stack:#{@stack.object_id}>"
+    end
+  end
+end

data/lib/tdparser/stackref_parser.rb

@@ -0,0 +1,29 @@
+module TDParser
+  class StackrefParser < ReferenceParser # :nodoc:
+    attr_reader :stack, :equality
+
+    def initialize(stack, eqsym)
+      @stack = stack
+      @equality = eqsym
+    end
+
+    def call(tokens, buff)
+      ys = @stack.pop
+      if ys.nil? || ys.empty?
+        nil
+      else
+        back_ref(ys.dup, @equality).call(tokens, buff)
+      end
+    end
+
+    def to_s
+      "<stackref:#{@stack.object_id}>"
+    end
+
+    def ==(other)
+      super(other) &&
+        @stack.equal?(other.stack) &&
+        (@equality == other.equality)
+    end
+  end
+end

data/lib/tdparser/state_parser.rb

@@ -0,0 +1,28 @@
+module TDParser
+  class StateParser < Parser # :nodoc:
+    attr_reader :state
+
+    def initialize(s)
+      @state = s
+    end
+
+    def call(_tokens, buff)
+      return unless buff.map[:state] == @state
+
+      Sequence[@state]
+    end
+
+    def to_s
+      "<state:#{@state}>"
+    end
+
+    def ==(other)
+      super(other) &&
+        (@state == other.state)
+    end
+
+    def same?(_r)
+      false
+    end
+  end
+end

data/lib/tdparser/terminal_parser.rb

@@ -0,0 +1,28 @@
+module TDParser
+  class TerminalParser < Parser # :nodoc:
+    attr_reader :symbol, :equality
+
+    def initialize(obj, eqsym)
+      @symbol   = obj
+      @equality = eqsym
+    end
+
+    def call(tokens, buff)
+      t = tokens.shift
+      buff.unshift(t)
+      return unless @symbol.__send__(@equality, t) || t.__send__(@equality, @symbol)
+
+      Sequence[t]
+    end
+
+    def ==(other)
+      (self.class == other.class) &&
+        (@symbol == other.symbol) &&
+        (@equality == other.equality)
+    end
+
+    def to_s
+      @symbol.to_s
+    end
+  end
+end

data/lib/tdparser/token_buffer.rb

@@ -0,0 +1,43 @@
+require "forwardable"
+
+module TDParser
+  class TokenBuffer # :nodoc:
+    attr_accessor :map, :state
+
+    def initialize(*args)
+      @array = Array.new(args)
+      @map = {}
+    end
+
+    def [](idx)
+      case idx
+      when Symbol, String
+        @map[idx]
+      else
+        @array[idx]
+      end
+    end
+
+    def []=(idx, val)
+      case idx
+      when Symbol, String
+        @map[idx] = val
+      else
+        @array[idx] = val
+      end
+    end
+
+    def clear
+      @array.clear
+      @map.clear
+    end
+
+    class << self
+      alias [] new
+    end
+
+    extend Forwardable
+    def_delegators :@array, :each, :unshift, :insert, :reverse, :join, :pop, :push, :to_a
+    include Enumerable
+  end
+end

data/lib/tdparser/token_generator.rb

@@ -0,0 +1,43 @@
+module TDParser
+  class TokenGenerator
+    def initialize(args = nil, &block)
+      enumerator = Enumerator.new do |y|
+        if args
+          args.each { |arg| y << arg }
+        else
+          block.call(y)
+        end
+      end
+      @enumerator = enumerator
+
+      @buffer = []
+    end
+
+    def next
+      @enumerator.next
+    end
+
+    def next?
+      @enumerator.peek
+      true
+    rescue StopIteration
+      false
+    end
+
+    def to_a
+      @enumerator.to_a
+    end
+
+    def shift
+      if @buffer.empty?
+        (self.next if next?)
+      else
+        @buffer.shift
+      end
+    end
+
+    def unshift(*token)
+      @buffer.unshift(*token)
+    end
+  end
+end

data/lib/tdparser/utils.rb

@@ -3,7 +3,7 @@
 require 'tdparser'
 
 module TDParser
-  class Token
+  class Token # :nodoc:
     attr_accessor :kind, :value
 
     def initialize(kind, value)
@@ -26,7 +26,7 @@ module TDParser
     end
   end
 
-  class BasicStringTokenizer
+  class BasicStringTokenizer # :nodoc:
     def self.[](rule, ignore = nil)
       new(rule, ignore)
     end
@@ -41,7 +41,7 @@ module TDParser
     def generate(str)
       scanner = StringScanner.new(str)
       TDParser::TokenGenerator.new do |x|
-        until scanner.empty?
+        until scanner.eos?
           if @ignore_pattern
             while scanner.scan(@ignore_pattern)
             end
@@ -52,7 +52,6 @@ module TDParser
               next unless reg =~ sstr
 
               x.yield(Token.new(kind, sstr))
-              yielded = true
               break
             end
           else
@@ -70,7 +69,7 @@ module TDParser
     end
   end
 
-  class WaitingTokenGenerator < TDParser::TokenGenerator
+  class WaitingTokenGenerator < TDParser::TokenGenerator # :nodoc:
     def initialize(*args)
       super(*args)
       @terminated = false

data/lib/tdparser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TDParser
-  VERSION = '1.5.0'
+  VERSION = '1.6.0'
 end

data/lib/tdparser/xml.rb

@@ -5,20 +5,22 @@ require 'rexml/parsers/pullparser'
 require 'rexml/document'
 
 module TDParser
-  module XMLParser
-    class XMLTokenGenerator < TDParser::TokenGenerator
-      def initialize(src)
-        @xparser = REXML::Parsers::BaseParser.new(src)
-        super()  do |g|
-          while @xparser.has_next?
-            e = @xparser.pull
-            g.yield(e)
-          end
+  class XMLTokenGenerator < TDParser::TokenGenerator
+    def initialize(src)
+      @xparser = REXML::Parsers::BaseParser.new(src)
+      super()  do |g|
+        while @xparser.has_next?
+          e = @xparser.pull
+          g.yield(e)
         end
       end
     end
+  end
+
+  module XMLParser
+    XMLTokenGenerator = ::TDParser::XMLTokenGenerator # TODO: Delete in later version
 
-    class XArray < Array
+    class XArray < Array # :nodoc:
       def ===(ary)
         return true if super(ary)
         return false unless ary.is_a?(Array)
@@ -34,7 +36,7 @@ module TDParser
       end
     end
 
-    class XHash < Hash
+    class XHash < Hash # :nodoc:
       def ===(h)
         return true if super(h)
         return false unless h.is_a?(Hash)