pione 0.1.3 → 0.1.4

data/test/model/spec_float.rb

@@ -19,123 +19,5 @@ describe 'Model::PioneFloat' do
     @one.should.not == PioneInteger.new(1)
   end
 
-  describe 'pione method ==' do
-    it 'should true' do
-      @one.call_pione_method("==", PioneFloat.new(1.0)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("==", @two).should.not.true
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("==", PioneInteger.new(1))
-      end
-    end
-  end
-
-  describe 'pione method !=' do
-    it 'should true' do
-      @one.call_pione_method("!=", @two).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("!=", PioneFloat.new(1.0)).should.not.true
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("!=", PioneInteger.new(1))
-      end
-    end
-  end
-
-  describe 'pione method >' do
-    it 'should true' do
-      @one.call_pione_method(">", PioneFloat.new(0.0)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method(">", PioneFloat.new(1.0)).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method(">", PioneInteger.new(1))
-      end
-    end
-  end
-
-  describe 'pione method >=' do
-    it 'should true' do
-      @one.call_pione_method(">=", PioneFloat.new(1.0)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method(">=", @two).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method(">=", PioneInteger.new(1))
-      end
-    end
-  end
-
-  describe 'pione method <' do
-    it 'should true' do
-      @one.call_pione_method("<", @two).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("<", PioneFloat.new(1.0)).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("<", PioneInteger.new(1))
-      end
-    end
-  end
-
-  describe 'pione method <=' do
-    it 'should true' do
-      @one.call_pione_method("<=", PioneFloat.new(1.0)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("<=", PioneFloat.new(0.0)).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("<=", PioneInteger.new(1))
-      end
-    end
-  end
-
-  describe 'pione method +' do
-    it 'should sum' do
-      @one.call_pione_method("+", @one).should == @two
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("+", PioneInteger.new(1))
-      end
-    end
-  end
-
-  describe 'pione method -' do
-    it 'should get difference' do
-      @two.call_pione_method("-", @one).should == @one
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("-", PioneInteger.new(1))
-      end
-    end
-  end
+  test_pione_method("float")
 end

data/test/model/spec_float.yml

@@ -0,0 +1,17 @@
+# +
+- "1.1" : "1.0 + 0.1"
+
+# -
+- "0.9" : "1.0 - 0.1"
+
+# as_string, str
+- '"0.1"' : "0.1.as_string"
+- '"1.0"' : "1.0.str"
+
+# as_int, i
+- "1" : "1.0.as_integer"
+- "0" : "0.1.i"
+
+# as_float, f
+- "0.1" : "0.1.as_float"
+- "1.0" : "1.0.f"

data/test/model/spec_integer.rb

@@ -19,123 +19,5 @@ describe 'Model::PioneInteger' do
     @one.should.not == PioneFloat.new(1.0)
   end
 
-  describe 'pione method ==' do
-    it 'should true' do
-      @one.call_pione_method("==", PioneInteger.new(1)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("==", PioneInteger.new(2)).should.not.true
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("==", PioneFloat.new(1.0))
-      end
-    end
-  end
-
-  describe 'pione method !=' do
-    it 'should true' do
-      @one.call_pione_method("!=", PioneInteger.new(2)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("!=", PioneInteger.new(1)).should.not.true
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("!=", PioneFloat.new(1.0))
-      end
-    end
-  end
-
-  describe 'pione method >' do
-    it 'should true' do
-      @one.call_pione_method(">", PioneInteger.new(0)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method(">", PioneInteger.new(1)).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method(">", PioneFloat.new(1.0))
-      end
-    end
-  end
-
-  describe 'pione method >=' do
-    it 'should true' do
-      @one.call_pione_method(">=", PioneInteger.new(1)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method(">=", PioneInteger.new(2)).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method(">=", PioneFloat.new(1.0))
-      end
-    end
-  end
-
-  describe 'pione method <' do
-    it 'should true' do
-      @one.call_pione_method("<", PioneInteger.new(2)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("<", PioneInteger.new(1)).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("<", PioneFloat.new(1.0))
-      end
-    end
-  end
-
-  describe 'pione method <=' do
-    it 'should true' do
-      @one.call_pione_method("<=", PioneInteger.new(1)).should.true
-    end
-
-    it 'should false' do
-      @one.call_pione_method("<=", PioneInteger.new(0)).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("<=", PioneFloat.new(1.0))
-      end
-    end
-  end
-
-  describe 'pione method +' do
-    it 'should sum' do
-      @one.call_pione_method("+", @one).should == @two
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("+", PioneFloat.new(1.0))
-      end
-    end
-  end
-
-  describe 'pione method -' do
-    it 'should get difference' do
-      @two.call_pione_method("-", @one).should == @one
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @one.call_pione_method("-", PioneFloat.new(1.0))
-      end
-    end
-  end
+  test_pione_method("integer")
 end

data/test/model/spec_integer.yml

@@ -0,0 +1,57 @@
+# ==, !=
+- true  : '1 == 1'
+- false : '1 == 2'
+- true  : '1 != 2'
+- false : '1 != 1'
+
+# length
+- "3" : '(1 | 2 | 3).length'
+
+# []
+- "1" : '(1 | 2 | 3)[1]'
+- "2" : '(1 | 2 | 3)[2]'
+- "3" : '(1 | 2 | 3)[3]'
+
+# as_string, str
+- '"1" | "2" | "3"' : '(1 | 2 | 3).str'
+
+# +
+- "6" : '1 + 2 + 3'
+- "2 | 3 | 4" : '1 + (1 | 2 | 3)'
+- "2 | 3 | 4" : '(1 | 2 | 3) + 1'
+- "2 | 3 | 4| 3 | 4 | 5 | 4 | 5 | 6" : '(1 | 2 | 3) + (1 | 2 | 3)'
+
+# -
+- "-4" : '1 - 2 - 3'
+- "0 | -1 | -2" : '1 - (1 | 2 | 3)'
+- "0 | 1 | 2" : '(1 | 2 | 3) - 1'
+- "0 | -1 | -2 | 1 | 0 | -1 | 2 | 1 | 0" : '(1 | 2 | 3) - (1 | 2 | 3)'
+
+# *
+- "6" : '1 * 2 * 3'
+- "3 | 6 | 9" : '3 * (1 | 2 | 3)'
+- "3 | 6 | 9" : '(1 | 2 | 3) * 3'
+- "1 | 2 | 3 | 2 | 4 | 6 | 3 | 6 | 9" : '(1 | 2 | 3) * (1 | 2 | 3)'
+
+# /
+- true : '4 / 2 == 2'
+- true : '4 / (4 | 2) == (1 | 2)'
+- true : '(4 | 2) / 2 == (2 | 1)'
+- true : '(4 | 2) / (4 | 2) == (1 | 2 | 0 | 1)'
+
+# upto
+- '1 | 2 | 3' : '1.upto(3)'
+- '1' : '1.upto(1)'
+- '1' : '1.upto(0)'
+- '1 | 2 | 3 | 2 | 3 | 3' : '(1 | 2 | 3).upto(3)'
+- '1 | 1 | 2 | 1 | 2 | 3' : '1.upto(1 | 2 | 3)'
+- '1 | 1 | 2 | 1 | 2 | 3 | 2 | 2 | 2 | 3 | 3 | 3 | 3' : '(1 | 2 | 3).upto(1 | 2 | 3)'
+
+# downto
+- '3 | 2 | 1' : '3.downto(1)'
+- '3' : '3.downto(3)'
+- '3' : '3.downto(4)'
+- '3 | 2 | 1 | 2 | 1 | 1' : '(3 | 2 | 1).downto(1)'
+- '3 | 3 | 2 | 3 | 2 | 1' : '3.downto(3 | 2 | 1)'
+- '3 | 3 | 2 | 3 | 2 | 1 | 2 | 2 | 2 | 1 | 1 | 1 | 1' : '(3 | 2 | 1).downto(3 | 2 | 1)'
+

data/test/model/spec_keyed-sequence.rb

@@ -0,0 +1,5 @@
+require_relative '../test-util'
+
+describe 'Model::Sequence' do
+  test_pione_method("keyed-sequence")
+end

data/test/model/spec_keyed-sequence.yml

@@ -0,0 +1,22 @@
+# :
+- '(1 : "a") | (2 : "b") | (3 : "c")' : '(1 : "a") | (2 : "b") | (3 : "c")'
+- '("a" : 1) | ("b" : 2) | ("c" : 3)' : '("a" : 1) | ("b" : 2) | ("c" : 3)'
+- '(1 : "a") | (2 : "a") | (3 : "a")' : '(1 | 2 | 3) : "a"'
+
+# []
+- '"a"' : '((1 : "a") | (2 : "b") | (3 : "c"))[1]'
+- '"b"' : '((1 : "a") | (2 : "b") | (3 : "c"))[2]'
+- '"c"' : '((1 : "a") | (2 : "b") | (3 : "c"))[3]'
+- '"a" | "b"' : '((1 : ("a" | "b")) | (2 : ("c" | "d")) | (3 : ("e" | "f")))[1]'
+- '"c" | "d"' : '((1 : ("a" | "b")) | (2 : ("c" | "d")) | (3 : ("e" | "f")))[2]'
+- '"e" | "f"' : '((1 : ("a" | "b")) | (2 : ("c" | "d")) | (3 : ("e" | "f")))[3]'
+- '1' : '(("a" : 1) | ("b" : 2) | ("c" : 3))["a"]'
+- '2' : '(("a" : 1) | ("b" : 2) | ("c" : 3))["b"]'
+- '3' : '(("a" : 1) | ("b" : 2) | ("c" : 3))["c"]'
+
+# keys
+- '1 | 2 | 3' : '((1 : "a") | (2 : "b") | (3 : "c")).keys'
+
+# values
+- '"a" | "b" | "c"' : '((1 : "a") | (2 : "b") | (3 : "c")).values'
+

data/test/model/spec_message.rb

@@ -2,13 +2,13 @@ require_relative '../test-util'
 
 describe 'Model::Message' do
   before do
-    @a = Model::Message.new("next", 1)
-    @b = Model::Message.new("substring", "abcdefg", 2, 3)
+    @a = Model::Message.new("next", PioneInteger.new(1).to_seq)
+    @b = Model::Message.new("substring", PioneString.new("abcdefg").to_seq, PioneInteger.new(2).to_seq, PioneInteger.new(3).to_seq)
   end
 
   it 'should equal' do
-    @a.should == Model::Message.new("next", 1)
-    @b.should == Model::Message.new("substring", "abcdefg", 2, 3)
+    @a.should == Model::Message.new("next", PioneInteger.new(1).to_seq)
+    @b.should == Model::Message.new("substring", PioneString.new("abcdefg").to_seq, PioneInteger.new(2).to_seq, PioneInteger.new(3).to_seq)
   end
 
   it 'should not equal' do
@@ -16,14 +16,14 @@ describe 'Model::Message' do
   end
 
   it 'should send message' do
-    @a.eval(VariableTable.new).should == 2.to_pione
-    @b.eval(VariableTable.new).should == "cde".to_pione
+    @a.eval(VariableTable.new).should == PioneInteger.new(2).to_seq
+    @b.eval(VariableTable.new).should == PioneString.new("bcd").to_seq
   end
 
   it 'should get the method result from variable table' do
     vtable = VariableTable.new
     vtable.set(Variable.new("X"), @a)
-    vtable.get(Variable.new("X")).should == 2.to_pione
+    vtable.get(Variable.new("X")).should == PioneInteger.new(2).to_seq
     vtable.to_hash[Variable.new("X")].should == @a
   end
 

data/test/model/spec_parameters.rb

@@ -77,72 +77,59 @@ describe 'Model::Parameters' do
     @params_a.should.not.be.empty
   end
 
-  describe 'pione method ==' do
-    it 'should get true' do
-      params_a = @params_a
-      params_b = Parameters.new({
-          Variable.new("a") => "A".to_pione,
-          Variable.new("b") => "B".to_pione,
-          Variable.new("c") => "C".to_pione
-        })
-      params_a.call_pione_method("==", params_b).should ==
-        PioneBoolean.true
-    end
-
-    it 'should get false' do
-      params_a = {"a" => "A", "b" => "B", "c" => "C"}.to_params
-      params_b = {"a" => "X", "b" => "Y", "c" => "Z"}.to_params
-      params_a.call_pione_method("==", params_b).should ==
-        PioneBoolean.false
-    end
-  end
-
-  describe 'pione method !=' do
-    it 'should get true' do
-      params_a = {"a" => "A", "b" => "B", "c" => "C"}.to_params
-      params_b = {"a" => "X", "b" => "Y", "c" => "Z"}.to_params
-      params_a.call_pione_method("!=", params_b).should ==
-        PioneBoolean.true
-    end
-
-    it 'should get false' do
-      params_a = {"a" => "A", "b" => "B", "c" => "C"}.to_params
-      params_b = {"a" => "A", "b" => "B", "c" => "C"}.to_params
-      params_a.call_pione_method("!=", params_b).should ==
-        PioneBoolean.false
-    end
-  end
-
-  describe 'pione method []' do
-    it 'should get a value' do
-      @params_a.call_pione_method("[]", "a".to_pione).should ==
-        "A".to_pione
-    end
-  end
-
-  describe 'pione method get' do
-    it 'should get a value' do
-      @params_a.call_pione_method("get", "a".to_pione).should ==
-        "A".to_pione
-    end
-  end
-
-  describe 'pione method set' do
-    it 'should add a parameter' do
-      new_params = @params_a.call_pione_method("set", "d".to_pione, "D".to_pione)
-      new_params.get(Variable.new("d")).should == "D".to_pione
-    end
-
-    it 'should overwrite a parameter' do
-      new_params = @params_a.call_pione_method("set", "a".to_pione, "X".to_pione)
-      new_params.get(Variable.new("a")).should == "X".to_pione
+  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)
+    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)]
+      ]
+      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
+          )
+        )
+      end
     end
   end
 
-  describe 'pione method empty?' do
-    it 'should get true' do
-      Parameters.new({}).call_pione_method("empty?").should ==
-        PioneBoolean.true
+  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)
+    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
+        )
+      )
     end
   end
 end

data/test/model/spec_pione-method.rb

@@ -0,0 +1,56 @@
+require_relative '../test-util'
+
+describe "Pione::Model::PioneMethod" do
+  before do
+    @int_1 = PioneInteger.new(1).to_seq
+    @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})
+  end
+
+  it "should get inputs" do
+    @method_1.inputs.should == [TypeInteger]
+    @method_2.inputs.should == [TypeInteger, TypeString]
+    @method_3.inputs.should == []
+    @method_bad.inputs.should == [TypeString]
+  end
+
+  it "should get output" do
+    @method_1.output.should == TypeInteger
+    @method_2.output.should == TypeInteger
+    @method_3.output.should == :receiver_type
+    @method_bad.output.should == TypeInteger
+  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
+  end
+
+  it "should validate inputs" do
+    @method_1.validate_inputs(@int_1).should.be.false
+    @method_2.validate_inputs(@int_1).should.be.false
+    @method_2.validate_inputs(@int_1, @str_1).should.be.false
+    @method_2.validate_inputs(@int_1, @int_2).should.be.false
+    @method_2.validate_inputs(@int_1, @int_2, @int_3, @str_1).should.be.false
+    @method_3.validate_inputs(@int_1, @int_2).should.be.false
+  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
+  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) }
+  end
+end

