citrus 1.0.0

data/test/and_predicate_test.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/helper'
+
+class AndPredicateTest < Test::Unit::TestCase
+
+  def test_terminal?
+    rule = AndPredicate.new
+    assert_equal(false, rule.terminal?)
+  end
+
+  def test_match
+    rule = AndPredicate.new('a')
+
+    match = rule.match(input('b'))
+    assert_equal(nil, match)
+
+    match = rule.match(input('a'))
+    assert(match)
+    assert_equal('', match.text)
+    assert_equal(0, match.length)
+  end
+
+  def test_to_s
+    rule = AndPredicate.new('a')
+    assert_equal('&"a"', rule.to_s)
+  end
+
+end

data/test/calc_peg_test.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/helper'
+Citrus.load(File.dirname(__FILE__) + '/../examples/calc')
+
+class CalcPEGTest < Test::Unit::TestCase
+  include CalcTests
+end

data/test/calc_sugar_test.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/helper'
+require File.dirname(__FILE__) + '/../examples/calc_sugar'
+
+class CalcSugarTest < Test::Unit::TestCase
+  include CalcTests
+end

data/test/calc_test.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/helper'
+require File.dirname(__FILE__) + '/../examples/calc'
+
+class CalcTest < Test::Unit::TestCase
+  include CalcTests
+end

data/test/choice_test.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ChoiceTest < Test::Unit::TestCase
+
+  def test_terminal?
+    rule = Choice.new
+    assert_equal(false, rule.terminal?)
+  end
+
+  def test_match
+    rule = Choice.new(%w<a b>)
+
+    match = rule.match(input(''))
+    assert_equal(nil, match)
+
+    match = rule.match(input('a'))
+    assert(match)
+    assert_equal('a', match.text)
+    assert_equal(1, match.length)
+  end
+
+  def test_match_multi
+    rule = Choice.new(%w<a b>)
+
+    match = rule.match(input('ab'))
+    assert(match)
+    assert_equal('a', match.text)
+    assert_equal(1, match.length)
+
+    match = rule.match(input('ba'))
+    assert(match)
+    assert_equal('b', match.text)
+    assert_equal(1, match.length)
+  end
+
+  def test_match_embed
+    rule = Choice.new([ /\d+/, Choice.new(%w<+ ->) ])
+
+    match = rule.match(input('1+'))
+    assert(match)
+    assert_equal('1', match.text)
+    assert_equal(1, match.length)
+
+    match = rule.match(input('+1'))
+    assert(match)
+    assert_equal('+', match.text)
+    assert_equal(1, match.length)
+  end
+
+  def test_to_s
+    rule = Choice.new(%w<a b>)
+    assert_equal('"a" | "b"', rule.to_s)
+  end
+
+  def test_to_s_embed
+    rule1 = Choice.new(%w<a b>)
+    rule2 = Choice.new(%w<c d>)
+    rule = Choice.new([rule1, rule2])
+    assert_equal('("a" | "b") | ("c" | "d")', rule.to_s)
+  end
+
+end

data/test/expression_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ExpressionTest < Test::Unit::TestCase
+
+  def test_terminal?
+    rule = Expression.new
+    assert(rule.terminal?)
+  end
+
+  def test_match
+    rule = Expression.new(/\d+/)
+    match = rule.match(input('123 456'))
+    assert(match)
+    assert_equal('123', match.text)
+    assert_equal(3, match.length)
+  end
+
+  def test_match_failure
+    rule = Expression.new(/\d+/)
+    match = rule.match(input(' 456'))
+    assert_equal(nil, match)
+  end
+
+  def test_to_s
+    rule = Expression.new(/\d+/)
+    assert_equal('/\\d+/', rule.to_s)
+  end
+
+end

