yaparc 0.1.0 → 0.1.3

data/README

@@ -15,7 +15,7 @@ There are several implementations of parser combinator in ruby. This is a yet an
 
 In combinator parser, each parser is construct as a function taking input string as arguments. Larger parsers are built from smaller parsers. Although combinators are higher-order functions in ordinary functional languages, they are constructed as classes in yaparc, because Ruby has more object-oriented than functional property.
 
-All parsers has 'parse' method, each of which takes input string as its arguments except SatisfyParser. All of them return an array of array as their result, with the empty array [] denoting faiilure, and a singleton array [[v, xs]] indicating success, with value v and uncosumed input xs as String instance.
+All parsers has 'parse' method, each of which takes input string as its arguments except SatisfyParser. Every parser returns either Result::OK or Result::Fail as their result of parsing. An instance of Result::Fail denotes faiilure, and instance of Result::OK indicates success.
 
 == Primitive Parsers
 
@@ -29,25 +29,25 @@ All parsers has 'parse' method, each of which takes input string as its argument
 The parser SucceedParser always succeeds with the result value, without consuming any of the input string.
 In the following example, SucceedParser#parse takes an input string "blah, blah, blah" and returns the singleton array [[1, "blah, blah, blah"]].
 
-    parser = SucceedParser.new(1)
+    parser = Yaparc::SucceedParser.new(1)
     parser.parse("blah, blah, blah")
-    => [[1, "blah, blah, blah"]]
+    => #<Yaparc::Result::OK:0xb7aaaf5c @input="blah, blah, blah", @value=1>
 
 === FailParser class
 
 The parser FailParser always fails, regardless of the contents of the input string.
 
-    parser = FailParser.new
+    parser = Yaparc::FailParser.new
     parser.parse("abc")
-    => []
+    => #<Yaparc::Result::Fail:0xb7aa56b0 @value=nil>
 
 === ItemParser class
 
 The parser ItemParser fails if the input string is empty, and succeeds with the first character as the result value otherwise.
 
-    parser = ::Yaparc::ItemParser.new
+    parser = Yaparc::ItemParser.new
     parser.parse("abc")
-    => [["a", "bc"]]
+    => #<Yaparc::Result::OK:0xb7a9fdb4 @input="bc", @value="a">
 
 === SatisfyParser class
 
@@ -61,9 +61,9 @@ The parser SatisfyParser recognizes a single input via predicate which determine
         false
       end
     end
-    parser = SatisfyParser.new(is_integer)
+    parser = Yaparc::SatisfyParser.new(is_integer)
     parser.parse("123")
-    => [["1", "23"]]
+    => #<Yaparc::Result::OK:0xb7a8f284 @input="23", @value="1">
 
 
 == Combining Parsers
@@ -81,15 +81,15 @@ The SeqParser corresponds to sequencing in BNF. The following parser recognizes
 
   parser = SeqParser.new(Symbol.new('+'), Natural.new)
   parser.parse("+321")
-  => [[321,""]]
+  => #<Yaparc::Result::OK:0xb7a81ae4 @input="", @value=321>
 
 if a block given to SeqParser, it analyses input string to construct its logical structure.
 
-  parser = SeqParser.new(Symbol.new('+'), Natural.new) do | plus, nat|
+  parser = Yaparc::SeqParser.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | plus, nat|
     nat
   end
   parser.parse("+1234")
-  => [[1234,""]]
+  => #<Yaparc::Result::OK:0xb7a70a00 @input="", @value=1234>
 
 It produces a parse tree which expounds the semantic structure of the program.
 
@@ -98,26 +98,25 @@ It produces a parse tree which expounds the semantic structure of the program.
 The parser AltParser class is an alternation parser, which returns the result of the first parser to succeed, and failure if neither does.
 
 