data/test/model/spec_rule-expr.rb

@@ -14,11 +14,21 @@ describe 'Model::RuleExpr' do
     @a.should.not == @b
   end
 
+  it 'should set/get input ticket expression' do
+    ticket = TicketExpr.new("A").to_seq
+    @a.add_input_ticket_expr(ticket).input_ticket_expr.should == ticket
+  end
+
+  it 'should set/get output ticket expression' do
+    ticket = TicketExpr.new("A").to_seq
+    @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.true
+      ).should == PioneBoolean.new(true).to_seq
     end
 
     it 'should false' do
@@ -26,15 +36,15 @@ describe 'Model::RuleExpr' do
     end
 
     it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @a.call_pione_method("==", PioneInteger.new(1))
+      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.true
+      @a.call_pione_method("!=", @b).should == PioneBoolean.new(true).to_seq
     end
 
     it 'should false' do
@@ -44,15 +54,15 @@ describe 'Model::RuleExpr' do
     end
 
     it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @a.call_pione_method("!=", PioneInteger.new(1))
+      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")
+      @a.call_pione_method("as_string").should == PioneString.new("a").to_seq
     end
   end
 
@@ -60,7 +70,7 @@ describe 'Model::RuleExpr' 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)
+        RuleExpr.new(Package.new("main"), "a", params: params)
     end
   end
 end