yaparc 0.0.7 → 0.0.8

data/tests/test_parser.rb

@@ -15,28 +15,55 @@ class YaparcTest < Test::Unit::TestCase
 
   def test_succeed_parse
     parser = ::Yaparc::SucceedParser.new(1)
-    assert_equal [[1, "abs"]], parser.parse("abs")
-    assert_equal [[1, "abs"]], parser.tree
+    result = parser.parse("abs")
+    assert_equal 1, result.value
+    assert_equal "abs", result.input
+#    assert_equal 1, parser.tree
     result = parser.parse("abs") do |result|
-      result[0][0]
+      result
     end
-    assert_equal 1, result
+    assert_equal 1, result.value
   end
 
+#   def test_succeed_parse
+#     parser = ::Yaparc::SucceedParser.new(1)
+#     assert_equal [[1, "abs"]], parser.parse("abs")
+#     assert_equal [[1, "abs"]], parser.tree
+#     result = parser.parse("abs") do |result|
+#       result[0][0]
+#     end
+#     assert_equal 1, result
+#   end
+
   def test_fail_parse
     parser = ::Yaparc::FailParser.new
     result = parser.parse("abc")
-    assert_equal [],  result
+    assert_instance_of Fail,  result
   end
 
+#   def test_fail_parse
+#     parser = ::Yaparc::FailParser.new
+#     result = parser.parse("abc")
+#     assert_equal [],  result
+#   end
+
   def test_item_parse
     parser = ::Yaparc::ItemParser.new
     result = parser.parse("")
-    assert_equal [],  result
+    assert_instance_of Fail,  result
     result = parser.parse("abc")
-    assert_equal [["a", "bc"]],  result
+    assert_equal "a",  result.value
+    assert_equal "bc",  result.input
   end
 
+#   def test_item_parse
+#     parser = ::Yaparc::ItemParser.new
+#     result = parser.parse("")
+#     assert_equal [],  result
+#     result = parser.parse("abc")
+#     assert_equal [["a", "bc"]],  result
+#   end
+
   def test_satisfy_parse
     is_integer = lambda do |i|
       begin
@@ -48,11 +75,12 @@ class YaparcTest < Test::Unit::TestCase
     end
     parser = SatisfyParser.new(is_integer)
     result = parser.parse("123")
-    assert_equal [["1", "23"]],  result
+    assert_equal "1",  result.value
+    assert_equal "23",  result.input
 
     parser = SatisfyParser.new(is_integer)
     result = parser.parse("abc")
-    assert_equal [],  result
+    assert_instance_of Fail,  result
 
     is_char = lambda do |i|
       begin
@@ -64,175 +92,384 @@ class YaparcTest < Test::Unit::TestCase
     end
     parser = SatisfyParser.new(is_char)
     result = parser.parse("abc")
-    assert_equal [["a", "bc"]],  result
+    assert_equal "a",  result.value
+    assert_equal "bc",  result.input
   end
 
+#   def test_satisfy_parse
+#     is_integer = lambda do |i|
+#       begin
+#         Integer(i)
+#         true
+#       rescue
+#         false
+#       end
+#     end
+#     parser = SatisfyParser.new(is_integer)
+#     result = parser.parse("123")
+#     assert_equal [["1", "23"]],  result
+
+#     parser = SatisfyParser.new(is_integer)
+#     result = parser.parse("abc")
+#     assert_equal [],  result
+
+#     is_char = lambda do |i|
+#       begin
+#         String(i)
+#         true
+#       rescue
+#         false
+#       end
+#     end
+#     parser = SatisfyParser.new(is_char)
+#     result = parser.parse("abc")
+#     assert_equal [["a", "bc"]],  result
+#   end
+
+
   def test_seq_parse
     parser = SeqParser.new(ItemParser.new, ItemParser.new) do |item1, item2|
       [item1, item2]
     end
     result = parser.parse("abcdef")
-    assert_equal [[["a", "b"], "cdef"]],  result
+    assert_equal ["a", "b"],  result.value
+    assert_equal "cdef",  result.input
 
     parser = SeqParser.new(ItemParser.new, ItemParser.new, ItemParser.new) do |item1, item2, item3|
       [item1, item3]
     end
     result = parser.parse("ABCDEF")
