RubyGems - yaparc - Versions diffs - 0.2.3 → 0.3.0 - Mend

yaparc 0.2.3 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

data/test/test_prolog.rb DELETED Viewed

@@ -1,287 +0,0 @@
-require 'lib/yaparc.rb'
-require 'test/unit'
-=begin
-<prog> ::= <clause> [ <clause> ]*
-<clause> ::= <fact> | <rule> | <query>
-<fact> ::= <compoundterm> .
-<compoundterm> ::= <atom> [ ( <arglist> ) ]*
-<rule> ::= <head> :- <body> .
-<query> ::= ?- <body> .
-<head> ::= <compoundterm>
-<body> ::= <goal> [, <goal>]*
-<goal> ::= <compoundterm> | !
-<arglist> := <arg>[, <arg>]*
-<arg> ::= <atom> | <var> | <list>
-<atom> ::= /[a-zA-Z][a-zA-Z0-9]*/
-         | '/[a-zA-Z0-9]+/'
-<var> ::= ?/[a-zA-Z0-9]+/
-<list> ::= <leftbracket> <rightbracket>
-<list> ::= <leftbracket> <listelems> <rightbracket>
-<listelems> ::= <arglist>
-<listelems> ::= <arglist> <barsymbol> <list>
-<listelems> ::= <arglist> <barsymbol> <var>
-=end
-module PrologParser
-  #  KEYWORDS = %w{}
-  # <prog> ::= <clause> [ <clause> ]*
-  class Program
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(Yaparc::ManyOne.new(Clause.new,[])) do |clauses|
-          #LogRuby::Program.new(*clauses)
-        end
-      end
-    end
-  end
-  # <clause> ::= <fact> | <rule> | <query>
-  class Clause
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Alt.new(
-                        PrologParser::Fact.new,
-                        PrologParser::Rule.new,
-                        PrologParser::Query.new
-                        )
-      end
-    end
-  end
-  # <fact> ::= <compoundterm> .
-  class Fact
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(
-                        PrologParser::CompoundTerm.new,
-                        Yaparc::Literal.new('.')) do |compoundterm,_|
-          #LogRuby::Fact.new(compoundterm)
-        end
-      end
-    end
-  end
-  # <compoundterm> ::= <atom> [ ( <arglist> ) ]*
-  class CompoundTerm
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(
-                        PrologParser::Atom.new,
-                        Yaparc::ManyOne.new(
-                                            Yaparc::Seq.new(
-                                                            Yaparc::Literal.new('('),
-                                                            PrologParser::ArgList.new,
-                                                            Yaparc::Literal.new(')')) do |_,arglist,_|
-                                              arglist
-                                            end) do ||
-                        end) do |head, tail|
-          #LogRuby::CompoundTerm.new(head,*tail)
-        end
-      end
-    end
-  end
-  # <rule> ::= <head> :- <body> .
-  class Rule
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(
-                        PrologParser::Head.new,
-                        Yaparc::Literal.new(':-'),
-                        PrologParser::Body.new,
-                        Yaparc::Literal.new('.')) do |head,_,body,_|
-          #LogRuby::Rule.new(head,*body)
-        end
-      end
-    end
-  end
-  # <query> ::= ?- <body> .
-  class Query
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(
-                        Yaparc::Literal.new('?-'),
-                        PrologParser::Body.new,
-                        Yaparc::Literal.new('.')) do |_,body,_|
-#          LogRuby::Query.new(*body)
-        end
-      end
-    end
-  end
-  # <head> ::= <compoundterm>
-  class Head
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        PrologParser::CompoundTerm.new
-      end
-    end
-  end
-  # <body> ::= <goal> [, <goal>]*
-  class Body
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::ManyOne.new(PrologParser::Goal.new,[])
-      end
-    end
-  end
-  # <goal> ::= <compoundterm> | !
-  class Goal
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Alt.new(
-                        PrologParser::CompoundTerm.new,
-                        Yaparc::Literal.new('!'))
-      end
-    end
-  end
-  # <arglist> := <arg>[, <arg>]*
-  class ArgList
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(
-                        PrologParser::Arg.new,
-                        Yaparc::Many.new(
-                                         Yaparc::Seq.new(Yaparc::Literal.new(','), PrologParser::Arg.new),[])) do |head,tail|
-          [head] + tail
-        end
-      end
-    end
-  end
-  # <arg> ::= <atom> | <var> | <list>
-  class Arg
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Alt.new(
-                        PrologParser::Variable.new,
-                        PrologParser::Atom.new,
-                        PrologParser::List.new)
-      end
-    end
-  end
-  # <atom> ::= /[a-zA-Z][a-zA-Z0-9]*/
-  #          | '/[a-zA-Z0-9]+/'
-  class Atom
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(Yaparc::Regex.new(/[a-zA-Z][a-zA-Z0-9]*/)) do |ide|
-          #LogRuby::Atom.new(ide)
-        end
-      end
-    end
-  end
-  # <var> ::= ?/[a-zA-Z0-9]+/
-  class Variable
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(
-                        Yaparc::Literal.new("?"),
-                        Yaparc::Regex.new(/[a-zA-Z0-9]+/)) do |_,var|
-#          LogRuby::Variable.new(var)
-        end
-      end
-    end
-  end
-  # <list> ::= <leftbracket> <rightbracket>
-  class List
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.new(
-                        Yaparc::Literal.new("["),
-                        Yaparc::Literal.new("]"))
-      end
-    end
-  end
-end # of PrologParser
-class PrologTest < Test::Unit::TestCase
-  include ::Yaparc
-  def test_variable
-    var = PrologParser::Variable.new
-    result = var.parse("?Var")
-    assert_instance_of Result::OK, result
-#    assert_equal LogRuby::Variable.new("Var"), result.value
-  end
-  def test_atom
-    atom = PrologParser::Atom.new
-    result = atom.parse("atom")
-    assert_instance_of Result::OK, result
-#    assert_equal LogRuby::Atom.new("atom"), result.value
-  end
-  def test_arglist
-    arglist = PrologParser::ArgList.new
-    result = arglist.parse("term1,term2,term3")
-    assert_instance_of Result::OK, result
-#    assert_equal LogRuby::Atom.new("atom"), result.value
-  end
-  def test_compoundterm
-    compoundterm = PrologParser::CompoundTerm.new
-    result = compoundterm.parse("functor(term1,term2,term3)")
-    assert_instance_of Result::OK, result
-#    assert_equal LogRuby::CompoundTerm.new(LogRuby::Atom.new("functor"),
-#                                           LogRuby::Atom.new("term1"),LogRuby::Atom.new("term2"),LogRuby::Atom.new("term3")), result.value
-  end
-  def test_query
-    query = PrologParser::Query.new
-    result = query.parse("?- functor(?var,term).")
-    assert_instance_of Result::OK, result
-#    assert_equal LogRuby::Query.new(LogRuby::CompoundTerm.new(LogRuby::Atom.new('functor'),LogRuby::Variable.new('var'), LogRuby::Atom.new('term'))), result.value
-  end
-  def test_fact
-    fact = PrologParser::Fact.new
-    result = fact.parse("functor(term).")
-    assert_instance_of Result::OK, result
-#    assert_equal LogRuby::Fact.new(LogRuby::CompoundTerm.new(LogRuby::Atom.new('functor'),LogRuby::Atom.new('term'))), result.value
-  end
-  def test_rule
-    # likes(X, P) :- based(P,Y), likes(X,Y).
-    rule_parser = PrologParser::Rule.new
-    result = rule_parser.parse("likes(?X, ?P) :- based(?P,?Y), likes(?X,?Y).")
-    assert_instance_of Result::OK, result
-#    assert_equal rule, result.value
-  end
-end

data/test/test_sql.rb DELETED Viewed

@@ -1,317 +0,0 @@
-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
-  KEYWORDS = %w{NOT AND OR ALL IN select from where EXISTS}
-  ###  query_body := select_expression from_expression where_expression
-  class QueryBody
-    include Yaparc::Parsable
-    def initialize
-      @parser = lambda do |input|
-        Yaparc::Seq.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 |input|
-        Yaparc::Seq.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 |input|
-        Yaparc::Seq.new(
-                        Term.new,
-                        Yaparc::Many.new(
-                                         Yaparc::Seq.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 |input|
-        Yaparc::Seq.new(
-                        Yaparc::Symbol.new('from'),
-                        PathExpression.new,
-                        Yaparc::Many.new(
-                                         Yaparc::Seq.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 |input|
-        Yaparc::Seq.new(
-                              Yaparc::Symbol.new('/'),
-                              Term.new,
-                              Yaparc::Many.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 |input|
-        Yaparc::Many.new(SearchCond.new)
-      end
-    end
-  end
-  ###  term := any_characters
-  class Term
-    include Yaparc::Parsable
-    def initialize#(*keywords)
-      @parser = lambda do |input|
-#        Yaparc::Identifier.new(*KEYWORDS)
-        Yaparc::Identifier.new(:exclude => KEYWORDS)
-      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 |input|
-        Yaparc::Alt.new(
-                        Yaparc::Seq.new(Term.new,
-                                        Op.new,
-                                        Term.new) do |term1, op, term2|
-                          {:operator => op, :args => [term1, term2]}
-                        end,
-                        Yaparc::Seq.new(Yaparc::Symbol.new('('),
-                                        Yaparc::Symbol.new('NOT'),
-                                        SearchCond.new,
-                                        Yaparc::Symbol.new(')')) do |_, _, cond, _|
-                          {:logic => :not, :conditions => [cond]}
-                        end,
-                        Yaparc::Seq.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::Seq.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::Seq.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::Seq.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::Seq.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::Seq.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 |input|
-        Yaparc::Alt.new(
-                        Yaparc::Apply.new(Yaparc::Symbol.new('<>')) {|_| :not},
-                        Yaparc::Apply.new(Yaparc::Symbol.new('<=')) {|_| :lesser_eq },
-                        Yaparc::Apply.new(Yaparc::Symbol.new('>=')) {|_| :greater_eq },
-                        Yaparc::Apply.new(Yaparc::Symbol.new('<')) {|_| :lesser},
-                        Yaparc::Apply.new(Yaparc::Symbol.new('>')) {|_| :greater })
-      end
-    end
-  end
-end # of SQL
-class YaparcQueryTest < Test::Unit::TestCase
-  include ::Yaparc
-  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