yaparc 0.2.0 → 0.2.2

data/README

@@ -136,6 +136,19 @@ The ManyOne requires at least one successfull application of parser.
 * Symbol
 
 
+== Regex parser
+
+    parser = Regex.new(/\A[0-9]+/)
+    result = parser.parse("1234ab")
+    assert_equal '1234',  result.value
+
+    parser = Regex.new(/([0-9]+):([a-z]+)/) do  |match1, match2|
+      [match2,match1]
+    end
+    result = parser.parse("1234:ab")
+    assert_equal ["ab", "1234"],  result.value
+
+
 == Define your own parser
 
 In order to construct parsers, you make parser class to be inherited from Yaparc::AbstractParser class.

data/lib/yaparc.rb

@@ -27,41 +27,55 @@ module Yaparc
     IS_DIGIT = lambda {|i| i >= '0' and i <= '9'}
     IS_SPACE = lambda {|i| i == ' '}
     IS_WHITESPACE = lambda {|i| i == ' ' or i == "\n" or i == "\t"}
+    IS_CR = lambda {|i| i == "\n"}
 
-    def self.included(mod)
-      mod.extend ClassMethods
-    end
+#     def self.included(mod)
+#       mod.extend ClassMethods
+#     end
 
-    def parse(input, &block)
+    def parse(input) #, &block)
       result = @parser.call(input)
 
-      if result.respond_to? :parse
-        result = result.parse(input)
+      if result.respond_to?(:parse)
+        result.parse(input)
       else
-        if block_given?
-          result.value = yield result.value
-          @tree = result
-        else
-          @tree = result.value
-        end
         result
       end
-    end
 
-    def eval
-      tree = parse(input)
+#       if result.respond_to? :parse
+#         result = result.parse(input)
+#       else
+# #         if block_given?
+# #           result.value = yield result.value
+# #           @tree = result
+# #         end
+#         result
+#       end
+
+#      if result.respond_to? :parse
+#         result = result.parse(input)
+#       else
+#         if block_given?
+#           result.value = yield result.value
+#           @tree = result
+#         else
+#           @tree = result.value
+#         end
+#         result
+#       end
     end
 
-
-    module ClassMethods
-      def included(mod)
-      end
-    end
-  end # of Module Parsable
+#     def eval
+#       tree = parse(input)
+#     end
 
 
+#     module ClassMethods
+#       def included(mod)
+#       end
+#     end
+  end # of Module Parsable
 
-#  class SucceedParser
   class Succeed
     include Parsable
     attr_reader :remaining
@@ -73,7 +87,6 @@ module Yaparc
     end
   end
 
-#  class FailParser
   class Fail
     include Parsable
     def initialize
@@ -84,8 +97,6 @@ module Yaparc
   end
 
 
-
-#  class ItemParser
   class Item
     include Parsable
     def initialize
@@ -99,7 +110,6 @@ module Yaparc
     end
   end
 
-#  class ZeroOneParser
   class ZeroOne
     include Parsable
     def initialize(parser, identity = [])
@@ -115,36 +125,43 @@ module Yaparc
         else
           raise
         end
-
-#        AltParser.new(parser, Succeed.new(identity))
-#         case result = AltParser.new(parser, Succeed.new(identity)).parse(input)
-#         if input.nil? or input.empty?
-#           Result::Fail.new(:input => input)
-#         else
-#           Result::OK.new(:value => input[0..0],:input => input[1..input.length])
-#         end
-
       end
     end
   end
 
-#  class SatisfyParser
   class Satisfy
     include Parsable
     def initialize(predicate)
       raise unless predicate.instance_of?(Proc)
 
       @parser = lambda do |input|
-        case result = Item.new.parse(input)
-        when Result::OK
-          parser = if predicate.call(result.value)
-                     Succeed.new(result.value, result.input)
-                   else
-                     Fail.new
-                   end
-        else # Result::Fail or Result::Error
+        result = Item.new.parse(input)
+        if result.instance_of?(Result::OK) and predicate.call(result.value)
+          Succeed.new(result.value, result.input)
+        else
           Fail.new
         end
+
+#         if result.instance_of?(Result::OK)
+#           if predicate.call(result.value)
+#             Succeed.new(result.value, result.input)
+#           else
+#             Fail.new
+#           end
+#         else # Result::Fail or Result::Error
+#           Fail.new
+#         end
+
+#         case result = Item.new.parse(input)
+#         when Result::OK
+#           parser = if predicate.call(result.value)
+#                      Succeed.new(result.value, result.input)
+#                    else
+#                      Fail.new
+#                    end
+#         else # Result::Fail or Result::Error
+#           Fail.new
+#         end
       end
     end
 
