rsec 0.3.2

data/test/test_lookahead.rb

@@ -0,0 +1,16 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestLookAhead < TC
+  def test_lookahead
+    p1 = 'a'.r & 'b'
+    p2 = /\w/.r
+    p = seq(p1, p2)
+    ase ['a', 'b'], p.parse('ab')
+    ase INVALID, p.parse('ac')
+    
+    p1 = 'a'.r ^ 'b'
+    p = seq(p1, p2)
+    ase ['a', 'c'], p.parse('ac')
+    ase INVALID, p.parse('ab')
+  end
+end

data/test/test_misc.rb

@@ -0,0 +1,56 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestMisc < TC
+  def test_lazy
+    p1 = nil
+    p2 = lazy{p1}
+    
+    p1 = '3'.r
+    asp '3', p2
+    
+    p1 = '4'.r
+    asp '3', p2
+
+    p2 = lazy{p7} # don't have to define p7 before lazy
+    p7 = '5'.r
+    asp '5',p2
+  end
+  
+  def test_eof
+    p = ''.r.eof
+    asp '', p
+    ase INVALID, p.parse('a')
+  end
+
+  def test_cache
+    p1 = seq('a', seq('b', 'c'))
+    p = seq(p1.cached, 'd')
+    ase [['a',['b','c']],'d'], p.parse('abcd')
+
+    # with map block
+    p = seq(p1.cached{ 'mapped' }, 'd')
+    ase ['mapped', 'd'], p.parse('abcd')
+  end
+  
+  def test_map
+    p = /\w/.r.map{|n| n*2}
+    ase 'bb', p.parse('b')
+    ase INVALID, p.parse('.')
+  end
+  
+  def test_fail
+    p = 'v'.r.fail 'omg!'
+    p.eof.parse! 'u'
+    assert false, "should raise syntax error"
+  rescue Rsec::SyntaxError => e
+    assert e.to_s.index 'omg!'
+  end
+  
+  def test_fail_with_block
+    p = 'v'.r.fail('omg!'){ 'should fail' }
+    p.eof.parse! 'u'
+    assert false, "should raise syntax error"
+  rescue Rsec::SyntaxError => e
+    assert e.to_s.index 'omg!'
+  end
+end

data/test/test_one_of.rb

@@ -0,0 +1,39 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestOneOf < TC
+  def test_one_of
+    p = one_of('abcd')
+    ase 'c', p.parse('c')
+    ase INVALID, p.parse('e')
+    p = one_of('+=')
+    ase '=', p.parse('=')
+
+    begin
+      p = one_of('')
+      assert false, "should raise exception for empty string"
+    rescue
+    end
+
+    # with map block
+    p = one_of('x+'){|v| v * 2}
+    ase '++', p.parse('+')
+  end
+
+  def test_one_of_
+    p = one_of_('abcd')
+    ase 'a', p.parse('a')
+    ase INVALID, p.parse('e')
+    ase 'd', p.parse(' d ')
+    ase 'a', p.parse(' a')
+    ase 'c', p.parse('c ')
+
+    assert_raise(ArgumentError) {
+      p = one_of_('')
+    }
+
+    # with map block
+    p = one_of_('w'){'v'}
+    ase 'v', p.parse('w')
+  end
+
+end

data/test/test_pattern.rb

@@ -0,0 +1,53 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestPattern < TC
+  def test_create
+    p1 = 'x'.r
+    asp 'x', p1
+    p1 = 'abc'.r
+    asp 'abc', p1
+    
+    asr do
+      p1.eof.parse! 'abcd'
+    end
+    ase INVALID, p1.eof.parse('abcd')
+    
+    asr do 
+      p1.eof.parse! 'xabc'
+    end
+    ase INVALID, p1.eof.parse('xabc')
+
+    # with map block
+    p = 'x'.r{ 'y' }
+    ase INVALID, p.parse('y')
+    ase 'y', p.parse('x')
+  end
+
+  def test_until
+    p = 'ef'.r.until
+    asp 'xef', p
+    asp "x\nef", p
+    
+    p = 'e'.r.until
+    asp 'xe', p
+    asp "x\ne", p
+
+    # with map block
+    p = 'e'.r.until{|s| s*2}
+    ase 'xexe', p.parse('xe')
+  end
+
+  def test_word
+    p = word('abc')
+    ase INVALID, p.parse('abcd')
+    ase INVALID, seq_(p, 'd').parse('abcd')
+    ase 'abc', p.parse('abc')
+    ase ['abc', 'd'], seq_(p, 'd').parse('abc d')
+  end
+
+  def test_symbol
+    p = symbol('*')
+    ase '*', p.parse(' * ')
+  end
+
+end

data/test/test_prim.rb

@@ -0,0 +1,59 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestPrim < TC
+  def test_floating
+    [:double].each do |ty|
+      p = prim ty
+      ase INVALID, p.parse('d')
+      ase 3.2e5.round, p.parse('+3.2e5').round
+      ase INVALID, p.parse(' 4.8')
+
+      p = prim ty, allowed_sign: ''
+      ase 1.5e-3.round(4), p.parse('1.5E-3').round(4)
+      ase INVALID, p.parse('+3.0')
+
+      p = prim ty, allowed_sign: '-'
+      ase (-5.0).round, p.parse('-5').round
+      ase INVALID, p.parse('-')
+      ase INVALID, p.parse('+5')
+      ase 5.0.round, p.parse('5').round
+      
+      # with map block
+      p = prim(ty){|x| x * 2 }
+      ase 100.0.round, p.parse('50').round
+    end
+  end
+
+  def test_hex_floating
+    [:hex_double].each do |ty|
+      p = prim ty
+      ase Float('0x3.2').round(4), p.parse('0x3.2').round(4)
+
+      # with map block
+      p = prim(ty){|x| x - 0.1 }
+      ase (Float('0x3.2') - 0.1).round(4), p.parse('0x3.2').round(4)
+    end
+  end
+
+  def test_integer
+    [:int32, :unsigned_int32, :int64, :unsigned_int64].each do |ty|
+      p = prim ty
+      ase 432, p.parse('432')
+      p = prim ty, base: 4
+      ase '120'.to_i(4), p.parse('120')
+      p = prim ty, base: 35
+      ase '1ax'.to_i(35), p.parse('1ax')
+    end
+
+    p = prim :int32, allowed_signs: '-'
+    ase INVALID, p.parse('+12')
+    ase INVALID, p.parse('123333333333333333333333333333333333')
+    ase INVALID, p.parse('-')
+    ase -49, p.parse('-49')
+
+    assert_raise RuntimeError do
+      prim :unsigned_int32, allowed_signs: '+-'
+    end
+  end
+end
+

data/test/test_repeat.rb

@@ -0,0 +1,50 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestRepeat < TC
+  def test_maybe
+    [:_?, :maybe].each do |m|
+      p = seq('v', 'q').send m
+      ase [], p.parse('')
+      ase INVALID, p.eof.parse('v')
+      ase [['v', 'q']], p.parse('vq')
+
+      # with map block
+      p = seq('v', 'q').maybe {|x| x.empty? ? 'bad' : 'good' }
+      ase 'good', p.parse('vq')
+    end
+  end
+
+  def test_multiply
+    p = ('ce'.r * 3).eof
+    ase ['ce','ce','ce'], (p.parse 'cecece')
+    ase INVALID, (p.parse 'cece')
+    ase INVALID, (p.parse 'cececece')
+    
+    p = ('ce'.r * 0).eof
+    ase [], (p.parse '')
+    ase INVALID, (p.parse 'ce')
+  end
+  
+  def test_range
+    p = ('ce'.r * (2..3)).eof
+    ase INVALID, (p.parse 'ce')
+    ase ['ce','ce'], (p.parse 'cece')
+    ase INVALID, (p.parse 'cececece')
+  end
+  
+  def test_inf
+    p = ('ce'.r * (3..-1)).eof
+    ase INVALID,
+      (p.parse 'cece')
+    ase ['ce','ce','ce'],
+      (p.parse 'cecece')
+    ase ['ce','ce','ce','ce','ce'],
+      (p.parse 'cecececece')
+  end
+
+  def test_star
+    p = '*'.r.star
+    ase [], p.parse('')
+    ase %w[* * *], p.parse('***')
+  end
+end

data/test/test_rsec.rb

@@ -0,0 +1,10 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestRsec < TC
+  def test_try_skip_pattern
+    p = Rsec.try_skip_pattern 'abc'.r
+    ase Rsec::SkipPattern, p.class
+    p = Rsec.try_skip_pattern 'abc'.r.until
+    ase Rsec::SkipUntilPattern, p.class
+  end
+end

data/test/test_seq.rb

@@ -0,0 +1,51 @@
+require "#{File.dirname(__FILE__)}/helpers.rb"
+
+class TestSeq < TC
+  def test_seq
+    p = seq('a', 'b', 'c')
+    ase ['a','b','c'], p.parse('abc')
+    ase INVALID, p.parse('a')
+    ase INVALID, p.parse('b')
+    ase INVALID, p.parse('c')
+    ase INVALID, p.parse('bc')
+    ase INVALID, p.parse('ab')
+  end
+
+  def test_seq_
+    p = seq_('abc', 'ef', 'vv')
+    ase %w[abc ef vv], p.parse("abc    ef vv")
+    p = seq_('abc', 'ef', 'vv', skip: /\s+/)
+    ase %w[abc ef vv], p.parse("abc    ef vv")
+    ase INVALID, p.parse("abcef vv")
+  end
+
+  def test_seq_mix
+    p = seq('e', seq_('a','b','c'), 'd')
+    ase ['e', ['a','b','c'], 'd'], p.parse('eabcd')
+  end
+  
+  def test_seq_one
+    p = seq('a', 'b', 'c')[1]
+    ase 'b', p.parse('abc')
+    p = seq('abc', /\s*/, 'd')[2]
+    ase 'd', p.parse('abc d')
+  end
+
+  def test_seq_one_
+    p = seq_('a', 'b', 'c')[1]
+    ase 'b', p.parse('a bc')
+    p = seq_('abc', /\s*/, 'd')[2]
+    ase 'd', p.parse('abc d')
+  end
+
+  def test_fall
+    p = 'a'.r >> 'b'
+    ase 'b', p.parse!('ab')
+    p = p << 'c'
+    ase 'b', p.parse!('abc')
+
+    p = p._?
+    ase ['b'], p.eof.parse!('abc')
+    ase [], p.eof.parse!('')
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: rsec
+version: !ruby/object:Gem::Version
+  version: 0.3.2
+  prerelease: 
+platform: ruby
+authors:
+- NS
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-02-24 00:00:00.000000000 +08:00
+default_executable: 
+dependencies: []
+description: Easy and extreme fast dynamic PEG parser combinator.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- readme.rdoc
+files:
+- license.txt
+- readme.rdoc
+- lib/rsec/helpers.rb
+- lib/rsec/parser.rb
+- lib/rsec/parsers/join.rb
+- lib/rsec/parsers/misc.rb
+- lib/rsec/parsers/prim.rb
+- lib/rsec/parsers/repeat.rb
+- lib/rsec/parsers/seq.rb
+- lib/rsec/utils.rb
+- lib/rsec.rb
+- examples/arithmetic.rb
+- examples/bnf.rb
+- examples/c_minus.rb
+- examples/scheme.rb
+- examples/slow_json.rb
+- examples/s_exp.rb
+- examples/hello.scm
+- test/helpers.rb
+- test/test_branch.rb
+- test/test_examples.rb
+- test/test_join.rb
+- test/test_lookahead.rb
+- test/test_misc.rb
+- test/test_one_of.rb
+- test/test_pattern.rb
+- test/test_prim.rb
+- test/test_repeat.rb
+- test/test_rsec.rb
+- test/test_seq.rb
+- bench/bench.rb
+- bench/little.rb
+- bench/profile.rb
+has_rdoc: true
+homepage: http://rsec.heroku.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Extreme Fast Parser Combinator for Ruby
+test_files: []