yaparc 0.0.1

data/README

@@ -0,0 +1,16 @@
+= Synopsis
+
+This is a yet another simple combinator parser library in ruby.
+
+= Requirements
+
+* Ruby (http://www.ruby-lang.org/)
+
+= Install
+
+ $ gem install yaparc
+
+= Usage
+
+Please look at unit test files.
+

data/lib/parser.rb

@@ -0,0 +1,271 @@
+
+module Yaparc
+  module Parsable
+    include Yaparc
+
+    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)
+      @parser.call(input)
+    end
+
+    def eval
+      tree = parse(input)
+    end
+
+    def define_parser
+      raise
+    end
+
+    module ClassMethods
+      def included(mod)
+      end
+
+#       def self.initialize
+#         @parser = @@parser
+#       end
+
+      def define_parser(&block)
+        @@parser = lambda do |input|
+          parser = yield 
+          parser.parse(input)
+        end
+      end
+    end
+  end # of Parsable
+
+  class SucceedParser
+    include Parsable
+    def initialize(value)
+      @parser = lambda {|input| [[value, input]]}
+    end
+  end
+
+  class FailParser
+    include Parsable
+    def initialize
+      @parser = lambda {|input| []}
+    end
+  end
+
+  class ItemParser
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        if input.nil? or input.empty?
+          []
+        else
+          [[input[0..0],input[1..input.length]]]
+        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(*parsers, &block)
+      @parser = lambda do |input|
+        args = []
+        remains = parsers.inject(input) do |accumulator, parser|
+          result = parser.parse(accumulator)
+          unless result == []
+            args << result[0][0]
+            result[0][1]
+          else
+            break []
+          end
+        end
+        unless remains == []
+          retval = yield(*args)
+          [[retval, remains]]
+        else
+          []
+        end
+      end
+    end # of initialize
+  end # of SeqParser
+
+  class AltParser
+    include Parsable
+    def initialize(*parsers)
+      @parser = lambda do |input|
+        parsers.inject([]) do |accum, parser|
+          result = parser.parse(input)
+          if result == []
+            result
+          else
+            break [result[0]]
+          end
+        end
+      end
+    end # of initialize
+  end
+
+  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 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 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

data/tests/test_calc.rb

@@ -0,0 +1,129 @@
+require 'lib/parser.rb'
+require 'test/unit'
+require 'pp'
+
+
+
+class Expr
+  include Yaparc::Parsable
+
+#   define_parser do
+#     AltParser.new(
+#                   SeqParser.new(Term.new,
+#                                 Symbol.new('+'),
+#                                 Expr.new) do |term, _, expr|
+#                     ['+', term,expr]
+#                   end,
+#                   Term.new
+#                   )
+#   end
+
+  def initialize
+    @parser = lambda do |input|
+      AltParser.new(
+                    SeqParser.new(Term.new,
+                                  Symbol.new('+'),
+                                  Expr.new) do |term, _, expr|
+                      ['+', term,expr]
+                    end,
+                    Term.new
+                    ).parse(input)
+    end
+  end
+
+  def eval(input)
+    result = parse(input)
+    tree = result[0][0]
+#    p tree
+    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])
+      end
+    else
+      tree
+    end
+    
+  end
+end
+
+class Term
+  include Yaparc::Parsable
+
+#   define_parser do
+#     AltParser.new(
+#                   SeqParser.new(Factor.new,
+#                                 Symbol.new('*'),
+#                                 Term.new) do |factor, _, term|
+#                     ['*', factor,term]
+#                   end,
+#                   Factor.new
+#                   )
+#   end
+
+  def initialize
+    @parser = lambda do |input|
+      AltParser.new(
+                    SeqParser.new(Factor.new,
+                                  Symbol.new('*'),
+                                  Term.new) do |factor, _, term|
+                      ['*', factor,term]
+                    end,
+                    Factor.new
+                    ).parse(input)
+    end
+  end
+end
+
+class Factor
+  include Yaparc::Parsable
+
+#   define_parser do
+#     AltParser.new(
+#                   SeqParser.new(Symbol.new('('),
+#                                 Expr.new,
+#                                 Symbol.new(')')) do |_,expr, _|
+#                     expr
+#                   end,
+#                   Natural.new
+#                   )
+#   end
+
+  def initialize
+    @parser = lambda do |input|
+      AltParser.new(
+                    SeqParser.new(Symbol.new('('),
+                                  Expr.new,
+                                  Symbol.new(')')) do |_,expr, _|
+                      expr
+                    end,
+                    Natural.new
+                    ).parse(input)
+    end
+  end
+end
+
+class YaparcCalcTest < Test::Unit::TestCase
+  include ::Yaparc
+
+  def setup
+  end
+  def test_expr
+    parser = Expr.new
+    result = parser.parse("1 + 2 ")
+    assert_equal [[["+", 1, 2], ""]],  result
+    assert_equal 3, parser.eval("1 + 2 ")
+    assert_equal 9, parser.eval("(1 + 2) * 3 ")
+  end
+end

data/tests/test_parser.rb

@@ -0,0 +1,167 @@
+require 'lib/parser.rb'
+require 'test/unit'
+require 'pp'
+
+class YaparcTest < Test::Unit::TestCase
+  include ::Yaparc
+
+
+  def setup
+
+  end
+
+  def teardown
+  end
+
+  def test_succeed_parse
+    parser = ::Yaparc::SucceedParser.new(1)
+    assert_equal [[1, "abs"]], parser.parse("abs")
+  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
+    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
+
+    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_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_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_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
+
+    parser = StringParser.new("abc")
+    result = parser.parse("ab1234")
+    assert_equal [],  result
+  end
+
+  def test_many_parse
+    is_digit = 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
+  end
+
+  def test_nat
+    parser = Nat.new
+    result = parser.parse("123 abc")
+    assert_equal [[123, " abc"]],  result
+  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
+  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
+  end
+
+end
+

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.3
+specification_version: 1
+name: yaparc
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-12-06 00:00:00 +09:00
+summary: Yet Another Combinator Parser Library
+require_paths: 
+- lib
+email: akimichi_tatsukawa@nifty.com
+homepage: http://rubyforge.org/projects/yaparc/
+rubyforge_project: 
+description: 
+autorequire: parser
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Akimichi Tatsukawa
+files: 
+- tests/test_calc.rb
+- tests/test_parser.rb
+- lib/parser.rb
+- README
+test_files: 
+- tests/test_calc.rb
+- tests/test_parser.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+