pione 0.1.4 → 0.2.0

data/test/model/spec_package-expr.rb

@@ -0,0 +1,19 @@
+require_relative '../test-util'
+
+describe 'Model::PackageExpr' do
+  before do
+    @package_expr = Model::PackageExpr.new('A')
+  end
+
+  it 'should equal' do
+    @package_expr.should == Model::PackageExpr.new('A')
+  end
+
+  it 'should not equal' do
+    @package_expr.should != Model::PackageExpr.new('B')
+  end
+
+  it 'should get a package name' do
+    @package_expr.name.should == 'A'
+  end
+end

data/test/model/spec_parameters.rb

@@ -1,72 +1,62 @@
 require_relative '../test-util'
 
-describe 'Model::Parameters' do
+describe 'Pione::Model::Parameters' do
   before do
-    @params_a = Parameters.new({
-        Variable.new("a") => PioneString.new("A"),
-        Variable.new("b") => PioneString.new("B"),
-        Variable.new("c") => PioneString.new("C")
-      })
+    @a = PioneString.new("a")
+    @b = PioneString.new("b")
+    @c = PioneString.new("c")
+    @d = PioneString.new("d")
+    @i1 = PioneInteger.new(1)
+    @i2 = PioneInteger.new(2)
+    @i3 = PioneInteger.new(3)
+    @true = PioneBoolean.new(true)
+    @false = PioneBoolean.new(false)
+    @var_x = Variable.new("X")
+    @var_y = Variable.new("Y")
+    @var_z = Variable.new("Z")
+    @var_a = Variable.new("A")
+    @params = Parameters.new({@var_x => @a, @var_y => @b, @var_z => @c})
   end
 
   it 'should be equal' do
-    @params_a.should == Parameters.new({
-        Variable.new("a") => PioneString.new("A"),
-        Variable.new("b") => PioneString.new("B"),
-        Variable.new("c") => PioneString.new("C")
-      })
-    set = Set.new
-    set.add(@params_a)
-    set.add(Parameters.new({
-          Variable.new("a") => PioneString.new("A"),
-          Variable.new("b") => PioneString.new("B"),
-          Variable.new("c") => PioneString.new("C")
-        }))
-    set.size.should == 1
+    @params.should == Parameters.new({@var_x => @a, @var_y => @b, @var_z => @c})
   end
 
   it 'should be not equal' do
-    @params_a.should.not ==
-      Parameters.new({
-        Variable.new("a") => PioneString.new("X"),
-        Variable.new("b") => PioneString.new("Y"),
-        Variable.new("c") => PioneString.new("Z")
-      })
+    @params.should != Parameters.new({@var_z => @a, @var_y => @b, @var_x => @c})
   end
 
-  it 'should get value' do
-    params = @params_a
-    params.get(Variable.new("a")).should == "A".to_pione
-    params.get(Variable.new("b")).should == "B".to_pione
-    params.get(Variable.new("c")).should == "C".to_pione
+  it 'should get the value' do
+    @params.tap do |x|
+      x.get(@var_x).should == @a
+      x.get(@var_y).should == @b
+      x.get(@var_z).should == @c
+    end
   end
 
   it 'should set a parameter' do
-    params = @params_a
-    new_params = params.set(Variable.new("d"), "D".to_pione)
-    new_params.get(Variable.new("a")).should == "A".to_pione
-    new_params.get(Variable.new("b")).should == "B".to_pione
-    new_params.get(Variable.new("c")).should == "C".to_pione
-    new_params.get(Variable.new("d")).should == "D".to_pione
-    params.get(Variable.new("d")).should.nil
+    new_params = @params.set(@var_a, @d)
+    new_params.get(@var_x).should == @a
+    new_params.get(@var_y).should == @b
+    new_params.get(@var_z).should == @c
+    new_params.get(@var_a).should == @d
+    @params.get(@var_a).should.nil
   end
 
   it 'should overwrite a parameter' do
-    params = @params_a
-    new_params = params.set(Variable.new("a"), "Z".to_pione)
-    new_params.get(Variable.new("a")).should == "Z".to_pione
-    new_params.get(Variable.new("b")).should == "B".to_pione
-    new_params.get(Variable.new("c")).should == "C".to_pione
-    params.get(Variable.new("a")).should == "A".to_pione
+    new_params = @params.set(@var_x, @d)
+    new_params.get(@var_x).should == @d
+    new_params.get(@var_y).should == @b
+    new_params.get(@var_z).should == @c
+    @params.get(@var_x).should == @a
   end
 
   it 'should delete a parameter' do
