pione 0.2.2 → 0.3.0

data/test/model/spec_data-expr.yml

@@ -1,24 +0,0 @@
-# |
-- "'a' | 'b' | 'c'" : "'a' | 'b' | 'c'"
-
-# except
-- "'a'.except('b')" : "'a'.except('b')"
-- "'a'.except('b'.except('c'))" : "'a'.except('b'.except('c'))"
-
-# exceptions
-- "'b'" : "'a'.except('b').exceptions"
-
-# accept_nonexistence?
-- "false" : "'a'.accept_nonexistence?"
-- "false" : "('a' or 'a').accept_nonexistence?"
-- "true" : "('a' or null).accept_nonexistence?"
-- "true" : "(null or 'a').accept_nonexistence?"
-- "true" : "(null or null).accept_nonexistence?"
-- "false | false | false" : "('a' | 'b' | 'c').accept_nonexistence?"
-- "true | false | false" : "('a' or null | 'b' | 'c').accept_nonexistence?"
-- "true | true | false" : "('a' or null | 'b' or null | 'c').accept_nonexistence?"
-- "true | true | true" : "('a' or null | 'b' or null | 'c' or null).accept_nonexistence?"
-
-# as_string
-- '"a b c"' : "('a' | 'b' | 'c').as_string.join(\" \")"
-

data/test/model/spec_data-expr_match.yml

@@ -1,45 +0,0 @@
-"'*.a'":
-  match:
-    - "1.a"
-    - "2.a"
-    - "3.a"
-    - "123.a"
-  unmatch:
-    - "1.b"
-    - ".a"
-    - "a"
-    - "1.1a"
-    - "1.aa"
-    - "123.aa"
-"'A:B'":
-  match:
-    - "A"
-    - "B"
-  unmatch:
-    - "AB"
-    - "BA"
-"'*.a:*.b'":
-  match:
-    - "1.a"
-    - "1.b"
-  unmatch:
-    - "1.ab"
-    - "1.ba"
-    - ".a"
-    - ".b"
-"'A' or 'B'":
-  match:
-    - "A"
-    - "B"
-  unmatch:
-    - "AB"
-    - "BA"
-"'*.a' or '*.b'":
-  match:
-    - "1.a"
-    - "1.b"
-  unmatch:
-    - "1.ab"
-    - "1.ba"
-    - ".a"
-    - ".b"

data/test/model/spec_feature-expr.rb

@@ -1,333 +0,0 @@
-require_relative '../test-util'
-
-describe 'Feature::Expr' do
-  it 'should equal' do
-    Feature::PossibleExpr.new("A").should ==
-      Feature::PossibleExpr.new("A")
-    Feature::RestrictiveExpr.new("A").should ==
-      Feature::RestrictiveExpr.new("A")
-  end
-
-  it 'should not equal' do
-    possible_a = Feature::PossibleExpr.new("A")
-    possible_b = Feature::PossibleExpr.new("B")
-    restrictive_a = Feature::RestrictiveExpr.new("A")
-    restrictive_b = Feature::RestrictiveExpr.new("B")
-    requisite_a = Feature::RequisiteExpr.new("A")
-    requisite_b = Feature::RequisiteExpr.new("B")
-    blocking_a = Feature::BlockingExpr.new("A")
-    blocking_b = Feature::BlockingExpr.new("B")
-    preferred_a = Feature::PreferredExpr.new("A")
-    preferred_b = Feature::PreferredExpr.new("B")
-    empty = Feature::EmptyFeature.new
-    boundless = Feature::BoundlessFeature.new
-    possible_a.should.not == possible_b
-    possible_a.should.not == restrictive_a
-    possible_a.should.not == requisite_a
-    possible_a.should.not == blocking_a
-    possible_a.should.not == preferred_a
-    possible_a.should.not == empty
-    possible_a.should.not == boundless
-    restrictive_a.should.not == restrictive_b
-  end
-
-  it 'should match' do
-    possible = Feature::PossibleExpr.new("A")
-    requisite = Feature::RequisiteExpr.new("A")
-    possible.match(requisite).should.true
-  end
-
-  it 'should not match' do
-    possible = Feature::PossibleExpr.new("A")
-    requisite = Feature::RequisiteExpr.new("B")
-    requisite.match(possible).should.false
-  end
-
-  describe 'Feature::EmptyFeature' do
-    it 'should be equal' do
-      Feature.empty.should == Feature.empty
-      Feature.empty.should == Feature.and()
-      Feature.empty.should == Feature.or()
-    end
-  end
-
-  describe 'Feature::AndExpr' do
-    it 'should be equal' do
-      Feature.and().should == Feature.empty
-    end
-
-    it 'should be empty' do
-      Feature.and.should.be.empty
-    end
-
-    it 'should add elements' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      c = Feature::PossibleExpr.new("C")
-      d = Feature::PossibleExpr.new("D")
-      and1 = Feature::AndExpr.new(a, b)
-      Feature::AndExpr.new(and1, c, d).should ==
-        Feature::AndExpr.new(a, b, c, d)
-    end
-
-    it 'should unify redundant elements' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      and1 = Feature::AndExpr.new(a, b)
-      Feature::AndExpr.new(and1, a, b).should == and1
-      Feature::AndExpr.new(and1, and1).should == and1
-    end
-
-    it 'should background preferred feature by requisite feature' do
-      requisite = Feature::RequisiteExpr.new("A")
-      preferred = Feature::PreferredExpr.new("A")
-      Feature::AndExpr.new(requisite, preferred).simplify.should ==
-        requisite
-      Feature::AndExpr.new(preferred, requisite).simplify.should ==
-        requisite
-    end
-
-    it 'should background preferred feature by blocking feature' do
-      blocking = Feature::BlockingExpr.new("A")
-      preferred = Feature::PreferredExpr.new("A")
-      Feature::AndExpr.new(blocking, preferred).simplify.should ==
-        blocking
-      Feature::AndExpr.new(preferred, blocking).simplify.should ==
-        blocking
-    end
-
-    it 'should summarize or-clause' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      c = Feature::PossibleExpr.new("C")
-      d = Feature::PossibleExpr.new("D")
-      or1 = Feature::OrExpr.new(a, b)
-      or2 = Feature::OrExpr.new(a, c)
-      or3 = Feature::OrExpr.new(a, d)
-      or4 = Feature::OrExpr.new(c, d)
-      Feature::AndExpr.new(or1, or2).simplify.should ==
-        Feature::OrExpr.new(a, Feature::AndExpr.new(b, c))
-      Feature::AndExpr.new(or2, or1).simplify.should ==
-        Feature::OrExpr.new(a, Feature::AndExpr.new(b, c))
-      Feature::AndExpr.new(or1, or2, or3).simplify.should ==
-        Feature::OrExpr.new(a, Feature::AndExpr.new(b, c, d))
-      Feature::AndExpr.new(or1, or2, or4).simplify.should ==
-        Feature::AndExpr.new(Feature::OrExpr.new(a, Feature::AndExpr.new(b, c)),
-                             Feature::OrExpr.new(c, d))
-    end
-
-    it 'should unify by restrictive feature' do
-      possible = Feature::PossibleExpr.new("A")
-      restrictive = Feature::RestrictiveExpr.new("A")
-      Feature::AndExpr.new(possible, restrictive).simplify.should ==
-        restrictive
-      Feature::AndExpr.new(restrictive, possible).simplify.should ==
-        restrictive
-    end
-
-    it 'should expand' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      c = Feature::PossibleExpr.new("C")
-      d = Feature::PossibleExpr.new("D")
-      or1 = Feature::OrExpr.new(a, b)
-      or2 = Feature::OrExpr.new(c, d)
-      list = Feature::AndExpr.new(or1, or2).expander.to_a
-      list.size.should == 4
-      list.should.include Feature::AndExpr.new(a, c)
-      list.should.include Feature::AndExpr.new(a, d)
-      list.should.include Feature::AndExpr.new(b, c)
-      list.should.include Feature::AndExpr.new(b, d)
-    end
-
-    it 'should clone with the set' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      expr = Feature::AndExpr.new(a, b)
-      expr.clone.should == expr
-      expr.clone.__id__.should.not == expr.__id__
-    end
-  end
-
-  describe 'Feature::OrExpr' do
-    it 'should add elements' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      c = Feature::PossibleExpr.new("C")
-      d = Feature::PossibleExpr.new("D")
-      expr = Feature::OrExpr.new(a, b)
-      Feature::OrExpr.new(expr, c, d).should ==
-        Feature::OrExpr.new(a, b, c, d)
-    end
-
-    it 'should unify redundant elements' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      expr = Feature::OrExpr.new(a, b)
-      Feature::OrExpr.new(expr, a, b).should == expr
-      Feature::OrExpr.new(expr, expr).should == expr
-    end
-
-    it 'should foreground preferred feature over requisite feature' do
-      requisite = Feature::RequisiteExpr.new("A")
-      preferred = Feature::PreferredExpr.new("A")
-      Feature::OrExpr.new(requisite, preferred).simplify.should ==
-        preferred
-      Feature::OrExpr.new(preferred, requisite).simplify.should ==
-        preferred
-    end
-
-    it 'should foreground preferred feature over blocking feature' do
-      blocking = Feature::BlockingExpr.new("A")
-      preferred = Feature::PreferredExpr.new("A")
-      Feature::OrExpr.new(blocking, preferred).simplify.should ==
-        preferred
-      Feature::OrExpr.new(preferred, blocking).simplify.should ==
-        preferred
-    end
-
-    it 'should unify by possible feature' do
-      possible = Feature::PossibleExpr.new("A")
-      restrictive = Feature::RestrictiveExpr.new("A")
-      Feature::OrExpr.new(possible, restrictive).simplify.should ==
-        possible
-      Feature::OrExpr.new(restrictive, possible).simplify.should ==
-        possible
-    end
-
-    it 'should neutralize' do
-      requisite = Feature::RequisiteExpr.new("A")
-      blocking = Feature::BlockingExpr.new("A")
-      Feature::OrExpr.new(requisite, blocking).simplify.should ==
-        Feature::EmptyFeature.new
-      Feature::OrExpr.new(blocking, requisite).simplify.should ==
-        Feature::EmptyFeature.new
-    end
-
-    it 'should expand' do
-      a = Feature::PossibleExpr.new("A")
-      b = Feature::PossibleExpr.new("B")
-      c = Feature::PossibleExpr.new("C")
-      d = Feature::PossibleExpr.new("D")
-      and1 = Feature::AndExpr.new(a, b)
-      and2 = Feature::AndExpr.new(c, d)
-      list = Feature::OrExpr.new(and1, and2).expander.to_a
-      list.size.should == 2
-      list.should.include Feature::AndExpr.new(a, b)
-      list.should.include Feature::AndExpr.new(c, d)
-    end
-
-    it 'should be empty' do
-      Feature::AndExpr.new(Feature::EmptyFeature.new).should.be.empty
-    end
-  end
-
-  #
-  # test cases
-  #
-  yamlname = 'spec_feature-expr_decide.yml'
-  ymlpath = File.join(File.dirname(__FILE__), yamlname)
-  testcases = YAML.load_file(ymlpath)
-
-  describe 'Feature::Sentence' do
-    it 'should get true' do
-      possible_a = Feature::PossibleExpr.new("A")
-      possible_b = Feature::PossibleExpr.new("B")
-      provider = Feature::OrExpr.new(possible_a, possible_b)
-      requisite_a = Feature::RequisiteExpr.new("A")
-      requisite_b = Feature::RequisiteExpr.new("B")
-      request = Feature::OrExpr.new(requisite_a, requisite_b)
-      Feature::Sentence.new(provider, request).decide.should.be.true
-    end
-
-    it 'should eliminate requisite feature' do
-      possible = Feature::PossibleExpr.new("A")
-      requisite = Feature::RequisiteExpr.new("A")
-      provider = Feature::AndExpr.new(possible)
-      request = Feature::AndExpr.new(requisite)
-      m = Feature::Sentence::EliminationMethod
-      result, p, r = m.eliminate_requisite_feature(provider, request)
-      result.should.be.true
-      p.should.empty
-      r.should.empty
-    end
-
-    it 'should eliminate blocking feature' do
-      possible = Feature::PossibleExpr.new("X")
-      requisite = Feature::RequisiteExpr.new("Y")
-      blocking = Feature::BlockingExpr.new("Z")
-      provider = Feature::AndExpr.new(possible)
-      request = Feature::AndExpr.new(requisite, blocking)
-      m = Feature::Sentence::EliminationMethod
-      result, p, r = m.eliminate_blocking_feature(provider, request)
-      result.should.be.true
-      p.should == Feature::AndExpr.new(possible)
-      r.should == Feature::AndExpr.new(requisite)
-    end
-
-    it 'should eliminate preferred feature' do
-      possible = Feature::PossibleExpr.new("X")
-      requisite = Feature::RequisiteExpr.new("Y")
-      preferred = Feature::PreferredExpr.new("Z")
-      provider = Feature::AndExpr.new(possible)
-      request = Feature::AndExpr.new(requisite, preferred)
-      m = Feature::Sentence::EliminationMethod
-      result, p, r = m.eliminate_preferred_feature(provider, request)
-      result.should.be.true
-      p.should == Feature::AndExpr.new(possible)
-      r.should == Feature::AndExpr.new(requisite)
-    end
-
-    it 'should eliminate or-clause including empty feature' do
-      possible1 = Feature::PossibleExpr.new("X")
-      possible2 = Feature::PossibleExpr.new("Y")
-      or_clause = Feature::OrExpr.new(Feature::EmptyFeature.new, possible1)
-      provider = Feature::AndExpr.new(or_clause, possible2)
-      request = Feature::AndExpr.new(Feature::EmptyFeature.new)
-      m = Feature::Sentence::EliminationMethod
-      result, p, r = m.eliminate_or_clause_including_empty_feature(provider, request)
-      result.should.be.true
-      p.should == Feature::AndExpr.new(possible2)
-      r.should.be.empty
-    end
-
-    it 'should eliminate possible feature' do
-      possible1 = Feature::PossibleExpr.new("X")
-      possible2 = Feature::PossibleExpr.new("Y")
-      requisite = Feature::RequisiteExpr.new("Y")
-      provider = Feature::AndExpr.new(possible1, possible2)
-      request = Feature::AndExpr.new(requisite)
-      m = Feature::Sentence::EliminationMethod
-      result, p, r = m.eliminate_possible_feature(provider, request)
-      result.should.be.true
-      p.should == Feature::AndExpr.new(possible2)
-      r.should == Feature::AndExpr.new(requisite)
-    end
-
-    testcases["unification"].each do |type_name, methods|
-      methods.each do |method_name, cases|
-        cases.each do |case_name, testcase|
-          it "should unify %s expression by %s(%s)" % [type_name, method_name, case_name] do
-            parser = DocumentParser.new.feature_expr
-            expr1 = Transformer.document(parser.parse(testcase["expr1"]))
-            expr2 = Transformer.document(parser.parse(testcase["expr2"]))
-            result = Transformer.document(parser.parse(testcase["result"]))
-            expr1.send(method_name, expr2).should.be.true
-          end
-        end
-      end
-    end
-
-    # sentence test cases
-    testcases["sentence"].each do |testname, testcase|
-      it "should get #{testcase["result"]}: #{testname}" do
-        parser = DocumentParser.new.feature_expr
-        provide = Transformer.document(parser.parse(testcase["provide"]))
-        request = Transformer.document(parser.parse(testcase["request"]))
-        Feature::Sentence.new(provide, request).decide.should == testcase["result"]
-      end
-    end
-  end
-
-  # test_pione_method("feature-expr")
-end