-  parser = AltParser.new(
-                          SeqParser.new(Symbol.new('+'), Natural.new) do | _, nat|
+  parser = Yaparc::AltParser.new(
+                          Yaparc::SeqParser.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | _, nat|
                             nat
                           end,
-                          Natural.new
+                          Yaparc::Natural.new
                          )
   parser.parse("1234")
-  => [[1234,""]]
+  => #<Yaparc::Result::OK:0xb7a5a610 @input="", @value=1234>
   parser.parse("-1234")
-  => []
+  => #<Yaparc::Result::Fail:0xb7a57ba4 @value=nil>
 
 
 === ManyParser
 
 In ManyParser, zero or more applications of parser are admissible.
 
-    parser = ManyParser.new(SatisfyParser.new(lambda {|i| i > '0' and i < '9'}))
+    parser = Yaparc::ManyParser.new(Yaparc::SatisfyParser.new(lambda {|i| i > '0' and i < '9'}))
     parser.parse("123abc")
-    => [["123", "abc"]]
-
+    => #<Yaparc::Result::OK:0xb7a49dc4 @input="abc", @value="123">
 
 === ManyOneParser
 
@@ -145,7 +144,7 @@ There are two ways to construct parser. One is to inherit from Yaparc::ParserBas
   class StringMatch < Yaparc::ParserBase
 
     def initialize(literal)
-      @parser = Token.new(StringParser.new(literal))
+      @parser = Yaparc::Token.new(Yaparc::StringParser.new(literal))
     end
   end
 
@@ -154,7 +153,7 @@ The other is to inherit from Yaparc::AbstractParser class.
   class Identifier < Yaparc::AbstractParser
     def initialize
       @parser = lambda do
-        Token.new(Ident.new)
+        Yaparc::Token.new(Yaparc::Ident.new)
       end
     end
   end

data/lib/yaparc.rb

@@ -1,10 +1,3 @@
-def assert_at(file,line, message = "")
-  unless yield
-    raise "Assertion failed !: #{file}, #{line}: #{message}"
-  end
-end
-
-
 module Yaparc
   module Result
     class Base
@@ -12,7 +5,7 @@ module Yaparc
       def initialize(options = {})
         @message = options[:message] if options[:message]
         @input = options[:input] if options[:input]
-        @value = options[:value] if options[:value]
+        @value = options[:value]
       end
     end
 
@@ -38,16 +31,35 @@ module Yaparc
       mod.extend ClassMethods
     end
 
-
     def parse(input, &block)
       result = @parser.call(input)
-      if block_given?
-        @tree = yield result.value
+
+      if result.respond_to? :parse
+        result = result.parse(input)
       else
-        @tree = result.value
+        if block_given?
+          #        @tree = yield result.value
+          result.value = yield result.value
+          @tree = result
+        else
+          @tree = result.value
+          #          @tree = result.parse(input)
+        end
+        result
       end
-      result
     end
+#     def parse(input, &block)
+#       result = @parser.call(input)
+#       if block_given?
+# #        @tree = yield result.value
+#         result.value = yield result.value
+#         @tree = result
+#       else
+# #        @tree = result.value
+#         @tree = result.parse(input)
+#       end
+#       result
+#     end
 
     def eval
       tree = parse(input)
@@ -63,24 +75,6 @@ module Yaparc
           yield
         end
       end
-
-#       def define_parser(&block)
-#         @@parser = lambda do |input|
-#           parser = yield
-#           parser.parse(input)
-#         end
-#       end
-
-#       def cparse(input, &block)
-#         tree = @@cparser.call.parse(input)
-#         if block_given?
-#           yield tree
-#         else
-#           tree
-#         end
-#       end
-#       module_function :cparse
-
     end
   end # of Module Parsable
 
@@ -91,7 +85,6 @@ module Yaparc
     attr_reader :remaining
     def initialize(value, remaining = nil)
       @parser = lambda do |input|
-#        [[value, input]]
         Result::OK.new(:value => value, :input => input)
       end
       @remaining = remaining
@@ -115,7 +108,6 @@ module Yaparc
         if input.nil? or input.empty?
           Result::Fail.new
         else
-#          [[input[0..0],input[1..input.length]]]
           Result::OK.new(:value => input[0..0],:input => input[1..input.length])
         end
       end
@@ -125,7 +117,7 @@ module Yaparc
   class SatisfyParser
     include Parsable
     def initialize(predicate)
-      assert_at(__FILE__,__LINE__){predicate.instance_of?(Proc)}
+      raise unless predicate.instance_of?(Proc)
 
       @parser = lambda do |input|
         case result = ItemParser.new.parse(input)
@@ -153,8 +145,6 @@ module Yaparc
     end
   end
 
-
-
   class SeqParser
     include Parsable
     def initialize(*parsers, &block)
@@ -167,6 +157,7 @@ module Yaparc
             break Result::Fail.new
           else
             args << result.value
+#            args << result.parse(input)
             result
           end
         end
@@ -195,7 +186,6 @@ module Yaparc
       @parser = lambda do |input|
         initial_result = Result::OK.new(:input => input)
         final_result = Result::Fail.new
-#        final_result = Error.new
         parsers.each do |parser|
           case result = parser.parse(initial_result.input)
           when Result::Fail
@@ -275,12 +265,13 @@ module Yaparc
     include Parsable
     def initialize(parser, identity = "")
       @parser = lambda do |input|
-        AltParser.new(ManyOneParser.new(parser, identity), SucceedParser.new(identity)).parse(input)
+#        AltParser.new(ManyOneParser.new(parser, identity), SucceedParser.new(identity)).parse(input)
+        AltParser.new(ManyOneParser.new(parser, identity), SucceedParser.new(identity))
       end
     end
 
     def parse(input)
-      @parser.call(input)
+      @parser.call(input).parse(input)
     end
   end
 
@@ -319,7 +310,6 @@ module Yaparc
     end
   end
 
-
   class ZeroOneParser < ParserBase
     def initialize(parser)
       @parser = AltParser.new(parser, SucceedParser.new([])) # Is it OK?
@@ -361,7 +351,6 @@ module Yaparc
   class Token < ParserBase
 
     def initialize(parser, prefix = Space.new, postfix = Space.new)
-#      @parser = SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
       @parser = SeqParser.new(prefix, parser, postfix) do |_, vs, _|
         vs
       end

data/tests/test_calc.rb

@@ -1,126 +1,90 @@
 require 'lib/yaparc.rb'
 require 'test/unit'
-require 'pp'
 
+module Calc
 
-class Expr < Yaparc::AbstractParser
+  class Expr < Yaparc::AbstractParser
 
-  def initialize
-    @parser = lambda do
-      Yaparc::AltParser.new(
-                            Yaparc::SeqParser.new(Term.new,
-                                                  Yaparc::Symbol.new('+'),
-                                                  Expr.new) do |term, _, expr|
-                              ['+', term,expr]
-                            end,
-                            Term.new
-                            )
+    def initialize
+      @parser = lambda do
+        Yaparc::AltParser.new(
+                              Yaparc::SeqParser.new(Term.new,
+                                                    Yaparc::Symbol.new('+'),
+                                                    Expr.new) do |term, _, expr|
+                                ['+', term,expr]
+                              end,
+                              Term.new
+                              )
+      end
     end
-  end
 
-#   define_parser do
-#     Yaparc::AltParser.new(
-#                           Yaparc::SeqParser.new(Term.new,
-#                                                 Yaparc::Symbol.new('+'),
-#                                                 Expr.new) do |term, _, expr|
-#                             ['+', term,expr]
-#                           end,
-#                           Term.new
-#                           )
-#   end
-
-
-  def evaluate(input)
-    result = parse(input)
-    tree = result.value
-    eval_tree(tree)
-  end
+    def evaluate(input)
+      result = parse(input)
+      tree = result.value
+      eval_tree(tree)
+    end
 
-  def eval_tree(tree)
-    case tree
-    when Array
-      case tree[0]
-      when '+'
-        eval_tree(tree[1]) + eval_tree(tree[2])
-      when '-'
-        eval_tree(tree[1]) - eval_tree(tree[2])
-      when '*'
-        eval_tree(tree[1]) * eval_tree(tree[2])
-      when '/'
-        eval_tree(tree[1]) / eval_tree(tree[2])
+    def eval_tree(tree)
+      case tree
+      when Array
+        case tree[0]
+        when '+'
+          eval_tree(tree[1]) + eval_tree(tree[2])
+        when '-'
+          eval_tree(tree[1]) - eval_tree(tree[2])
+        when '*'
+          eval_tree(tree[1]) * eval_tree(tree[2])
+        when '/'
+          eval_tree(tree[1]) / eval_tree(tree[2])
+        end
+      else
+        tree
       end
-    else
-      tree
     end
   end
-end
 
-class Term < Yaparc::AbstractParser
-
-  def initialize
-    @parser = lambda do
-      Yaparc::AltParser.new(
-                            Yaparc::SeqParser.new(Factor.new,
-                                                  Yaparc::Symbol.new('*'),
-                                                  Term.new) do |factor, _, term|
-                              ['*', factor,term]
-                            end,
-                            Factor.new
-                            )
+  class Term < Yaparc::AbstractParser
+
+    def initialize
+      @parser = lambda do
+        Yaparc::AltParser.new(
+                              Yaparc::SeqParser.new(Factor.new,
+                                                    Yaparc::Symbol.new('*'),
+                                                    Term.new) do |factor, _, term|
+                                ['*', factor,term]
+                              end,
+                              Factor.new
+                              )
+      end
     end
   end
 
-#   define_parser do
-#     Yaparc::AltParser.new(
-#                           Yaparc::SeqParser.new(Factor.new,
-#                                                 Yaparc::Symbol.new('*'),
-#                                                 Term.new) do |factor, _, term|
-#                             ['*', factor,term]
-#                           end,
-#                           Factor.new
-#                           )
-#   end
-end
-
-class Factor < Yaparc::AbstractParser
-
-
-  def initialize
-    @parser = lambda do
-      Yaparc::AltParser.new(
-                    Yaparc::SeqParser.new(
-                                          Yaparc::Symbol.new('('),
-                                          Expr.new,
-                                          Yaparc::Symbol.new(')')
-                                          ) do |_,expr, _|
-                      expr
-                    end,
-                    Yaparc::Natural.new
-                    )
+  class Factor < Yaparc::AbstractParser
+
+
+    def initialize
+      @parser = lambda do
+        Yaparc::AltParser.new(
+                              Yaparc::SeqParser.new(
+                                                    Yaparc::Symbol.new('('),
+                                                    Expr.new,
+                                                    Yaparc::Symbol.new(')')
+                                                    ) do |_,expr, _|
+                                expr
+                              end,
+                              Yaparc::Natural.new
+                              )
+      end
     end
   end
-
-#   define_parser do
-#     AltParser.new(
-#                   Yaparc::SeqParser.new(
-#                                         Yaparc::Symbol.new('('),
-#                                         Expr.new,
-#                                         Yaparc::Symbol.new(')')
-#                                         ) do |_,expr, _|
-#                     expr
-#                   end,
-#                   Natural.new
-#                   )
-#   end
-end
-
+end # of Calc
 
 class YaparcCalcTest < Test::Unit::TestCase
   include ::Yaparc
 
   def setup
-    @expr = Expr.new
-    @factor = Factor.new
+    @expr = Calc::Expr.new
+    @factor = Calc::Factor.new
   end
 
   def test_expr
@@ -145,17 +109,4 @@ class YaparcCalcTest < Test::Unit::TestCase
     assert_equal 312,  result.value
     assert_equal "",  result.input
   end
-
-#   def test_cexpr
-#     result = @expr.cparse("1 + 2 ")
-#     assert_equal [[["+", 1, 2], ""]],  result
-#   end
-
-#   def test_expr_define_parser
-#     parser = Expr.new
-#     result = Expr.parse("1 + 2 ")
-#     assert_equal [[["+", 1, 2], ""]],  result
-# #     assert_equal 3, parser.evaluate("1 + 2 ")
-# #     assert_equal 9, parser.evaluate("(1 + 2) * 3 ")
-#   end
 end

data/tests/test_parser.rb

@@ -25,28 +25,12 @@ class YaparcTest < Test::Unit::TestCase
     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_instance_of Result::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("")
@@ -56,14 +40,6 @@ class YaparcTest < Test::Unit::TestCase
     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
@@ -96,37 +72,6 @@ class YaparcTest < Test::Unit::TestCase
     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]
