pione 0.1.0

data/test/model/spec_integer.rb

@@ -0,0 +1,141 @@
+require_relative '../test-util'
+
+describe 'Model::PioneInteger' do
+  before do
+    @one = PioneInteger.new(1)
+    @two = PioneInteger.new(2)
+  end
+
+  it 'should get a ruby object that has same value' do
+    @one.to_ruby.should == 1
+  end
+
+  it 'should equal' do
+    @one.should == PioneInteger.new(1)
+  end
+
+  it 'should not equal' do
+    @one.should.not == PioneInteger.new(2)
+    @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
+end

data/test/model/spec_list.rb

@@ -0,0 +1,26 @@
+require_relative '../test-util'
+
+describe 'Model::List' do
+  it 'should be equal' do
+    x1 = PioneList.new
+    x2 = PioneList.new
+    x1.should.be.equal x2
+  end
+
+  it 'should be equal with elements' do
+    x1 = PioneList.new(PioneString.new("abc"), PioneString.new("def"))
+    x2 = PioneList.new(PioneString.new("abc"), PioneString.new("def"))
+    x1.should.be.equal x2
+  end
+
+  it 'should not be equal' do
+    x1 = PioneList.new(PioneString.new("abc"))
+    x2 = PioneList.new(PioneString.new("abc"), PioneString.new("def"))
+    x1.should.not.be.equal x2
+  end
+
+  it 'should have type [string]' do
+    list = PioneList.new(PioneString.new("abc"))
+    list.pione_model_type.should == TypeList.new(TypeString)
+  end
+end

data/test/model/spec_message.rb

@@ -0,0 +1,42 @@
+require_relative '../test-util'
+
+describe 'Model::Message' do
+  before do
+    @a = Model::Message.new("next", 1)
+    @b = Model::Message.new("substring", "abcdefg", 2, 3)
+  end
+
+  it 'should equal' do
+    @a.should == Model::Message.new("next", 1)
+    @b.should == Model::Message.new("substring", "abcdefg", 2, 3)
+  end
+
+  it 'should not equal' do
+    @a.should.not == @b
+  end
+
+  it 'should send message' do
+    @a.eval(VariableTable.new).should == 2.to_pione
+    @b.eval(VariableTable.new).should == "cde".to_pione
+  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.to_hash[Variable.new("X")].should == @a
+  end
+
+  it 'should not include variables' do
+    @a.should.not.include_variable
+  end
+
+  it 'should include variables' do
+    Message.new(
+      "next", Variable.new("N")
+    ).should.include_variable
+    Message.new(
+      "substring", "abcdef", Variable.new("FROM"), Variable.new("TO")
+    ).should.include_variable
+  end
+end

data/test/model/spec_package.rb

@@ -0,0 +1,15 @@
+require_relative '../test-util'
+
+describe 'Model::Package' do
+  it 'should be equal' do
+    Model::Package.new('abc').should == Model::Package.new('abc')
+  end
+
+  it 'should not be equal' do
+    Model::Package.new('abc').should.not == Model::Package.new('def')
+  end
+
+  it 'should get a package name' do
+    Model::Package.new('abc').name.should == 'abc'
+  end
+end

data/test/model/spec_parameters.rb

@@ -0,0 +1,148 @@
+require_relative '../test-util'
+
+describe '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")
+      })
+  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
+  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")
+      })
+  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
+  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
+  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
+  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
+  end
+
+  it 'should be empty' do
+    Parameters.new({}).should.be.empty
+  end
+
+  it 'should not be emtpy' 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
+    end
+  end
+
+  describe 'pione method empty?' do
+    it 'should get true' do
+      Parameters.new({}).call_pione_method("empty?").should ==
+        PioneBoolean.true
+    end
+  end
+end

data/test/model/spec_rule-expr.rb

@@ -0,0 +1,66 @@
+require_relative '../test-util'
+
+describe 'Model::RuleExpr' do
+  before do
+    @a = RuleExpr.new(Package.new("main"), "a")
+    @b = RuleExpr.new(Package.new("main"), "b")
+  end
+
+  it 'should be equal' do
+    @a.should == RuleExpr.new(Package.new("main"), "a")
+  end
+
+  it 'should be not equal' do
+    @a.should.not == @b
+  end
+
+  describe 'pione method ==' do
+    it 'should true' do
+      @a.call_pione_method(
+        "==", RuleExpr.new(Package.new("main"), "a")
+      ).should.true
+    end
+
+    it 'should false' do
+      @a.call_pione_method("==", @b).should.not.true
+    end
+
+    it 'should raise type error' do
+      should.raise(PioneModelTypeError) do
+        @a.call_pione_method("==", PioneInteger.new(1))
+      end
+    end
+  end
+
+  describe 'pione method !=' do
+    it 'should true' do
+      @a.call_pione_method("!=", @b).should.true
+    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(PioneModelTypeError) do
+        @a.call_pione_method("!=", PioneInteger.new(1))
+      end
+    end
+  end
+
+  describe 'pione method as_string' do
+    it 'should get string' do
+      @a.call_pione_method("as_string").should == PioneString.new("a")
+    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)
+    end
+  end
+end

data/test/model/spec_rule-io.rb

@@ -0,0 +1,32 @@
+require_relative '../test-util'
+
+describe 'Model::RuleIOElement' do
+  it 'should have name as a pione string' do
+    RuleIOElement.new("a.txt").name.should.kind_of?(PioneString)
+  end
+
+  it 'should have uri as a pione string' do
+    elt = RuleIOElement.new("a.txt")
+    elt.uri = "local:./test/a.txt"
+    elt.uri.should.kind_of?(PioneString)
+  end
+end
+
+describe 'Model::RuleIOList' do
+  it 'should add elements' do
+    list = RuleIOList.new
+    list.add(RuleIOElement.new("a.txt"))
+      .add(RuleIOElement.new("b.txt"))
+      .add(RuleIOElement.new("c.txt"))
+      .elements.size.should == 3
+    list.elements.size.should == 0
+  end
+
+  it 'should add elements destructively' do
+    list = RuleIOList.new
+    list.add! RuleIOElement.new("a.txt")
+    list.add! RuleIOElement.new("b.txt")
+    list.add! RuleIOElement.new("c.txt")
+    list.elements.size.should == 3
+  end
+end