data/test/model/spec_feature-expr_decide.yml

@@ -1,28 +0,0 @@
-unification:
-  AND:
-    unify_redundant_feature:
-      case1:
-        expr1: "+X & +Y"
-        expr2: "+X"
-        result: "+X & +Y"
-      case2:
-        expr1: "+X & +Y"
-        expr2: "+Y"
-        result: "+X & +Y"
-sentence:
-  case1:
-    provide: "^X"
-    request: "+X"
-    result: true
-  case2:
-    provide: "^X"
-    request: "*"
-    result: true
-  case3:
-    provide: "^X"
-    request: "+Y"
-    result: false
-  case4:
-    provide: "^X"
-    request: "-X"
-    result: false

data/test/model/spec_float.rb

@@ -1,23 +0,0 @@
-require_relative '../test-util'
-
-describe 'Model::PioneFloat' do
-  before do
-    @one = PioneFloat.new(1.0)
-    @two = PioneFloat.new(2.0)
-  end
-
-  it 'should get a ruby object that has same value' do
-    @one.value.should == 1.0
-  end
-
-  it 'should equal' do
-    @one.should == PioneFloat.new(1.0)
-  end
-
-  it 'should not equal' do
-    @one.should.not == PioneFloat.new(2.0)
-    @one.should.not == PioneInteger.new(1)
-  end
-
-  test_pione_method("float")
-end