@@ -150,26 +95,6 @@ class YaparcTest < Test::Unit::TestCase
     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")
@@ -177,12 +102,6 @@ class YaparcTest < Test::Unit::TestCase
     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")
@@ -199,30 +118,20 @@ class YaparcTest < Test::Unit::TestCase
     assert_instance_of Result::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.value
     assert_equal "",  result.input
+
+    parser = Yaparc::ApplyParser.new(Yaparc::RegexParser.new(/\d+/)) do |match|
+      Integer(match)
+    end
+    result = parser.parse('7')
+    assert_equal 7,  result.value
   end
 
   def test_char_parse
@@ -236,16 +145,6 @@ class YaparcTest < Test::Unit::TestCase
     assert_instance_of Result::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")
@@ -257,16 +156,6 @@ class YaparcTest < Test::Unit::TestCase
     assert_instance_of  Result::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")
@@ -277,17 +166,13 @@ class YaparcTest < Test::Unit::TestCase
     result = parser.parse("1234ab")
     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
+    parser = RegexParser.new(/[0-9]+/)
+    result = parser.parse("1234ab") do |match|
+      Integer(match)
+    end
+    assert_equal 1234,  result.value
+  end
 
   def test_zero_one_parse
     parser = ZeroOneParser.new(StringParser.new("abc"))