-    assert_equal [[["A", "C"], "DEF"]],  result
+    assert_equal ["A", "C"],  result.value
+    assert_equal "DEF",  result.input
 
     parser = SeqParser.new(ItemParser.new, ItemParser.new, ItemParser.new) do |item1, item2, item3|
       [item2]
     end
     result = parser.parse("ABCDEF")
-    assert_equal [[["B"], "DEF"]],  result
+    assert_equal ["B"],  result.value
+    assert_equal "DEF",  result.input
   end
 
+#   def test_seq_parse
+#     parser = SeqParser.new(ItemParser.new, ItemParser.new) do |item1, item2|
+#       [item1, item2]
+#     end
+#     result = parser.parse("abcdef")
+#     assert_equal [[["a", "b"], "cdef"]],  result
+
+#     parser = SeqParser.new(ItemParser.new, ItemParser.new, ItemParser.new) do |item1, item2, item3|
+#       [item1, item3]
+#     end
+#     result = parser.parse("ABCDEF")
+#     assert_equal [[["A", "C"], "DEF"]],  result
+
+#     parser = SeqParser.new(ItemParser.new, ItemParser.new, ItemParser.new) do |item1, item2, item3|
+#       [item2]
+#     end
+#     result = parser.parse("ABCDEF")
+#     assert_equal [[["B"], "DEF"]],  result
+#   end
+
   def test_seq_parse_without_block
     parser = SeqParser.new(ItemParser.new, ItemParser.new)
     result = parser.parse("abcdef")
-    assert_equal [["b", "cdef"]],  result
+    assert_equal "b",  result.value
+    assert_equal "cdef",  result.input
   end
 
+#   def test_seq_parse_without_block
+#     parser = SeqParser.new(ItemParser.new, ItemParser.new)
+#     result = parser.parse("abcdef")
+#     assert_equal [["b", "cdef"]],  result
+#   end
+
   def test_alt_parse
     parser = AltParser.new(ItemParser.new, SucceedParser.new('d'))
     result = parser.parse("abc")
-    assert_equal [["a", "bc"]],  result
+    assert_equal "a",  result.value
+    assert_equal "bc",  result.input
 
     parser = AltParser.new(FailParser.new, SucceedParser.new('d'))
     result = parser.parse("abc")
-    assert_equal [["d", "abc"]],  result
+    assert_equal "d",  result.value
+    assert_equal "abc",  result.input
 
     parser = AltParser.new(FailParser.new, FailParser.new)
     result = parser.parse("abc")
-    assert_equal [],  result
+    assert_instance_of Fail,  result
   end
 
 
+#   def test_alt_parse
+#     parser = AltParser.new(ItemParser.new, SucceedParser.new('d'))
+#     result = parser.parse("abc")
+#     assert_equal [["a", "bc"]],  result
+
+#     parser = AltParser.new(FailParser.new, SucceedParser.new('d'))
+#     result = parser.parse("abc")
+#     assert_equal [["d", "abc"]],  result
+
+#     parser = AltParser.new(FailParser.new, FailParser.new)
+#     result = parser.parse("abc")
+#     assert_equal [],  result
+#   end
+
+#   def test_apply_parse
+#     is_digit = lambda {|i| i >= '0' and i <= '9'}
+#     parser = ApplyParser.new(SatisfyParser.new(is_digit)) do |digit|
+#       digit.to_i - '0'.to_i
+#     end
+
+#     result = parser.parse('7')
+#     assert_equal [[7, ""]],  result
+#   end
+
   def test_char_parse
     parser = CharParser.new("a")
     result = parser.parse("abc")
-    assert_equal [["a", "bc"]],  result
+    assert_equal "a",  result.value
+    assert_equal "bc",  result.input
 
     parser = CharParser.new("a")
     result = parser.parse("123")
-    assert_equal [],  result
+    assert_instance_of Fail,  result
   end
 
+#   def test_char_parse
+#     parser = CharParser.new("a")
+#     result = parser.parse("abc")
+#     assert_equal [["a", "bc"]],  result
+
+#     parser = CharParser.new("a")
+#     result = parser.parse("123")
+#     assert_equal [],  result
+#   end
+
   def test_string_parse
     parser = StringParser.new("abc")
     result = parser.parse("abcdef")
-    assert_equal [["abc", "def"]],  result
+    assert_equal "abc",  result.value
+    assert_equal "def",  result.input
 
     parser = StringParser.new("abc")
     result = parser.parse("ab1234")
-    assert_equal [],  result
+    assert_instance_of Fail,  result
   end
 