@@ -167,21 +184,26 @@ module Yaparc
 
     def initialize(parser, &block)
       @parser = lambda do |input|
-        case result = parser.parse(input)
-        when Result::Fail
+        result = parser.parse(input)
+        if result.instance_of?(Result::Fail)
           Result::Error.new(:value => result.value, :input => result.input)
-        when Result::OK
-          Succeed.new(result.value)
         else
           Succeed.new(result.value)
-#          Result::OK.new(:value => result.value,:input => result.input)
         end
+#         case result = parser.parse(input)
+#         when Result::Fail
+#           Result::Error.new(:value => result.value, :input => result.input)
+#         when Result::OK
+#           Succeed.new(result.value)
+#         else
+#           Succeed.new(result.value)
+# #          Result::OK.new(:value => result.value,:input => result.input)
+#         end
       end
     end
   end # of NoFail
 
 
-#  class SeqParser
   class Seq
     include Parsable
     def initialize(*parsers, &block)
@@ -189,15 +211,20 @@ module Yaparc
         args = []
         initial_result = Result::OK.new(:input => input)
         final_result = parsers.inject(initial_result) do |subsequent, parser|
-          case result = parser.parse(subsequent.input)
-          when Result::Fail
+          result = parser.parse(subsequent.input)
+          if result.instance_of?(Result::Fail)
             break Result::Fail.new(:input => subsequent.input)
-#           when Result::Error
-#             break Result::Error.new(:input => subsequent.input)
           else
             args << result.value
             result
           end
+#           case result = parser.parse(subsequent.input)
+#           when Result::Fail
+#             break Result::Fail.new(:input => subsequent.input)
+#           else
+#             args << result.value
+#             result
+#           end
         end
 
         case final_result
@@ -217,21 +244,18 @@ module Yaparc
     end # of initialize
   end # of Seq
 
-
-#  class AltParser
   class Alt
     include Parsable
     def initialize(*parsers)
       @parser = lambda do |input|
-        initial_result = Result::OK.new(:input => input)
         final_result = Result::Fail.new(:input => input)
         parsers.each do |parser|
-#          case result = parser.parse(initial_result.input)
           case result = parser.parse(input)
           when Result::Fail
             next
-          when Result::Error
-            return Result::Error.new(:value => result.value, :input => result.input)
+#           when Result::Error
+#             raise
+#             return Result::Error.new(:value => result.value, :input => result.input)
           when Result::OK
             break final_result = result
           else
@@ -243,17 +267,22 @@ module Yaparc
     end # of initialize
   end
 
-#  class ApplyParser
   class Apply
     include Parsable
     def initialize(parser, &block)
       @parser = lambda do |input|
-        case result = parser.parse(input)
-        when Result::OK
+        result = parser.parse(input)
+        if result.instance_of?(Result::OK)
           Succeed.new(yield(result.value)).parse(result.input)
         else
           Fail.new.parse(input)
         end
+#         case result = parser.parse(input)
+#         when Result::OK
+#           Succeed.new(yield(result.value)).parse(result.input)
+#         else
+#           Fail.new.parse(input)
+#         end
       end
     end # of initialize
   end # of Apply
@@ -261,13 +290,13 @@ module Yaparc
 
   class String
     include Parsable
-    def initialize(string)
+    def initialize(string, case_sensitive = true)
       @parser = lambda do |input|
-        case result = Item.new.parse(string)
-        when Result::OK
+        result = Item.new.parse(string)
+        if result.instance_of?(Result::OK)
           Seq.new(
-                  Char.new(result.value),
-                  Yaparc::String.new(result.input),
+                  Char.new(result.value, case_sensitive),
+                  Yaparc::String.new(result.input, case_sensitive),
                   Succeed.new(result.value + result.input)
                   ) do |char_result, string_result, succeed_result|
             succeed_result
@@ -275,6 +304,18 @@ module Yaparc
         else
           Succeed.new(result) # Is it OK?
         end
+#         case result = Item.new.parse(string)
+#         when Result::OK
+#           Seq.new(
+#                   Char.new(result.value, case_sensitive),
+#                   Yaparc::String.new(result.input, case_sensitive),
+#                   Succeed.new(result.value + result.input)
+#                   ) do |char_result, string_result, succeed_result|
+#             succeed_result
+#           end
+#         else
+#           Succeed.new(result) # Is it OK?
+#         end
       end
     end
 
@@ -283,10 +324,9 @@ module Yaparc
 #     end
   end
 
-#  class RegexParser
   class Regex
     include Parsable
-    
+
     def initialize(regex, &block)
       @regex = regex
       @parser = lambda do |input|
@@ -303,6 +343,7 @@ module Yaparc
     end
 
     def parse_with_parameter(input)
+      raise "Deprecated!! Use Regex with block"
       if match = Regexp.new(@regex).match(input)
         if block_given?
           yield match.to_a[1..match.to_a.length]
@@ -316,7 +357,6 @@ module Yaparc
   end
 
   # permits zero or more applications of parser.
-#  class ManyParser
   class Many
     include Parsable
     def initialize(parser, identity = [])
@@ -327,7 +367,6 @@ module Yaparc
   end
 
   # requires at least one successfull application of parser.
-#  class ManyOne
   class ManyOne
     include Parsable
     def initialize(parser, identity = [])
@@ -338,41 +377,53 @@ module Yaparc
             if tail.instance_of?(::String)
               head + tail
             else
-              raise "Incompatible type: head => #{head}, tail => #{tail}"
+              raise "Incompatible type: head => #{head.inspect}, tail => #{tail.inspect}"
             end
           when ::Array
             if tail.instance_of?(Array)
               head + tail
             else
-              raise "Incompatible type: head => #{head}, tail => #{tail}"
+              raise "Incompatible type: head => #{head.inspect}, tail => #{tail.inspect}"
             end
           when ::Hash
             if tail.instance_of?(Hash)
               head.merge(tail)
             else
-              raise "Incompatible type: head => #{head}, tail => #{tail}"
+              raise "Incompatible type: head => #{head.inspect}, tail => #{tail.inspect}"
             end
           when ::Integer
             if tail.kind_of?(Integer)
               head + tail
             else
-              raise "Incompatible type: head => #{head}, tail => #{tail}"
+              raise "Incompatible type: head => #{head.inspect}, tail => #{tail.inspect}"
             end
           else
-            raise "Incompatible type: head => #{head}"
+            if tail.nil?
+              head
+            else
+              [head] + tail
+            end
           end
-          #head + tail
         end
       end
     end
   end
 
-#  class SpaceParser
   class Space
     include Parsable
     def initialize
       @parser = lambda do |input|
-        Seq.new(Many.new(Satisfy.new(IS_SPACE),""))
+        #Many.new(Satisfy.new(IS_SPACE),"")
+        Regex.new(/\A[ ]*/)
+      end
+    end
+  end
+
+  class CR
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        Regex.new(/\A[ \t]+[\n][ \t\n]+/)
       end
     end
   end
@@ -381,7 +432,8 @@ module Yaparc
     include Parsable
     def initialize
       @parser = lambda do |input|
-        Seq.new(Many.new(Satisfy.new(IS_WHITESPACE),''))
+        #Many.new(Satisfy.new(IS_WHITESPACE),'')
+        Regex.new(/\A[\t\n ]*/)
       end
     end
   end
@@ -392,7 +444,7 @@ module Yaparc
 
     def initialize(parser, args = { }, &block)
       @parser = lambda do |input|
-        @prefix = args[:prefix] ? args[:prefix] : WhiteSpace.new 
+        @prefix = args[:prefix] ? args[:prefix] : WhiteSpace.new
         @postfix = args[:postfix] ? args[:postfix] : WhiteSpace.new
         if block_given?
           yield self
@@ -408,18 +460,16 @@ module Yaparc
     end
   end
 
-#  class LiteralParser
   class Literal
     include Parsable
-    def initialize(literal)
+    def initialize(literal, case_sensitive = true)
       @parser =  lambda do |input|
-        Tokenize.new(Yaparc::String.new(literal))
+        Tokenize.new(Yaparc::String.new(literal, case_sensitive))
       end
     end
   end
 
   # Refer to http://www.cs.nott.ac.uk/~gmh/monparsing.pdf, p.23
-
   class Identifier
     include Yaparc::Parsable
     @@identifier_regex = ::Yaparc::Regex.new(/\A[a-zA-Z_]+[a-zA-Z0-9_]*/)
@@ -442,17 +492,21 @@ module Yaparc
       end
     end
 
-    def parse(input)
-      @parser.call(input).parse(input)
-    end
+#     def parse(input)
+#       @parser.call(input).parse(input)
+#     end
   end
 
-#  class Char
   class Char
     include Parsable
 
-    def initialize(char)
-      equal_char = lambda {|i| i == char}
+    def initialize(char, case_sensitive = true)
+      raise unless char.length == 1
+      if case_sensitive
+        equal_char = lambda {|i| i == char}
+      else # in case of case-insentive
+        equal_char = lambda {|i| i.casecmp(char) == 0}
+      end
       @parser =  lambda do |input|
         Satisfy.new(equal_char)
       end