@@ -300,15 +185,6 @@ class YaparcTest < Test::Unit::TestCase
     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 = SatisfyParser.new(lambda {|i| i >= '0' and i <= '9'})
     parser = ManyParser.new(is_digit)
@@ -321,17 +197,6 @@ class YaparcTest < Test::Unit::TestCase
     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")
@@ -339,12 +204,6 @@ class YaparcTest < Test::Unit::TestCase
     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")
@@ -352,13 +211,6 @@ class YaparcTest < Test::Unit::TestCase
     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]
@@ -368,14 +220,6 @@ class YaparcTest < Test::Unit::TestCase
     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")
@@ -383,12 +227,6 @@ class YaparcTest < Test::Unit::TestCase
     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 ")
@@ -403,18 +241,6 @@ class YaparcTest < Test::Unit::TestCase
     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 ")
@@ -422,55 +248,11 @@ class YaparcTest < Test::Unit::TestCase
     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.value
     assert_equal "",  result.input
   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
 

data/tests/test_sql.rb

@@ -0,0 +1,324 @@
+require 'lib/yaparc.rb'
+require 'test/unit'
+
+###  c.f. http://www11.plala.or.jp/sotsuken/db/sql.html
+###
+###  query_body := select_expression from_expression where_expression
+###  select_expression := 'select' term_sequence
+###  term_sequence := term[,term_sequence]*
+###  from_expression := 'from' path_expression[, path_expression]*
+###  path_expression := '/' term [path_expression]*
+###  where_expression :=
+###                    | search_cond
+###  search_cond := term op term
+###              | ( NOT search_cond )
+###              | ( search_cond AND search_cond )
+###              | ( search_cond OR search_cond )
+###              | EXISTS ( query_body )
+###              | term op ANY ( query_body )
+###              | term op ALL ( query_body )
+###              | term IN ( query_body )
+###  term := any_characters
+###  op := <> | = | <  | > | <= | >=
+
+module SQL
+  ###  query_body := select_expression from_expression where_expression
+  class QueryBody
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::SeqParser.new(SelectExpression.new,
+                              FromExpression.new,
+                              WhereExpression.new) do |select, from, where|
+          {:select => select, :from => from, :where => where }
+        end
+      end
+    end
+  end
+
+  ###  select_expression := 'select' term_sequence
+  class SelectExpression
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::SeqParser.new(
+                              Yaparc::Symbol.new('select'),
+                              TermSequence.new) do |_,terms|
+          terms
+        end
+      end
+    end
+  end
+
+  ###  term_sequence := term[,term_sequence]*
+  class TermSequence
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::SeqParser.new(
+                              Term.new,
+                              Yaparc::ManyParser.new(
+                                                     Yaparc::SeqParser.new(
+                                                                           Yaparc::Symbol.new(','),
+                                                                           TermSequence.new) do |_, terms|
+                                                       terms
+                                                     end,
+                                                     []
+                                                     )
+                              ) do |term,terms|
+          [term] + terms
+        end
+      end
+    end
+  end
+
+  ###  from_expression := 'from' path_expression[, path_expression]*
+  class FromExpression
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::SeqParser.new(
+                              Yaparc::Symbol.new('from'),
+                              PathExpression.new,
+                              Yaparc::ManyParser.new(
+                                                     Yaparc::SeqParser.new(
+                                                                           Yaparc::Symbol.new(','),
+                                                                           PathExpression.new) do |_, path|
+                                                       [path]
+                                                     end,
+                                                     []
+                                                     )
+                              ) do |_,path,paths|
+          path + paths
+        end
+      end
+    end
+  end
+
+
+  ###  path_expression := '/' term [path_expression]*
+  class PathExpression
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::SeqParser.new(
+                              Yaparc::Symbol.new('/'),
+                              Term.new,
+                              Yaparc::ManyParser.new(
+                                                     PathExpression.new do |path|
+                                                       path
+                                                     end,
+                                                     []
+                                                     )
+                              ) do |_,term, paths|
+          [term] + paths
+        end
+      end
+    end
+  end
+
+  ###  where_expression :=
+  ###                    | search_cond
+  class WhereExpression
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::ManyParser.new(SearchCond.new)
+      end
+    end
+  end
+
+  ###  term := any_characters
+  class Term
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::Identifier.new
+      end
+    end
+  end
+
+  ###  search_cond := term op term
+  ###              | ( NOT search_cond )
+  ###              | ( search_cond AND search_cond )
+  ###              | ( search_cond OR search_cond )
+  ###              | EXISTS ( query_body )
+  ###              | term op ANY ( query_body )
+  ###              | term op ALL ( query_body )
+  ###              | term IN ( query_body )
+
+  class SearchCond
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::AltParser.new(
+                              Yaparc::SeqParser.new(Term.new,
+                                                    Op.new,
+                                                    Term.new) do |term1, op, term2|
+                                {:operator => op, :args => [term1, term2]}
+                              end,
+                              Yaparc::SeqParser.new(Yaparc::Symbol.new('('),
+                                                    Yaparc::Symbol.new('NOT'),
+                                                    SearchCond.new,
+                                                    Yaparc::Symbol.new(')')) do |_, _, cond, _|
+                                {:logic => :not, :conditions => [cond]}
+                              end,
+                              Yaparc::SeqParser.new(Yaparc::Symbol.new('('),
+                                                    SearchCond.new,
+                                                    Yaparc::Symbol.new('AND'),
+                                                    SearchCond.new,
+                                                    Yaparc::Symbol.new(')')) do |_, cond1, _,cond2,_|
+                                {:logic => :and, :conditions => [cond1, cond2]}
+                              end,
+                              Yaparc::SeqParser.new(Yaparc::Symbol.new('('),
+                                                    SearchCond.new,
+                                                    Yaparc::Symbol.new('OR'),
+                                                    SearchCond.new,
+                                                    Yaparc::Symbol.new(')')) do |_, cond1, _,cond2,_|
+                                {:logic => :or, :conditions => [cond1,cond2]}
+                              end,
+                              Yaparc::SeqParser.new(Yaparc::Symbol.new('EXISTS'),
+                                                    Yaparc::Symbol.new('('),
+                                                    QueryBody.new,
+                                                    Yaparc::Symbol.new(')')) do |_, _, body,_|
+                                {:logic => :exits, :condition => body}
+                              end,
+                              # term op ANY ( query_body )
+                              Yaparc::SeqParser.new(Term.new,
+                                                    Op.new,
+                                                    Yaparc::Symbol.new('ANY'),
+                                                    Yaparc::Symbol.new('('),
+                                                    QueryBody.new,
+                                                    Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
+                                {:operator => op,
+                                  :term1 => term,
+                                  :term2 => {:logic => :any, :condition => body}
+                                }
+                              end,
+                              # term op ALL ( query_body )
+                              Yaparc::SeqParser.new(Term.new,
+                                                    Op.new,
+                                                    Yaparc::Symbol.new('ALL'),
+                                                    Yaparc::Symbol.new('('),
+                                                    QueryBody.new,
+                                                    Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
+                                {:operator => op,
+                                  :term1 => term,
+                                  :term2 => {:logic => :ALL, :condition => body}
+                                }
+                              end,
+                              # term IN ( query_body )
+                              Yaparc::SeqParser.new(Term.new,
+                                                    Op.new,
+                                                    Yaparc::Symbol.new('IN'),
+                                                    Yaparc::Symbol.new('('),
+                                                    QueryBody.new,
+                                                    Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
+                                {:operator => op,
+                                  :term1 => term,
+                                  :term2 => {:logic => :IN, :condition => body}
+                                }
+                              end)
+      end
+    end
+  end
+
+  ###  op := <> | = | <  | > | <= | >=
+  class Op
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do
+        Yaparc::AltParser.new(
+                              Yaparc::ApplyParser.new(Yaparc::Symbol.new('<>')) {|_| :not},
+                              Yaparc::ApplyParser.new(Yaparc::Symbol.new('<=')) {|_| :lesser_eq },
+                              Yaparc::ApplyParser.new(Yaparc::Symbol.new('>=')) {|_| :greater_eq },
+                              Yaparc::ApplyParser.new(Yaparc::Symbol.new('<')) {|_| :lesser},
+                              Yaparc::ApplyParser.new(Yaparc::Symbol.new('>')) {|_| :greater })
+      end
+    end
+  end
+end # of SQL
+
+
+class YaparcQueryTest < Test::Unit::TestCase
+  include ::Yaparc
+
+#   def setup
+#     @expr = Expr.new
+#     @factor = Factor.new
+#   end
+
+  def test_op
+    op = SQL::Op.new
+    result = op.parse("<")
+    assert_instance_of Result::OK,  result
+    assert_equal :lesser,  result.value
+    result = op.parse("<=")
+    assert_instance_of Result::OK,  result
+    assert_equal :lesser_eq,  result.value
+  end
+
+  def test_term
+    term = SQL::Term.new
+    result = term.parse("abc")
+    assert_instance_of Result::OK,  result
+    assert_equal "abc",  result.value
+  end
+
+  def test_path_expression
+    path = SQL::PathExpression.new
+    result = path.parse("/xyz")
+    assert_instance_of Result::OK,  result
+    assert_equal ["xyz"],  result.value
+    result = path.parse("/abc/def")
+    assert_instance_of Result::OK,  result
+    assert_equal ["abc", "def"],  result.value
+  end
+
+  def test_from_expression
+    path = SQL::FromExpression.new
+    result = path.parse("from /xyz")
+    assert_instance_of Result::OK,  result
+    assert_equal ["xyz"],  result.value
+    result = path.parse("from /abc/def")
+    assert_instance_of Result::OK,  result
+    assert_equal ["abc", "def"],  result.value
+  end
+
+  def test_search_cond
+    search = SQL::SearchCond.new
+    result = search.parse("abc <> xyz")
+    assert_instance_of Result::OK,  result
+    assert_equal Hash[:operator=> :not, :args=>["abc", "xyz"]],  result.value
+
+    result = search.parse("(NOT abc <> xyz)")
+    assert_instance_of Result::OK,  result
+    assert_equal Hash[:logic=>:not, :conditions=>[{:operator=>:not, :args=>["abc", "xyz"]}]],  result.value
+    result = search.parse("(abc <> xyz AND abc > xyz)")
+    assert_instance_of Result::OK,  result
+    assert_equal Hash[
+                      :logic=>:and, :conditions=> [{:operator=>:not, :args=>["abc", "xyz"]},
+                                                   {:operator=>:greater, :args=>["abc", "xyz"]}]
+                     ],  result.value
+  end
+
+  def test_query_body
+    query = SQL::QueryBody.new
+    result = query.parse("select abc from /xyz")
+    assert_instance_of Result::OK,  result
+    assert_equal Hash[:from=>["xyz"], :where=>"", :select=>["abc"]],  result.value
+    result = query.parse("select abc from /xyz/fgh")
+    assert_instance_of Result::OK,  result
+    assert_equal Hash[:from=>["xyz","fgh"], :where=>"", :select=>["abc"]],  result.value
+  end
+
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.3
 specification_version: 1
 name: yaparc
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2008-01-16 00:00:00 +09:00
+  version: 0.1.3
+date: 2008-01-20 00:00:00 +09:00
 summary: Yet Another Combinator Parser Library
 require_paths: 
 - lib
@@ -31,11 +31,13 @@ authors:
 files: 
 - tests/test_parser.rb
 - tests/test_calc.rb
+- tests/test_sql.rb
 - lib/yaparc.rb
 - README
 test_files: 
 - tests/test_parser.rb
 - tests/test_calc.rb
+- tests/test_sql.rb
 rdoc_options: []
 
 extra_rdoc_files: