rsec 0.3.2

data/lib/rsec/parsers/repeat.rb

@@ -0,0 +1,90 @@
+module Rsec
+
+  # the content appears 1 or 0 time
+  class Maybe < Unary
+    def _parse ctx
+      save = ctx.pos
+      res = some._parse ctx
+      if INVALID[res]
+        ctx.pos = save
+        []
+      else
+        [res]
+      end
+    end
+  end
+
+  # repeat from range.begin.abs to range.end.abs <br/>
+  # note: range's max should always be > 0<br/>
+  #       see also helpers
+  class RepeatRange
+    include Parser
+
+    def self.[] base, range
+      self.new base, range
+    end
+
+    def initialize base, range
+      @base = base
+      @at_least = range.min.abs
+      @optional = range.max - @at_least
+    end
+
+    def _parse ctx
+      rp_node = []
+      @at_least.times do
+        res = @base._parse ctx
+        return INVALID if INVALID[res]
+        rp_node.push res
+      end
+      @optional.times do
+        save = ctx.pos
+        res = @base._parse ctx
+        if INVALID[res]
+          ctx.pos = save
+          break
+        end
+        rp_node.push res
+      end
+      rp_node
+    end
+  end
+
+  # matches exactly n.abs times repeat<br/>
+  class RepeatN < Struct.new(:base, :n)
+    include Parser
+    def _parse ctx
+      n.times.inject([]) do |rp_node|
+        res = base._parse ctx
+        return INVALID if INVALID[res]
+        rp_node.push res
+      end
+    end
+  end
+
+  # repeat at least n.abs times <- [n, inf) <br/>
+  class RepeatAtLeastN < Struct.new(:base, :n)
+    include Parser
+    def _parse ctx
+      rp_node = []
+      n.times do
+        res = base._parse(ctx)
+        return INVALID if INVALID[res]
+        rp_node.push res
+      end
+      # note this may be an infinite action
+      # returns if the pos didn't change
+      loop do
+        save = ctx.pos
+        res = base._parse ctx
+        if (INVALID[res] or ctx.pos == save)
+          ctx.pos = save
+          break
+        end
+        rp_node.push res
+      end
+      rp_node
+    end
+  end
+
+end

data/lib/rsec/parsers/seq.rb

@@ -0,0 +1,94 @@
+module Rsec
+
+  # sequence combinator<br/>
+  # result in an array
+  class Seq < Unary
+    def _parse ctx
+      some.map do |e|
+        res = e._parse ctx
+        return INVALID if INVALID[res]
+        res
+      end
+    end
+  end
+
+  # sequence combinator<br/>
+  # the result is the result of the parser at idx
+  class SeqOne < Struct.new(:parsers, :idx)
+    include Parser
+
+    def _parse ctx
+      ret = INVALID
+      parsers.each_with_index do |p, i|
+        res = p._parse ctx
+        return INVALID if INVALID[res]
+        ret = res if i == idx
+      end
+      ret
+    end
+  end
+
+  # skips skipper between tokens
+  class Seq_ < Struct.new(:first, :rest, :skipper)
+    include Parser
+
+    def _parse ctx
+      res = first._parse ctx
+      return INVALID if INVALID[res]
+      ret = [res]
+
+      rest.each do |e|
+        return INVALID if INVALID[skipper._parse ctx]
+        res = e._parse ctx
+        return INVALID if INVALID[res]
+        ret << res
+      end
+      ret
+    end
+  end
+  
+  # skips skipper between tokens
+  class SeqOne_ < Struct.new(:first, :rest, :skipper, :idx)
+    include Parser
+
+    def _parse ctx
+      ret = INVALID
+
+      res = first._parse ctx
+      return INVALID if INVALID[res]
+      ret = res if 0 == idx
+
+      check = idx - 1
+      rest.each_with_index do |p, i|
+        return INVALID if INVALID[skipper._parse ctx]
+        res = p._parse ctx
+        return INVALID if INVALID[res]
+        ret = res if i == check
+      end
+      ret
+    end
+  end
+
+  # unbox result size
+  # only work for seq and join and maybe'ed seq and join
+  class Unbox < Unary
+    def _parse ctx
+      res = some._parse ctx
+      return INVALID if INVALID[res]
+      res.size == 1 ? res.first : res
+    end
+  end
+
+  # inner
+  # only work for seq
+  class Inner < Unary
+    def _parse ctx
+      res = some._parse ctx
+      return INVALID if INVALID[res]
+      res.shift
+      res.pop
+      res
+    end
+  end
+
+end