-    params = @params_a
-    new_params = params.delete(Variable.new("a"))
-    new_params.get(Variable.new("a")).should.nil
-    new_params.get(Variable.new("b")).should == "B".to_pione
-    new_params.get(Variable.new("c")).should == "C".to_pione
-    params.get(Variable.new("a")).should == "A".to_pione
+    new_params = @params.delete(@var_x)
+    new_params.get(@var_x).should.nil
+    new_params.get(@var_y).should == @b
+    new_params.get(@var_z).should == @c
+    @params.get(@var_x).should == @a
   end
 
   it 'should be empty' do
@@ -74,62 +64,40 @@ describe 'Model::Parameters' do
   end
 
   it 'should not be emtpy' do
-    @params_a.should.not.be.empty
+    @params.should.not.be.empty
   end
 
   it 'should expand sequence with each modifier' do
-    seq_a = StringSequence.new([PioneString.new("X"), PioneString.new("Y"), PioneString.new("Z")]).set_each
-    seq_b = IntegerSequence.new([PioneInteger.new(1), PioneInteger.new(2), PioneInteger.new(3)]).set_each
-    seq_c = BooleanSequence.new([PioneBoolean.new(true), PioneBoolean.new(false)]).set_each
-    params = Parameters.new(Variable.new("A") => seq_a, Variable.new("B") => seq_b, Variable.new("C") => seq_c)
+    seq_a = StringSequence.new([@a, @b, @c]).set_each
+    seq_b = IntegerSequence.new([@i1, @i2, @i3]).set_each
+    seq_c = BooleanSequence.new([@true, @false]).set_each
+    params = Parameters.new(@var_x => seq_a, @var_y => seq_b, @var_z => seq_c)
     params.to_a.tap do |list|
       list.size.should == 18
       comb = [
-        [PioneString.new("X"), PioneInteger.new(1), PioneBoolean.new(true)],
-        [PioneString.new("X"), PioneInteger.new(2), PioneBoolean.new(true)],
-        [PioneString.new("X"), PioneInteger.new(3), PioneBoolean.new(true)],
-        [PioneString.new("X"), PioneInteger.new(1), PioneBoolean.new(false)],
-        [PioneString.new("X"), PioneInteger.new(2), PioneBoolean.new(false)],
-        [PioneString.new("X"), PioneInteger.new(3), PioneBoolean.new(false)],
-        [PioneString.new("Y"), PioneInteger.new(1), PioneBoolean.new(true)],
-        [PioneString.new("Y"), PioneInteger.new(2), PioneBoolean.new(true)],
-        [PioneString.new("Y"), PioneInteger.new(3), PioneBoolean.new(true)],
-        [PioneString.new("Y"), PioneInteger.new(1), PioneBoolean.new(false)],
-        [PioneString.new("Y"), PioneInteger.new(2), PioneBoolean.new(false)],
-        [PioneString.new("Y"), PioneInteger.new(3), PioneBoolean.new(false)],
-        [PioneString.new("Z"), PioneInteger.new(1), PioneBoolean.new(true)],
-        [PioneString.new("Z"), PioneInteger.new(2), PioneBoolean.new(true)],
-        [PioneString.new("Z"), PioneInteger.new(3), PioneBoolean.new(true)],
-        [PioneString.new("Z"), PioneInteger.new(1), PioneBoolean.new(false)],
-        [PioneString.new("Z"), PioneInteger.new(2), PioneBoolean.new(false)],
-        [PioneString.new("Z"), PioneInteger.new(3), PioneBoolean.new(false)]
+        [@a, @i1, @true], [@a, @i2, @true], [@a, @i3, @true],
+        [@a, @i1, @false], [@a, @i2, @false], [@a, @i3, @false],
+        [@b, @i1, @true], [@b, @i2, @true], [@b, @i3, @true],
+        [@b, @i1, @false], [@b, @i2, @false], [@b, @i3, @false],
+        [@c, @i1, @true], [@c, @i2, @true], [@c, @i3, @true],
+        [@c, @i1, @false], [@c, @i2, @false], [@c, @i3, @false]
       ]
       comb.each do |elts|
         list.should.include(
-          Parameters.new(
-            Variable.new("A") => elts[0].to_seq,
-            Variable.new("B") => elts[1].to_seq,
-            Variable.new("C") => elts[2].to_seq
-          )
+          Parameters.new(@var_x => elts[0].to_seq, @var_y => elts[1].to_seq, @var_z => elts[2].to_seq)
         )
       end
     end
   end
 
   it 'should expand sequences with all modifier' do
-    seq_a = StringSequence.new([PioneString.new("X"), PioneString.new("Y"), PioneString.new("Z")]).set_all
-    seq_b = IntegerSequence.new([PioneInteger.new(1), PioneInteger.new(2), PioneInteger.new(3)]).set_all
-    seq_c = BooleanSequence.new([PioneBoolean.new(true), PioneBoolean.new(false)]).set_all
-    params = Parameters.new(Variable.new("A") => seq_a, Variable.new("B") => seq_b, Variable.new("C") => seq_c)
+    seq_a = StringSequence.new([@a, @b, @c]).set_all
+    seq_b = IntegerSequence.new([@i1, @i2, @i3]).set_all
+    seq_c = BooleanSequence.new([@true, @false]).set_all
+    params = Parameters.new(@var_x => seq_a, @var_y => seq_b, @var_z => seq_c)
     params.to_a.tap do |list|
       list.size.should == 1
-      list.should.include(
-        Parameters.new(
-          Variable.new("A") => seq_a,
-          Variable.new("B") => seq_b,
-          Variable.new("C") => seq_c
-        )
-      )
+      list.should.include(Parameters.new(@var_x => seq_a, @var_y => seq_b, @var_z => seq_c))
     end
   end
 end

data/test/model/spec_pione-method.rb

@@ -6,10 +6,11 @@ describe "Pione::Model::PioneMethod" do
     @int_2 = PioneInteger.new(2).to_seq
     @int_3 = PioneInteger.new(3).to_seq
     @str_1 = PioneString.new(1).to_seq
-    @method_1 = Model::PioneMethod.new([TypeInteger], TypeInteger, lambda{|rec, arg1| arg1})
-    @method_2 = Model::PioneMethod.new([TypeInteger, TypeString], TypeInteger, lambda{|rec, arg1, arg2| arg1})
-    @method_3 = Model::PioneMethod.new([], :receiver_type, lambda{|rec| rec})
-    @method_bad = Model::PioneMethod.new([TypeString], TypeInteger, lambda{|rec, arg1| arg1})
+    @method_1 = Model::PioneMethod.new("m1", [TypeInteger], TypeInteger, lambda{|vtable, rec, arg1| arg1})
+    @method_2 = Model::PioneMethod.new("m2", [TypeInteger, TypeString], TypeInteger, lambda{|vtable, rec, arg1, arg2| arg1})
+    @method_3 = Model::PioneMethod.new("m3", [], :receiver_type, lambda{|vtable, rec| rec})
+    @method_bad = Model::PioneMethod.new("mbad", [TypeString], TypeInteger, lambda{|vtable, rec, arg1| arg1})
+    @vtable = Model::VariableTable.empty
   end
 
   it "should get inputs" do
@@ -27,10 +28,10 @@ describe "Pione::Model::PioneMethod" do
   end
 
   it "should be callable" do
-    @method_1.call(@int_1, @int_2).should == @int_2
-    @method_2.call(@int_1, @int_2, @str_1).should == @int_2
-    @method_3.call(@int_1).should == @int_1
-    @method_3.call(@str_1).should == @str_1
+    @method_1.call(@vtable, @int_1, @int_2).should == @int_2
+    @method_2.call(@vtable, @int_1, @int_2, @str_1).should == @int_2
+    @method_3.call(@vtable, @int_1).should == @int_1
+    @method_3.call(@vtable, @str_1).should == @str_1
   end
 
   it "should validate inputs" do
@@ -43,14 +44,14 @@ describe "Pione::Model::PioneMethod" do
   end
 
   it "should call" do
-    @method_1.call(@int_1, @int_2).should == @int_2
-    @method_2.call(@int_1, @int_2, @str_1).should == @int_2
-    @method_3.call(@int_1).should == @int_1
+    @method_1.call(@vtable, @int_1, @int_2).should == @int_2
+    @method_2.call(@vtable, @int_1, @int_2, @str_1).should == @int_2
+    @method_3.call(@vtable, @int_1).should == @int_1
   end
 
   it "should raise interface error" do
-    should.raise(MethodInterfaceError){ @method_1.call(@int_1, @str_1) }
-    should.raise(MethodInterfaceError){ @method_2.call(@int_1, @str_1, @str_1) }
-    should.raise(MethodInterfaceError){ @method_bad.call(@int_1, @str_1) }
+    should.raise(MethodInterfaceError){ @method_1.call(@vtable, @int_1, @str_1) }
+    should.raise(MethodInterfaceError){ @method_2.call(@vtable, @int_1, @str_1, @str_1) }
+    should.raise(MethodInterfaceError){ @method_bad.call(@vtable, @int_1, @str_1) }
   end
 end

data/test/model/spec_rule-expr.rb

@@ -2,12 +2,12 @@ require_relative '../test-util'
 
 describe 'Model::RuleExpr' do
   before do
-    @a = RuleExpr.new(Package.new("main"), "a")
-    @b = RuleExpr.new(Package.new("main"), "b")
+    @a = RuleExpr.new(PackageExpr.new("main"), "a")
+    @b = RuleExpr.new(PackageExpr.new("main"), "b")
   end
 
   it 'should be equal' do
-    @a.should == RuleExpr.new(Package.new("main"), "a")
+    @a.should == RuleExpr.new(PackageExpr.new("main"), "a")
   end
 
   it 'should be not equal' do
@@ -24,53 +24,5 @@ describe 'Model::RuleExpr' do
     @a.add_output_ticket_expr(ticket).output_ticket_expr.should == ticket
   end
 
-  describe 'pione method ==' do
-    it 'should true' do
-      @a.call_pione_method(
-        "==", RuleExpr.new(Package.new("main"), "a")
-      ).should == PioneBoolean.new(true).to_seq
-    end
-
-    it 'should false' do
-      @a.call_pione_method("==", @b).should.not.true
-    end
-
-    it 'should raise type error' do
-      should.raise(MethodNotFound) do
-        @a.call_pione_method("==", PioneInteger.new(1).to_seq)
-      end
-    end
-  end
-
-  describe 'pione method !=' do
-    it 'should true' do
-      @a.call_pione_method("!=", @b).should == PioneBoolean.new(true).to_seq
-    end
-
-    it 'should false' do
-      @a.call_pione_method(
-        "!=", RuleExpr.new(Package.new("main"), "a")
-      ).should.not.true
-    end
-
-    it 'should raise type error' do
-      should.raise(MethodNotFound) do
-        @a.call_pione_method("!=", PioneInteger.new(1).to_seq)
-      end
-    end
-  end
-
-  describe 'pione method as_string' do
-    it 'should get string' do
-      @a.call_pione_method("as_string").should == PioneString.new("a").to_seq
-    end
-  end
-
-  describe 'pione method params' do
-    it 'should set parameters' do
-      params = Parameters.new({Variable.new("a") => PioneBoolean.true})
-      @a.call_pione_method("params", params).should ==
-        RuleExpr.new(Package.new("main"), "a", params: params)
-    end
-  end
+  test_pione_method("rule-expr")
 end

data/test/model/spec_rule-expr.yml

@@ -0,0 +1,11 @@
+# ==
+- "true" : "&Test:Main == &Test:Main"
+- "false" : "&Test:Main == &Test:Count"
+
+# !=
+- "true" : "&Test:Main != &Test:Count"
+- "false" : "&Test:Main != &Test:Main"
+
+# params
+- "Main {N: 1}" : "Main.params({N: 1})"
+

data/test/model/spec_sequence.yml

@@ -54,6 +54,12 @@
 - 'true | true | true' : '(1 | 2 | 3).member?(1 | 2 | 3)'
 - 'true | false' : '(1 | 2).member?(1 | 3)'
 
+# empty?
+# literal for empty sequences don't not exist now
+- 'false' : '(1 | 2 | 3).empty?'
+- 'false' : '(1 | 2).empty?'
+- 'false' : '1.empty?'
+
 # reverse
 - '3 | 2 | 1' : '(1 | 2 | 3).reverse'
 - '1' : '1.reverse'

data/test/model/spec_string.rb

@@ -1,13 +1,17 @@
 require_relative '../test-util'
 
-describe 'Model::PioneString' do
+describe 'Pione::Model::PioneString' do
   before do
     @a = PioneString.new("a")
     @b = PioneString.new("b")
+    @vtable = VariableTable.new({
+        Variable.new("var1") => @a.to_seq,
+        Variable.new("var2") => @b.to_seq
+      })
   end
 
-  it 'should get a ruby object that has same value' do
-    @a.to_ruby.should == "a"
+  it 'should the value' do
+    @a.value.should == "a"
   end
 
   it 'should equal' do
@@ -15,23 +19,27 @@ describe 'Model::PioneString' do
   end
 
   it 'should not equal' do
-    @a.should.not == @b
+    @a.should != @b
+  end
+
+  it 'should include variables' do
+    PioneString.new("{$var1}").should.include_variable
+    PioneString.new("<? $var1 ?>").should.include_variable
+  end
+
+  it 'should not include variables' do
+    PioneString.new("$var1").should.not.include_variable
+    PioneString.new("<? 1 ?>").should.not.include_variable
   end
 
   it 'should expand variables' do
-    vtable = VariableTable.new({
-        Variable.new("var1") => PioneString.new("a").to_seq,
-        Variable.new("var2") => PioneString.new("b").to_seq
-      })
-    PioneString.new("{$var1}:{$var2}").eval(vtable).should ==
-      PioneString.new("a:b")
+    PioneString.new("{$var1}:{$var2}").eval(@vtable).should == PioneString.new("a:b")
   end
 
   it 'should expand an expression' do
-    vtable = VariableTable.new
-    PioneString.new("1 + 1 = <?1 + 1?>").eval(vtable).should ==
+    PioneString.new("1 + 1 = <?1 + 1?>").eval(@vtable).should ==
       PioneString.new("1 + 1 = 2")
-    PioneString.new("1 + 2 = <? 1 + 2 ?>").eval(vtable).should ==
+    PioneString.new("1 + 2 = <? 1 + 2 ?>").eval(@vtable).should ==
       PioneString.new("1 + 2 = 3")
   end
 

data/test/model/spec_string.yml

@@ -61,8 +61,16 @@
 - '"a" | "ab" | "abc" | "b" | "bc" | "bc" | "c" | "c" | "c"' : '"abc".substring(1 | 2 | 3, 1 | 2 | 3)'
 
 # []
-- true: '"abc"[0] == "abc"'
-- true: '("a" | "b" | "c")[0] == "abc"'
+- '"abc"' : '"abc".nth(1)'
+- '"a"' : '("a" | "b" | "c").nth(1)'
+- '"b"' : '("a" | "b" | "c").nth(2)'
+- '"c"' : '("a" | "b" | "c").nth(3)'
+
+# []
+- '"abc"' : '"abc"[1]'
+- '"a"' : '("a" | "b" | "c")[1]'
+- '"b"' : '("a" | "b" | "c")[2]'
+- '"c"' : '("a" | "b" | "c")[3]'
 
 # as_integer, i
 - "1" : '"1".as_integer'

data/test/model/spec_ticket-expr.rb

@@ -1,7 +1,7 @@
 require_relative '../test-util'
 
 describe 'Model::TicketExpr' do
-  it 'should equal between same name ticket expressions' do
+  it 'should equal' do
     TicketExpr.new("T").should == TicketExpr.new("T")
   end
 
@@ -9,9 +9,31 @@ describe 'Model::TicketExpr' do
     TicketExpr.new("T").should.not == TicketExpr.new("t")
   end
 
-  it 'should get names' do
+  it 'should get name' do
     TicketExpr.new("T").name.should == "T"
   end
+end
+
+describe "Pione::Model::TicketExprSequence" do
+  before do
+    @x = TicketExpr.new("X")
+    @y = TicketExpr.new("Y")
+    @seq = TicketExprSequence.new([@x, @y])
+  end
+
+  it "should equal" do
+    @seq.should == TicketExprSequence.new([@x, @y])
+  end
+
+  it "should not equal" do
+    @seq.should != TicketExprSequence.new([@y, @x])
+  end
+
+  it "should get ticket names" do
+    @seq.names.should.include("X")
+    @seq.names.should.include("Y")
+    @seq.names.should.not.include("Z")
+  end
 
-  test_pione_method("ticket-expr")
+  test_pione_method "ticket-expr"
 end