@@ -464,9 +518,9 @@ module Yaparc
     def initialize
       @parser = lambda do |input|
         Seq.new(
-                      Satisfy.new(IS_LOWER),
-                      Many.new(Satisfy.new(IS_ALPHANUM),"")
-                      ) do |head, tail|
+                Satisfy.new(IS_LOWER),
+                Many.new(Satisfy.new(IS_ALPHANUM),"")
+                ) do |head, tail|
           head + tail
         end
       end
@@ -519,6 +573,14 @@ module Yaparc
   class AbstractParser
     include Parsable
 
+#     def parse(input, &block)
+#       tree = @parser.call.parse(input)
+#       if block_given?
+#         yield tree
+#       else
+#         tree
+#       end
+#     end
     def parse(input, &block)
       tree = @parser.call.parse(input)
       if block_given?

data/tests/test_parser.rb

@@ -186,6 +186,14 @@ class YaparcTest < Test::Unit::TestCase
     parser = Char.new("a")
     result = parser.parse("123")
     assert_instance_of Result::Fail,  result
+
+    parser = Char.new("a", false)
+    result = parser.parse("a")
+    assert_instance_of Result::OK,  result
+    result = parser.parse("A")
+    assert_instance_of Result::OK,  result
+    result = parser.parse("!")
+    assert_instance_of Result::Fail,  result
   end
 
   def test_string_parse
@@ -197,6 +205,12 @@ class YaparcTest < Test::Unit::TestCase
     parser = Yaparc::String.new("abc")
     result = parser.parse("ab1234")
     assert_instance_of  Result::Fail,  result
+
+    parser = Yaparc::String.new("abc", false)
+    result = parser.parse("abc")
+    assert_instance_of  Result::OK,  result
+    result = parser.parse("aBc")
+    assert_instance_of  Result::OK,  result
   end
 
   def test_regex_parse
@@ -211,15 +225,17 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal "ab",  result.input
 
     parser = Regex.new(/\A[0-9]+/)
-    result = parser.parse("1234ab") do |match|
-      Integer(match)
-    end
-    assert_equal 1234,  result.value
+    result = parser.parse("1234ab")
+#     result = parser.parse("1234ab") do |match|
+#       Integer(match)
+#     end
+#    assert_equal 1234,  result.value
+    assert_equal '1234',  result.value
 
-    parser = Regex.new(/([0-9]+):([a-z]+)/)
-    result = parser.parse_with_parameter("1234:ab") do |match1, match2|
-      assert_equal 'ab',  match2
-    end
+#     parser = Regex.new(/([0-9]+):([a-z]+)/)
+#     result = parser.parse_with_parameter("1234:ab") do |match1, match2|
+#       assert_equal 'ab',  match2
+#     end
 
     parser = Regex.new(/([0-9]+):([a-z]+)/) do  |match1, match2|
       [match2,match1]
@@ -305,19 +321,26 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal "",  result.input
   end
 
-#   def test_space
-#     parser = Space.new
-#     result = parser.parse("    abc")
-#     assert_instance_of Result::OK,  result
-#     assert_equal "abc",  result.input
-#   end
+  def test_space
+    parser = Space.new
+    result = parser.parse("    abc")
+    assert_instance_of Result::OK,  result
+    assert_equal "abc",  result.input
+  end
 
-#   def test_whitespace
-#     parser = WhiteSpace.new
-#     result = parser.parse(" \n   abc")
-#     assert_instance_of Result::OK,  result
-#     assert_equal "abc",  result.input
-#   end
+  def test_whitespace
+    parser = WhiteSpace.new
+    result = parser.parse(" \n   abc")
+    assert_instance_of Result::OK,  result
+    assert_equal "abc",  result.input
+    snip =<<-SNIP
+        
+       abc
+    SNIP
+    result = parser.parse(snip)
+    assert_instance_of Result::OK,  result
+    assert_equal "abc\n",  result.input
+  end
 
 #   def test_token
 #     parser = Token.new
@@ -406,6 +429,12 @@ class YaparcTest < Test::Unit::TestCase
     result = parser.parse(" % ")
     assert_equal "%",  result.value
     assert_equal "",  result.input
+
+    parser = Literal.new('vgh', false)
+    result = parser.parse(" vgh ")
+    assert_instance_of Result::OK,  result
+    result = parser.parse(" vgH ")
+    assert_instance_of Result::OK,  result
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: yaparc
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors: 
 - Akimichi Tatsukawa
@@ -9,7 +9,7 @@ autorequire: yaparc
 bindir: bin
 cert_chain: []
 
-date: 2008-04-27 00:00:00 +09:00
+date: 2008-05-08 00:00:00 +09:00
 default_executable: 
 dependencies: []