data/lib/rsec/utils.rb

@@ -0,0 +1,116 @@
+# coding: utf-8
+
+module Rsec #:nodoc:
+
+  # error class for rescue
+  class SyntaxError < StandardError
+    attr_reader :msg, :line_text, :line, :col
+
+    # constructor
+    def initialize msg, line_text, line, col
+      @msg, @line_text, @line, @col = msg, line_text, line, col
+    end
+
+    # info with source position
+    def to_s
+      %Q<#@msg\n#@line_text\n#{' ' * @col}^>
+    end
+  end
+
+  # parse context inherits from StringScanner<br/>
+  # <br/>
+  # attributes:<br/>
+  # <pre>
+  #   [R]  string: string to parse
+  #   [RW] pos: current position
+  #   [R]  source: source file name
+  #   [R]  current_line_text: current line text
+  #   [R]  cache: for memoization
+  # </pre>
+  class ParseContext < StringScanner
+    attr_reader :source, :cache, :last_fail_pos
+    attr_accessor :attr_names
+
+    def initialize str, source
+      super(str)
+      @source = source
+      @cache = {}
+      @last_fail_pos = 0
+      @last_fail_mask = 0
+    end
+    
+    # clear packrat parser cache
+    def clear_cache
+      @cache.clear
+    end
+
+    # add fail message
+    def on_fail mask
+      if pos > @last_fail_pos
+        @last_fail_pos = pos
+        @last_fail_mask = mask
+      elsif pos == @last_fail_pos
+        @last_fail_mask |= mask
+      end
+    end
+
+    # generate parse error
+    def generate_error source
+      if self.pos <= @last_fail_pos
+        line = line @last_fail_pos
+        col = col @last_fail_pos
+        line_text = line_text @last_fail_pos
+        expect_tokens = Fail.get_tokens @last_fail_mask
+        expects = ", expect token [ #{expect_tokens.join ' | '} ]"
+      else
+        line = line pos
+        col = col pos
+        line_text = line_text pos
+        expects = nil
+      end
+      msg = "\nin #{source}:#{line} at #{col}#{expects}"
+      SyntaxError.new msg, line_text, line, col
+    end
+
+    # get line number
+    def line pos
+      string[0...pos].count("\n") + 1
+    end
+
+    # get column number: position in line
+    def col pos
+      return 1 if pos == 0
+      newline_pos = string.rindex "\n", pos - 1
+      if newline_pos
+        pos - newline_pos
+      else
+        pos + 1
+      end
+    end
+
+    # get line text containing pos
+    # the text is 80 at most
+    def line_text pos
+      from = string.rindex "\n", pos
+      from = from ? from + 1 : 0
+      from = pos - 40 if (from < pos - 40)
+
+      to = string.index("\n", pos)
+      to = to ? to - 1 : string.size
+      to = pos + 40 if (to > pos + 40)
+
+      string[from..to]
+    end
+  end
+
+  # the invalid token
+  INVALID = Object.new
+  class << INVALID
+    def to_str
+      'INVALID_TOKEN'
+    end
+    alias :[] :==
+    alias inspect to_str
+  end
+
+end

data/license.txt

@@ -0,0 +1 @@
+As Ruby's

data/readme.rdoc

@@ -0,0 +1,30 @@
+== Parser / Regexp Combinator for Ruby. 
+
+Easier and faster than treetop / rex+racc.
+
+It's ruby1.9 only.
+
+== License 
+
+As Ruby's
+
+== Install 
+
+The pure Ruby gem is fast enough (about 10+x faster than treetop generated code):
+
+    gem in rsec
+
+For extreme performance under C Ruby:
+
+	gem in rsec-ext
+
+It is about 30% faster than Haskell Parsec in the benchmark.
+
+== Doc
+
+http://rsec.heroku.com
+
+== Code
+
+http://github.com/luikore/rsec/tree/master
+