+#   def test_string_parse
+#     parser = StringParser.new("abc")
+#     result = parser.parse("abcdef")
+#     assert_equal [["abc", "def"]],  result
+
+#     parser = StringParser.new("abc")
+#     result = parser.parse("ab1234")
+#     assert_equal [],  result
+#   end
+
   def test_regex_parse
     parser = RegexParser.new(/[a-z]/)
     result = parser.parse("abcdef")
-    assert_equal [["a", "bcdef"]],  result
+    assert_equal "a",  result.value
+    assert_equal "bcdef",  result.input
 
     parser = RegexParser.new(/[0-9]+/)
     result = parser.parse("1234ab")
-    assert_equal [["1234", "ab"]],  result
+    assert_equal "1234",  result.value
+    assert_equal "ab",  result.input
   end
 
+#   def test_regex_parse
+#     parser = RegexParser.new(/[a-z]/)
+#     result = parser.parse("abcdef")
+#     assert_equal [["a", "bcdef"]],  result
+
+#     parser = RegexParser.new(/[0-9]+/)
+#     result = parser.parse("1234ab")
+#     assert_equal [["1234", "ab"]],  result
+#   end
+
   def test_zero_one_parse
     parser = ZeroOneParser.new(StringParser.new("abc"))
     result = parser.parse("abc  ")
-    assert_equal [["abc", "  "]],  result
+    assert_equal "abc",  result.value
+    assert_equal "  ",  result.input
     parser = ZeroOneParser.new(StringParser.new("abc"))
     result = parser.parse("123")
-    assert_equal [[[], "123"]],  result
+    assert_equal [],  result.value
+    assert_equal "123",  result.input
   end
 
+#   def test_zero_one_parse
+#     parser = ZeroOneParser.new(StringParser.new("abc"))
+#     result = parser.parse("abc  ")
+#     assert_equal [["abc", "  "]],  result
+#     parser = ZeroOneParser.new(StringParser.new("abc"))
+#     result = parser.parse("123")
+#     assert_equal [[[], "123"]],  result
+#   end
+
   def test_many_parse
-#    is_digit = lambda {|i| i > '0' and i < '9'}
-    is_digit = SatisfyParser.new(lambda {|i| i > '0' and i < '9'})
+    is_digit = SatisfyParser.new(lambda {|i| i >= '0' and i <= '9'})
     parser = ManyParser.new(is_digit)
     result = parser.parse("123abc")
-    assert_equal [["123", "abc"]],  result
+    assert_equal "123",  result.value
+    assert_equal "abc",  result.input
 
     result = parser.parse("abcdef")
-    assert_equal [[[], "abcdef"]],  result
+    assert_equal "",  result.value
+    assert_equal "abcdef",  result.input
   end
 
+#   def test_many_parse
+#     is_digit = SatisfyParser.new(lambda {|i| i >= '0' and i <= '9'})
+#     parser = ManyParser.new(is_digit)
+#     result = parser.parse("123abc")
+#     assert_equal [["123", "abc"]],  result
+
+#     result = parser.parse("abcdef")
+#     assert_equal [[[], "abcdef"]],  result
+#   end
+
 
   def test_ident
     parser = Ident.new
     result = parser.parse("abc def")
-    assert_equal [["abc", " def"]],  result
+    assert_equal "abc",  result.value
+    assert_equal " def",  result.input
   end
 
+#   def test_ident
+#     parser = Ident.new
+#     result = parser.parse("abc def")
+#     assert_equal [["abc", " def"]],  result
+#   end
+
   def test_nat
     parser = Nat.new
     result = parser.parse("123 abc")
-    assert_equal [[123, " abc"]],  result
+    assert_equal 123,  result.value
+    assert_equal " abc",  result.input
   end
 
+
+#   def test_nat
+#     parser = Nat.new
+#     result = parser.parse("123 abc")
+#     assert_equal [[123, " abc"]],  result
+#   end
+
   def test_nat_ident
     parser = SeqParser.new(Nat.new, Ident.new) do |nat, ident|
       [nat,ident]
     end
     result = parser.parse("123abc")
-    assert_equal [[[123, "abc"], ""]],  result
+    assert_equal [123, "abc"],  result.value
+    assert_equal "",  result.input
   end
 
+#   def test_nat_ident
+#     parser = SeqParser.new(Nat.new, Ident.new) do |nat, ident|
+#       [nat,ident]
+#     end
+#     result = parser.parse("123abc")
+#     assert_equal [[[123, "abc"], ""]],  result
+#   end
+
   def test_space
     parser = Space.new
     result = parser.parse("    abc")
-    assert_equal [[[], "abc"]],  result
+    assert_equal [],  result.value
+    assert_equal "abc",  result.input
   end
 
+#   def test_space
+#     parser = Space.new
+#     result = parser.parse("    abc")
+#     assert_equal [[[], "abc"]],  result
+#   end
+
   def test_identifier
     parser = Identifier.new
     result = parser.parse("    abc ")
-    assert_equal [["abc", ""]],  result
+    assert_equal "abc",  result.value
+    assert_equal "",  result.input
+
+    parser_with_keyword = Identifier.new("abc","efg")
+    result = parser_with_keyword.parse("abc")
+    assert_instance_of Fail,  result
+    result = parser_with_keyword.parse(" xyz")
+    assert_equal "xyz",  result.value
+    assert_equal "",  result.input
   end
 
+#   def test_identifier
+#     parser = Identifier.new
+#     result = parser.parse("    abc ")
+#     assert_equal [["abc", ""]],  result
+
+#     parser_with_keyword = Identifier.new("abc","efg")
+#     result = parser_with_keyword.parse("abc")
+#     assert_equal [],  result
+#     result = parser_with_keyword.parse(" xyz")
+#     assert_equal [["xyz", ""]],  result
+#   end
+
   def test_natural
     parser = Natural.new
     result = parser.parse(" 1234 ")
-    assert_equal [[1234, ""]],  result
+    assert_equal 1234,  result.value
+    assert_equal "",  result.input
   end
 
+#   def test_natural
+#     parser = Natural.new
+#     result = parser.parse(" 1234 ")
+#     assert_equal [[1234, ""]],  result
+#   end
+
   def test_symbol
     parser = Symbol.new('%')
     result = parser.parse(" % ")
-    assert_equal [["%", ""]],  result
+    assert_equal "%",  result.value
+    assert_equal "",  result.input
   end
 
-  def test_define_parser
-    parser = Symbol.new('%')
-    result = parser.parse(" % ")
-    assert_equal [["%", ""]],  result
-  end
-
-  def test_combination
-    parser = AltParser.new(
-                            SeqParser.new(Symbol.new('+'),
-                                          Natural.new) do | _, nat|
-                             nat
-                            end,
-                            Natural.new
-                            )
-    result = parser.parse("+123")
-    assert_equal [[123, ""]],  result
-    result = parser.parse(" 123 ")
-    assert_equal [[123, ""]],  result
-    parser = AltParser.new(
-                           SeqParser.new(
-                                         Symbol.new('('),
-                                         Natural.new,
-                                         Symbol.new(')')
-                                         ) do |_,expr, _|
-                             expr
-                           end,
-                           Natural.new
-                           )
-    result = parser.parse("( 123 )")
-    assert_equal [[123, ""]],  result
-  end
+#   def test_symbol
+#     parser = Symbol.new('%')
+#     result = parser.parse(" % ")
+#     assert_equal [["%", ""]],  result
+#   end
+
+#   def test_define_parser
+#     parser = Symbol.new('%')
+#     result = parser.parse(" % ")
+#     assert_equal [["%", ""]],  result
+#   end
+
+#   def test_combination
+#     parser = AltParser.new(
+#                             SeqParser.new(Symbol.new('+'),
+#                                           Natural.new) do | _, nat|
+#                              nat
+#                             end,
+#                             Natural.new
+#                             )
+#     result = parser.parse("+123")
+#     assert_equal [[123, ""]],  result
+#     result = parser.parse(" 123 ")
+#     assert_equal [[123, ""]],  result
+#     parser = AltParser.new(
+#                            SeqParser.new(
+#                                          Symbol.new('('),
+#                                          Natural.new,
+#                                          Symbol.new(')')
+#                                          ) do |_,expr, _|
+#                              expr
+#                            end,
+#                            Natural.new
+#                            )
+#     result = parser.parse("( 123 )")
+#     assert_equal [[123, ""]],  result
+#   end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.3
 specification_version: 1
 name: yaparc
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
-date: 2008-01-07 00:00:00 +09:00
+  version: 0.0.8
+date: 2008-01-10 00:00:00 +09:00
 summary: Yet Another Combinator Parser Library
 require_paths: 
 - lib