yaparc 0.0.6 → 0.0.7

data/README

@@ -19,4 +19,12 @@ This is a yet another simple combinator parser library in ruby.
 Please look at unit test files.
 
 
+== Basic Parsers
+
+== Combination Parsers
+
+=== Sequence Parser
+=== Alternate Parser
+
+
 

data/lib/yaparc.rb

@@ -106,19 +106,16 @@ module Yaparc
           FailParser.new
         else
           parser = if predicate.call(item[0][0])
-#                     input = item[0][1]
                      SucceedParser.new(item[0][0], item[0][1])
                    else
                      FailParser.new
                    end
-#          parser.parse(input)
         end
       end
     end
 
     def parse(input)
-      parser = @parser.call(input)
-      case parser
+      case parser = @parser.call(input)
       when SucceedParser
         parser.parse(parser.remaining)
       when FailParser
@@ -138,18 +135,22 @@ module Yaparc
         args = []
         remains = parsers.inject(input) do |accumulator, parser|
           result = parser.parse(accumulator)
-          unless result == []
+          if result == []
+            break []
+          else
             args << result[0][0]
             result[0][1]
-          else
-            break []
           end
         end
-        unless remains == []
-          retval = yield(*args)
-          [[retval, remains]]
-        else
+        if remains == []
           []
+        else
+          retval = if block_given?
+                     yield(*args)
+                   else
+                     args.last
+                   end
+          [[retval, remains]]
         end
       end
     end # of initialize
@@ -173,36 +174,6 @@ module Yaparc
   end
 
 
-  class ParserBase
-    include Parsable
-
-    def parse(input)
-      @parser.parse(input)
-    end
-  end
-
-  class AbstractParser
-    include Parsable
-
-    def parse(input, &block)
-      tree = @parser.call.parse(input)
-      if block_given?
-        @tree = yield tree
-      else
-        @tree = tree
-      end
-
-    end
-  end
-
-  class CharParser < ParserBase
-
-    def initialize(char)
-      equal_char = lambda {|i| i == char}
-      @parser = SatisfyParser.new(equal_char)
-    end
-  end
-
 
   class StringParser
     include Parsable
@@ -281,8 +252,24 @@ module Yaparc
   end
 
 
-  class ZeroOneParser < ParserBase
+  class ParserBase
+    include Parsable
+
+    def parse(input)
+      @parser.parse(input)
+    end
+  end
 
+  class CharParser < ParserBase
+
+    def initialize(char)
+      equal_char = lambda {|i| i == char}
+      @parser = SatisfyParser.new(equal_char)
+    end
+  end
+
+
+  class ZeroOneParser < ParserBase
     def initialize(parser)
       @parser = AltParser.new(parser, SucceedParser.new([]))
     end
@@ -290,7 +277,6 @@ module Yaparc
 
 
   class Ident < ParserBase
-
     def initialize
       @parser = SeqParser.new(
                               SatisfyParser.new(IS_LOWER),
@@ -328,7 +314,6 @@ module Yaparc
     end
   end
 
-
   class Token < ParserBase
 
     def initialize(parser)
@@ -338,7 +323,6 @@ module Yaparc
     end
   end
 
-
   class Identifier < ParserBase
 
     def initialize
@@ -346,7 +330,6 @@ module Yaparc
     end
   end
 
-
   class Natural < ParserBase
 
     def initialize
@@ -354,7 +337,6 @@ module Yaparc
     end
   end
 
-
   class Symbol < ParserBase
 
     def initialize(literal)
@@ -362,4 +344,18 @@ module Yaparc
     end
   end
 
+  class AbstractParser
+    include Parsable
+
+    def parse(input, &block)
+      tree = @parser.call.parse(input)
+      if block_given?
+        @tree = yield tree
+      else
+        @tree = tree
+      end
+
+    end
+  end
+
 end # of Yaparc

data/tests/test_parser.rb

@@ -87,6 +87,12 @@ class YaparcTest < Test::Unit::TestCase
     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
+  end
+
   def test_alt_parse
     parser = AltParser.new(ItemParser.new, SucceedParser.new('d'))
     result = parser.parse("abc")

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.3
 specification_version: 1
 name: yaparc
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.7
 date: 2008-01-07 00:00:00 +09:00
 summary: Yet Another Combinator Parser Library
 require_paths: 
@@ -29,14 +29,11 @@ post_install_message:
 authors: 
 - Akimichi Tatsukawa
 files: 
-- tests/test_parser_cps.rb
 - tests/test_parser.rb
 - tests/test_calc.rb
-- lib/parser_cps.rb
 - lib/yaparc.rb
 - README
 test_files: 
-- tests/test_parser_cps.rb
 - tests/test_parser.rb
 - tests/test_calc.rb
 rdoc_options: []

data/lib/parser_cps.rb

@@ -1,319 +0,0 @@
-
-module Yaparc
-  module Parsable
-    include Yaparc
-    
-    attr_accessor :tree
-    
-    IS_LOWER = lambda {|c| c >= 'a' and c <= 'z'}
-    IS_ALPHANUM = lambda {|c| (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9')}
-    IS_DIGIT = lambda {|i| i > '0' and i < '9'}
-    IS_SPACE = lambda {|i| i == ' '}
-
-#     def self.included(mod)
-#       mod.extend ClassMethods
-#     end
-
-    def parse(input, cont, &block)
-      tree = @parser.call(input, cont)
-      if block_given?
-        @tree = yield tree
-      else
-        @tree = tree
-      end
-      cont.apply(input)
-    end
-  end # of Parsable
-
-  module Continuation
-    class Base
-      def apply(input)
-        @proc.call(input)
-      end
-#       def apply(arg, input = '')
-#         @proc.call(input,val)
-#       end
-    end
-
-    class StopCont < Base
-      def initialize
-#         @proc = lambda do |input|
-#           lambda{|input, val|
-#             [[val,input]]
-#           }
-#         end
-        @proc = lambda do |val, input|
-          [[val,input]]
-        end
-      end
-    end
-
-
-
-    class ItemHeadCont < Base
-      def initialize(input, cont)
-        @proc = lambda do |val, input|
-          [[val,input]]
-        end
-      end
-    end
-
-    class ItemTailCont < Base
-      def initialize(cont)
-        @proc = lambda do |val, input|
-          [[val,input]]
-        end
-      end
-    end
-  end # of Continuation
-
-  module Parser
-    class SucceedParser
-      include Parsable
-      def initialize(val)
-        @parser = lambda do |input, cont|
-          cont.apply(val)
-        end
-      end
-    end
-
-    class FailParser
-      include Parsable
-      def initialize
-        @parser = lambda do |input|
-          []
-        end
-      end
-    end
-
-    class ItemParser
-      include Parsable
-      def initialize(cont)
-        @parser = lambda do |input|
-          if input.nil? or input.empty?
-            FailParser.new(StopCont.new)
-          else
-#            head = input[0..0]
-#            tail = input[1..input.length]
-            ItemHeadCont.new(input,ItemTailCont.new(cont)).apply(input)
-          end
-        end
-      end
-    end
-
-    class SatisfyParser
-      include Parsable
-      def initialize(predicate)
-        @parser = lambda do |input|
-          item = ItemParser.new.parse(input)
-          if item == []
-            FailParser.new.parse(input)
-          else
-            if predicate.call(item[0][0])
-              SucceedParser.new(item[0][0]).parse(item[0][1])
-            else
-              FailParser.new.parse(input)
-            end
-          end
-        end
-      end
-    end
-
-    class SeqParser
-      include Parsable
-      def initialize(first, second, &block)
-        @parser = lambda do |input, cont|
-          SeqCont.new(first, second, cont).apply(input)
-        end
-      end # of initialize
-
-      class SeqCont < Continuation::Base
-        def initialize(first, second, cont)
-          @proc = lambda do |input|
-            first.parse(input, second.parse(input, cont))
-          end
-        end
-      end
-    end # of SeqParser
-
-
-
-    class AltParser
-      include Parsable
-      def initialize(left, right)
-        @parser = lambda do |input, cont|
-          AltCont.new(left, right, cont).apply(input)
-        end
-      end
-      class AltCont < Continuation::Base
-        def initialize(left, right, cont)
-          @proc = lambda do |input|
-            left.parse(input, cont) or right.parse(input, cont)
-          end
-        end
-      end
-    end # of AltParser
-
-    class CharParser
-      include Parsable
-      def initialize(char)
-        equal_char = lambda {|i| i == char}
-        @parser = lambda do |input|
-          SatisfyParser.new(equal_char).parse(input)
-        end
-      end
-    end
-
-    class StringParser
-      include Parsable
-      def initialize(string)
-        @parser = lambda do |input|
-          result = ItemParser.new.parse(string)
-          if result == []
-            SucceedParser.new(result).parse(input) # FailParser.new.parse(input)
-          else
-            SeqParser.new(
-                          CharParser.new(result[0][0]),
-                          StringParser.new(result[0][1]),
-                          SucceedParser.new(result[0][0] + result[0][1])
-                          ) do |char_result, string_result, succeed_result|
-              succeed_result
-            end.parse(input)
-          end
-        end
-      end
-    end
-
-    class RegexParser
-      include Parsable
-      def initialize(regex)
-        @parser = lambda do |input|
-          if match = Regexp.new(regex).match(input)
-            [[match[0],match.post_match]]
-          else
-            []
-          end
-        end
-      end
-    end
-
-    class ManyParser
-      include Parsable
-      def initialize(predicate)
-        @parser = lambda do |input|
-          AltParser.new(ManyOneParser.new(predicate), SucceedParser.new([])).parse(input)
-        end
-      end
-    end
-
-    class ManyOneParser
-      include Parsable
-      def initialize(predicate)
-        @parser = lambda do |input|
-          SeqParser.new(
-                        SatisfyParser.new(predicate),
-                        ManyParser.new(predicate)
-                        ) do |v, vs|
-            if vs == []
-              v
-            else
-              v + vs.to_s
-            end
-          end.parse(input)
-        end
-      end
-    end
-
-    class ZeroOneParser
-      include Parsable
-      def initialize(parser)
-        @parser = lambda do |input|
-          AltParser.new(parser, 
-                        SucceedParser.new([])).parse(input)
-        end
-      end
-    end
-
-    class Ident
-      include Parsable
-      def initialize
-        @parser = lambda do |input|
-          SeqParser.new(
-                        SatisfyParser.new(IS_LOWER),
-                        ManyParser.new(IS_ALPHANUM)
-                        ) do |v, vs|
-            if vs == []
-              v
-            else
-              v + vs.to_s
-            end
-          end.parse(input)
-        end
-      end
-    end
-
-    class Nat
-      include Parsable
-      def initialize
-        @parser = lambda do |input|
-          SeqParser.new(ManyOneParser.new(IS_DIGIT)) do |vs|
-            if vs == []
-              vs
-            else
-              vs.to_i
-            end
-          end.parse(input)
-        end
-      end
-    end
-
-    class Space
-      include Parsable
-      def initialize
-        @parser = lambda do |input|
-          SeqParser.new(ManyParser.new(IS_SPACE)) do |vs|
-            []
-          end.parse(input)
-        end
-      end
-    end
-
-    class Token
-      include Parsable
-      def initialize(parser)
-        @parser = lambda do |input|
-          SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
-            vs
-          end.parse(input)
-        end
-      end
-    end
-
-    class Identifier
-      include Parsable
-      def initialize
-        @parser = lambda do |input|
-          Token.new(Ident.new).parse(input)
-        end
-      end
-    end
-
-    class Natural
-      include Parsable
-      def initialize
-        @parser = lambda do |input|
-          Token.new(Nat.new).parse(input)
-        end
-      end
-    end
-
-    class Symbol
-      include Parsable
-      def initialize(literal)
-        @parser = lambda do |input|
-          Token.new(StringParser.new(literal)).parse(input)
-        end
-      end
-    end
-  end # of Parser
-end # Yaparc

data/tests/test_parser_cps.rb

@@ -1,38 +0,0 @@
-require 'lib/parser_cps.rb'
-require 'test/unit'
-require 'pp'
-
-class YaparcTest < Test::Unit::TestCase
-  include ::Yaparc
-
-
-  def setup
-    @stop = Continuation::StopCont.new
-  end
-
-
-  def test_succeed_parse
-    parser = ::Yaparc::Parser::SucceedParser.new(1)
-    assert_equal [[1, "abs"]], parser.parse("abs", @stop)
-#     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::Parser::FailParser.new(@stop)
-#     result = parser.parse("abc")
-#     assert_equal [],  result
-#   end
-
-#   def test_item_parse
-#     parser = ::Yaparc::Parser::ItemParser.new(@stop)
-#     result = parser.parse("")
-#     assert_equal [],  result
-#     result = parser.parse("abc")
-#     assert_equal [["a", "bc"]],  result
-#   end
-end
-