data/test/fixed_width_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/helper'
+
+class FixedWidthTest < Test::Unit::TestCase
+
+  def test_terminal?
+    rule = FixedWidth.new
+    assert(rule.terminal?)
+  end
+
+  def test_match
+    rule = FixedWidth.new('abc')
+    match = rule.match(input('abc'))
+    assert(match)
+    assert_equal('abc', match.text)
+    assert_equal(3, match.length)
+  end
+
+  def test_match_short
+    rule = FixedWidth.new('abc')
+    match = rule.match(input('ab'))
+    assert_equal(nil, match)
+  end
+
+  def test_match_long
+    rule = FixedWidth.new('abc')
+    match = rule.match(input('abcd'))
+    assert(match)
+    assert_equal('abc', match.text)
+    assert_equal(3, match.length)
+  end
+
+  def test_to_s
+    rule = FixedWidth.new('abc')
+    assert_equal('"abc"', rule.to_s)
+  end
+
+end

data/test/grammar_test.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/helper'
+
+class GrammarTest < Test::Unit::TestCase
+
+  def test_new
+    Grammar.new do |g|
+      assert_kind_of(Module, g)
+      assert(g.include?(Grammar))
+    end
+  end
+
+  def test_name
+    assert_equal("Test::Unit::TestCase::TestGrammar", TestGrammar.name)
+  end
+
+  def test_no_name
+    grammar = Grammar.new
+    assert_equal('', grammar.name)
+  end
+
+  def test_rule_names
+    assert_equal([:alpha, :num, :alphanum], TestGrammar.rule_names)
+  end
+
+  def test_has_name
+    assert(TestGrammar.has_rule?('alpha'))
+    assert(TestGrammar.has_rule?(:alpha))
+  end
+
+  def test_doesnt_have_name
+    assert_equal(false, TestGrammar.has_rule?(:value))
+  end
+
+  def test_parse_fixed_width
+    grammar = Grammar.new {
+      rule(:abc) { 'abc' }
+    }
+    match = grammar.parse('abc')
+    assert(match)
+    assert_equal('abc', match.text)
+    assert_equal(3, match.length)
+  end
+
+  def test_parse_expression
+    grammar = Grammar.new {
+      rule(:alpha) { /[a-z]+/i }
+    }
+    match = grammar.parse('abc')
+    assert(match)
+    assert_equal('abc', match.text)
+    assert_equal(3, match.length)
+  end
+
+  def test_parse_sequence
+    grammar = Grammar.new {
+      rule(:num) { all(1, 2, 3) }
+    }
+    match = grammar.parse('123')
+    assert(match)
+    assert_equal('123', match.text)
+    assert_equal(3, match.length)
+  end
+
+  def test_parse_sequence_long
+    grammar = Grammar.new {
+      rule(:num) { all(1, 2, 3) }
+    }
+    assert_raise ParseError do
+      match = grammar.parse('1234')
+    end
+  end
+
+  def test_parse_sequence_short
+    grammar = Grammar.new {
+      rule(:num) { all(1, 2, 3) }
+    }
+    assert_raise ParseError do
+      match = grammar.parse('12')
+    end
+  end
+
+  def test_parse_choice
+    grammar = Grammar.new {
+      rule(:alphanum) { any(/[a-z]/i, 0..9) }
+    }
+
+    match = grammar.parse('a')
+    assert(match)
+    assert_equal('a', match.text)
+    assert_equal(1, match.length)
+
+    match = grammar.parse('1')
+    assert(match)
+    assert_equal('1', match.text)
+    assert_equal(1, match.length)
+  end
+
+  def test_parse_choice_miss
+    grammar = Grammar.new {
+      rule(:alphanum) { any(/[a-z]/, 0..9) }
+    }
+    assert_raise ParseError do
+      match = grammar.parse('A')
+    end
+  end
+
+  def test_parse_recurs
+    grammar = Grammar.new {
+      rule(:paren) { any(['(', :paren, ')'], /[a-z]/) }
+    }
+
+    match = grammar.parse('a')
+    assert(match)
+    assert_equal('a', match.text)
+    assert_equal(1, match.length)
+
+    match = grammar.parse('((a))')
+    assert(match)
+    assert('((a))', match.text)
+    assert(5, match.length)
+
+    str = ('(' * 200) + 'a' + (')' * 200)
+    match = grammar.parse(str)
+    assert(match)
+    assert(str, match.text)
+    assert(str.length, match.length)
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,143 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'test/unit'
+require 'citrus/debug'
+
+class Test::Unit::TestCase
+  include Citrus
+
+  def input(str='')
+    Input.new(str)
+  end
+
+  module TestGrammar
+    include Citrus::Grammar
+
+    rule :alpha do
+      /[a-zA-Z]/
+    end
+
+    rule :num do
+      ext(/[0-9]/) {
+        def value
+          text.to_i
+        end
+      }
+    end
+
+    rule :alphanum do
+      any(:alpha, :num)
+    end
+  end
+
+  class EqualRule
+    include Citrus::Rule
+
+    def initialize(value)
+      @value = value
+    end
+
+    def match(input, offset=0)
+      create_match(@value.to_s.dup, offset) if @value.to_s == input.string
+    end
+  end
+
+  module CalcTests
+    def test_int
+      match = Calc.parse('3')
+      assert(match)
+      assert_equal('3', match.text)
+      assert_equal(1, match.length)
+      assert_equal(3, match.value)
+    end
+
+    def test_float
+      match = Calc.parse('1.5')
+      assert(match)
+      assert_equal('1.5', match.text)
+      assert_equal(3, match.length)
+      assert_equal(1.5, match.value)
+    end
+
+    def test_addition
+      match = Calc.parse('1+2')
+      assert(match)
+      assert_equal('1+2', match.text)
+      assert_equal(3, match.length)
+      assert_equal(3, match.value)
+    end
+
+    def test_addition_multi
+      match = Calc.parse('1+2+3')
+      assert(match)
+      assert_equal('1+2+3', match.text)
+      assert_equal(5, match.length)
+      assert_equal(6, match.value)
+    end
+
+    def test_addition_float
+      match = Calc.parse('1.5+3')
+      assert(match)
+      assert_equal('1.5+3', match.text)
+      assert_equal(5, match.length)
+      assert_equal(4.5, match.value)
+    end
+
+    def test_subtraction
+      match = Calc.parse('3-2')
+      assert(match)
+      assert_equal(1, match.value)
+    end
+
+    def test_subtraction_float
+      match = Calc.parse('4.5-3')
+      assert(match)
+      assert_equal('4.5-3', match.text)
+      assert_equal(5, match.length)
+      assert_equal(1.5, match.value)
+    end
+
+    def test_multiplication
+      match = Calc.parse('2*5')
+      assert(match)
+      assert_equal(10, match.value)
+    end
+
+    def test_multiplication_float
+      match = Calc.parse('1.5*3')
+      assert(match)
+      assert_equal('1.5*3', match.text)
+      assert_equal(5, match.length)
+      assert_equal(4.5, match.value)
+    end
+
+    def test_division
+      match = Calc.parse('20/5')
+      assert(match)
+      assert_equal(4, match.value)
+    end
+
+    def test_division_float
+      match = Calc.parse('4.5/3')
+      assert(match)
+      assert_equal('4.5/3', match.text)
+      assert_equal(5, match.length)
+      assert_equal(1.5, match.value)
+    end
+
+    def test_complex
+      match = Calc.parse('7*4+3.5*(4.5/3)')
+      assert(match)
+      assert_equal('7*4+3.5*(4.5/3)', match.text)
+      assert_equal(33.25, match.value)
+    end
+
+    def test_complex_spaced
+      match = Calc.parse('7 * 4 + 3.5 * (4.5 / 3)')
+      assert(match)
+      assert_equal(33.25, match.value)
+    end
+  end
+
+end