data/test/helpers.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+$:.unshift "#{File.dirname(__FILE__)}/../ext"
+require "rsec"
+include Rsec::Helpers
+require "test/unit"
+
+TC = Test::Unit::TestCase
+class TC
+  INVALID = Rsec::INVALID
+end
+
+module Test::Unit::Assertions
+  alias ase assert_equal
+  def asr
+    assert_raise(Rsec::SyntaxError) { yield }
+  end
+  # assert parse returns s
+  def asp s, p
+    assert_equal(s, p.parse(s))
+  end
+end
+

data/test/test_branch.rb

@@ -0,0 +1,14 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestBranch < TC
+  def test_branch
+    p = 'a'.r | /\d+/ | seq('c', 'd')
+    ase ['c','d'], p.parse('cd')
+    ase '3', p.parse('3')
+    ase INVALID, p.parse('c')
+
+    p = 'x'.r | 'y'
+    ase INVALID, p.parse('')
+    ase 'y', p.parse('y')
+  end
+end

data/test/test_examples.rb

@@ -0,0 +1,36 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+$:.unshift "#{File.dirname __FILE__}/../examples"
+require "arithmetic"
+require "s_exp"
+
+class TestExamples < TC
+  def initialize *xs
+    super(*xs)
+    @a = arithmetic()
+    @s_exp = s_exp()
+  end
+  
+  def test_arithmetic
+    # step by step
+    s = '1'
+    ase eval(s), @a.parse(s)
+    s = '3+ 2'
+    ase eval(s), @a.parse(s)
+    s = '5-2*1'
+    ase eval(s), @a.parse(s)
+    s = '(2)'
+    ase eval(s), @a.parse(s)
+    s = '1+(2- (3+ 4))/5 * 2*4 +1'
+    ase eval(s), @a.parse(s)
+  end
+  
+  def test_s_exp
+    res = @s_exp.parse! '(a 3 4.3 (add 1 3) (minus (multi 4 5)))'
+    expected = ['a', 3.0, 4.3, ['add', 1, 3], ['minus', ['multi', 4, 5]]]
+    ase expected, res
+    
+    res = @s_exp.parse! '(a (3) ce2 (add 1 3))'
+    expected = ['a', 3.0, 'ce2', ['add', 1, 3]]
+    ase expected, res
+  end
+end

data/test/test_join.rb

@@ -0,0 +1,52 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestJoin < TC
+  def test_join
+    p0 = /\w{1,3}/.r.join '+'
+    ase ['abc'], p0.eof.parse('abc')
+    ase ['a','+','bc','+','d'], p0.parse('a+bc+d')
+    ase INVALID, p0.eof.parse('a+ bc+d')
+    ase INVALID, p0.eof.parse('a+b+')
+
+    p1 = seq(/[a-z]{1,3}/, '3')[0].join seq(/\s/.r, '+', /\s/)[1]
+    ase ['abc'], p1.eof.parse('abc3')
+    ase %w[a + bc + d], p1.parse('a3 + bc3 + d3')
+    ase INVALID, p1.eof.parse('a+b+')
+  end
+
+  def test_nest_join
+    p = 'a'.r.join(/\s*\*\s*/.r).join(/\s*\+\s*/.r)
+    ase [['a'], ' + ', ['a', ' * ', 'a'], ' +', ['a']], p.parse('a + a * a +a')
+  end
+
+  def test_join_with_mapping_block
+    p = 'a'.r.join('+'){|res| res.grep /\+/ }
+    ase ['+', '+'], p.parse('a+a+a')
+    ase [], p.parse('a')
+  end
+
+  def test_join_even
+    p = 'a'.r.join('+').even
+    ase %w[a a a], p.parse('a+a+a')
+    ase %w[a], p.parse('a')
+    ase INVALID, p.eof.parse('a+')
+    ase INVALID, p.parse('b')
+    ase INVALID, p.parse('')
+  end
+
+  def test_join_odd
+    p = 'a'.r.join('+').odd
+    ase %w[+ +], p.parse('a+a+a')
+    ase [], p.parse('a')
+    ase INVALID, p.parse('')
+    ase INVALID, p.parse('+')
+    ase INVALID, p.parse('b')
+  end
+
+  def test_nest_join_even_odd
+    p = 'a'.r.join('+').odd.join('*')
+    ase [['+'], '*', []], p.parse('a+a*a')
+    p = 'a'.r.join('+').even.join('*')
+    ase [['a','a'], '*', ['a']], p.parse('a+a*a')
+  end
+end