pione 0.2.2 → 0.3.0

data/test/model/spec_string.rb

@@ -1,47 +0,0 @@
-require_relative '../test-util'
-
-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 the value' do
-    @a.value.should == "a"
-  end
-
-  it 'should equal' do
-    @a.should == PioneString.new("a")
-  end
-
-  it 'should not equal' do
-    @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
-    PioneString.new("{$var1}:{$var2}").eval(@vtable).should == PioneString.new("a:b")
-  end
-
-  it 'should expand an expression' do
-    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 = 3")
-  end
-
-  test_pione_method("string")
-end

data/test/model/spec_string.yml

@@ -1,91 +0,0 @@
-# ==, !=
-- true  : '"a" == "a"'
-- false : '"a" != "a"'
-- false : '"a" == "b"'
-- true  : '"a" != "b"'
-- true  : '"" == ""'
-- true  : '"" != "a"'
-- true  : '("a" | "b" | "c") == ("a" | "b" | "c")'
-- true  : '("a" | "b" | "c") != ("c" | "b" | "a")'
-- false : '("" | "") == ""'
-
-# +
-- true  : '("a" + "b") == "ab"'
-- true  : '("a" + "b" + "c") == "abc"'
-- false : '("a" + "b" + "c") == ("a" | "b" | "c")'
-- true  : '(("a" | "b" | "c") + "a") == ("aa" | "ba" | "ca")'
-- true  : '("a" + ("a" | "b" | "c")) == ("aa" | "ab" | "ac")'
-- true  : '(("a" | "b" | "c") + ("a" | "b" | "c")) == ("aa" | "ab" | "ac" | "ba" | "bb" | "bc" | "ca" | "cb" | "cc")'
-
-# include?
-- true  : '"abc".include?("")'
-- true  : '"abc".include?("a")'
-- true  : '"abc".include?("ab")'
-- true  : '"abc".include?("bc")'
-- true  : '"abc".include?("abc")'
-- false : '"abc".include?("abcd")'
-- 'true | true | true' : '("a" | "b" | "c").include?("")'
-- 'true | false | false' : '("a" | "b" | "c").include?("a")'
-- 'false | false | false' : '("a" | "b" | "c").include?("ab")'
-- 'false | false | false' : '("a" | "b" | "c").include?("abc")'
-- 'false | false | false' : '("a" | "b" | "c").include?("abcd")'
-- 'false | false | false' : '"".include?("a" | "b" | "c")'
-- 'true | false | false' : '"a".include?("a" | "b" | "c")'
-- 'true | true | false' : '"ab".include?("a" | "b" | "c")'
-- 'true | true | true' : '"abc".include?("a" | "b" | "c")'
-- 'true | true | true'  : '"abc".include?("c" | "b" | "a")'
-- 'true | false | false | false | true | false | false | false | true'  : '("a" | "b" | "c").include?("a" | "b" | "c")'
-
-# insert
-- '"Xabc"' : '"abc".insert(1, "X")'
-- '"aXbc"' : '"abc".insert(2, "X")'
-- '"abXc"' : '"abc".insert(3, "X")'
-- '"abcX"' : '"abc".insert(4, "X")'
-- '"Xabc" | "aXbc" | "abXc" | "abcX"' : '"abc".insert(1 | 2 | 3 | 4, "X")'
-
-# count
-- true: '"".count == 0'
-- true: '"a".count == 1'
-- true: '"ab".count == 2'
-- true: '"abc".count == 3'
-- true: '" ".count == 1'
-
-# substring
-- '""' : '"abc".substring(1,0)'
-- '"a"' : '"abc".substring(1,1)'
-- '"ab"' : '"abc".substring(1,2)'
-- '"abc"' : '"abc".substring(1,3)'
-- '"abc"' : '"abc".substring(1,4)'
-- '"a" | "b" | "c"' : '"abc".substring(1 | 2 | 3, 1)'
-- '"a" | "ab" | "abc"' : '"abc".substring(1, 1 | 2 | 3)'
-- '"a" | "ab" | "abc" | "b" | "bc" | "bc" | "c" | "c" | "c"' : '"abc".substring(1 | 2 | 3, 1 | 2 | 3)'
-
-# []
-- '"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'
-- "1" : '"1".i'
-- "10" : '"10".i'
-- "100" : '"100".i'
-- "1" : '"01".i'
-- "10" : '"010".i'
-- "100" : '"0100".i'
-- "-1" : '"-1".i'
-- "(1 | 2 | 3)" : '("1" | "2" | "3").i'
-
-# as_float, f
-- "1.0" : '"1.0".as_float'
-- "1.0" : '"1.0".f'
-- "0.1" : '"0.1".f'
-- "0.1e10" : '"0.1e10".f'
-- "(0.1 | 1.0 | 0.1e10)" : '("0.1" | "1.0" | "0.1e10").f'

data/test/model/spec_ticket-expr.rb

@@ -1,39 +0,0 @@
-require_relative '../test-util'
-
-describe 'Model::TicketExpr' do
-  it 'should equal' do
-    TicketExpr.new("T").should == TicketExpr.new("T")
-  end
-
-  it 'should not equal' do
-    TicketExpr.new("T").should.not == TicketExpr.new("t")
-  end
-
-  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"
-end

data/test/model/spec_variable-table.rb

@@ -1,116 +0,0 @@
-require_relative '../test-util'
-
-describe 'Model::VariableTable' do
-  before do
-    @table = VariableTable.new
-    @table.set(Variable.new('A'), PioneInteger.new(1).to_seq)
-    @table.set(Variable.new('B'), PioneInteger.new(2).to_seq)
-    @table.set(Variable.new('C'), PioneInteger.new(3).to_seq)
-  end
-
-  it 'should get an empty table' do
-    VariableTable.empty.should.empty
-  end
-
-  it 'should get a variable value' do
-    @table.get(Variable.new('A')).should == PioneInteger.new(1).to_seq
-    @table.get(Variable.new('B')).should == PioneInteger.new(2).to_seq
-    @table.get(Variable.new('C')).should == PioneInteger.new(3).to_seq
-  end
-
-  it 'should get nil if the variable is unknown in the table' do
-    @table.get(Variable.new('D')).should.nil
-  end
-
-  it 'should set a new variable' do
-    @table.set(Variable.new('D'), PioneInteger.new(4))
-    @table.get(Variable.new('D')).should == PioneInteger.new(4)
-  end
-
-  it 'should not raise errors by binding same value as same name variable' do
-    should.not.raise(VariableBindingError) do
-      @table.set(Variable.new('A'), PioneInteger.new(1).to_seq)
-      @table.set(Variable.new('B'), PioneInteger.new(2).to_seq)
-      @table.set(Variable.new('C'), PioneInteger.new(3).to_seq)
-    end
-  end
-
-  it 'should raise an error by binding different value as same name variable' do
-    should.raise(VariableBindingError) do
-      @table.set(Variable.new('A'), PioneInteger.new(100))
-    end
-  end
-
-  it 'should expand a string with variable name form' do
-    @table.expand('{$A}').should == '1'
-    @table.expand('{$B}').should == '2'
-    @table.expand('{$C}').should == '3'
-  end
-
-  it 'should expand a string with variable expression form' do
-    @table.expand('<? $A + 1 ?>').should == '2'
-    @table.expand('<? $B + 1 ?>').should == '3'
-    @table.expand('<? $C + 1 ?>').should == '4'
-  end
-
-  it 'should get keys' do
-    vars = @table.variables
-    vars.should.include(Variable.new("A"))
-    vars.should.include(Variable.new("B"))
-    vars.should.include(Variable.new("C"))
-    vars.should.not.include(Variable.new("D"))
-  end
-
-  it 'should raise an error by unknown variable when expanding a string' do
-    should.raise(UnboundVariableError) do
-      @table.expand('{$D}')
-    end
-  end
-
-  it 'should have input auto variables' do
-    input_exprs = [
-      DataExpr.new('*.a').to_seq,
-      DataExpr.new('*.b').to_seq.set_all
-    ]
-    input_tuples = [
-      Tuple[:data].new(name: '1.a', location: Location['test']),
-      [ Tuple[:data].new(name: '1.b', location: Location['test1']),
-        Tuple[:data].new(name: '2.b', location: Location['test2']),
-        Tuple[:data].new(name: '3.b', location: Location['test3'])]
-    ]
-
-    @table.make_input_auto_variables(input_exprs, input_tuples)
-
-    input = @table.get(Variable.new('I'))
-    input.should.kind_of(KeyedSequence)
-    input.should == @table.get(Variable.new('INPUT'))
-
-    input1 = input.get(PioneInteger.new(1)).first
-    input1.should.kind_of(DataExpr)
-    input1.should == DataExpr.new("1.a")
-    input1.matched_data.size.should == 2
-    input1.matched_data[0].should == "1.a"
-    input1.matched_data[1].should == "1"
-    input1.location.should == Location["test"]
-
-    input2 = input.get(PioneInteger.new(2))
-    input2.size.should == 3
-    input2[0].should.kind_of(DataExpr)
-    input2[0].name.should == "1.b"
-    input2[0].matched_data.size.should == 2
-    input2[0].matched_data[0].should == "1.b"
-    input2[0].matched_data[1].should == "1"
-    input2[1].should.kind_of(DataExpr)
-    input2[1].name.should == "2.b"
-    input2[1].matched_data.size.should == 2
-    input2[1].matched_data[0].should == "2.b"
-    input2[1].matched_data[1].should == "2"
-    input2[2].should.kind_of(DataExpr)
-    input2[2].name.should == "3.b"
-    input2[2].matched_data.size.should == 2
-    input2[2].matched_data[0].should == "3.b"
-    input2[2].matched_data[1].should == "3"
-
-    @table.get(Variable.new('*')).should == StringSequence.new([PioneString.new('1')], separator: ":")
-  end
-end

data/test/model/spec_variable.rb

@@ -1,82 +0,0 @@
-require_relative '../test-util'
-
-describe 'Model::Variable' do
-  before do
-    @a = Variable.new("a")
-    @b = Variable.new("b")
-  end
-
-  it 'should equal' do
-    @a.should == Variable.new("a")
-  end
-
-  it 'should not equal' do
-    @a.should.not == @b
-  end
-
-  describe 'pione method ==' do
-    it 'should true' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      vtable.set(@b, PioneInteger.new(1).to_seq)
-      Message.new("==", @a, @b).eval(vtable).should == PioneBoolean.new(true).to_seq
-    end
-
-    it 'should false' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      vtable.set(@b, PioneInteger.new(2).to_seq)
-      Message.new("==", @a, @b).eval(vtable).should == PioneBoolean.new(false).to_seq
-    end
-
-    it 'should raise unbound variable error' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      should.raise(UnboundVariableError) do
-        Message.new("==", @a, @b).eval(vtable)
-      end
-    end
-
-    it 'should raise type error' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      vtable.set(@b, PioneFloat.new(1.0).to_seq)
-      should.raise(MethodNotFound) do
-        Message.new("==", @a, @b).eval(vtable)
-      end
-    end
-  end
-
-  describe 'pione method !=' do
-    it 'should true' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      vtable.set(@b, PioneInteger.new(2).to_seq)
-      Message.new("!=", @a, @b).eval(vtable).should == PioneBoolean.new(true).to_seq
-    end
-
-    it 'should false' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      vtable.set(@b, PioneInteger.new(1).to_seq)
-      Message.new("!=", @a, @b).eval(vtable).should == PioneBoolean.new(false).to_seq
-    end
-
-    it 'should raise unbound variable error' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      should.raise(UnboundVariableError) do
-        Message.new("!=", @a, @b).eval(vtable)
-      end
-    end
-
-    it 'should raise type error' do
-      vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1).to_seq)
-      vtable.set(@b, PioneFloat.new(1.0).to_seq)
-      should.raise(MethodNotFound) do
-        Message.new("!=", @a, @b).eval(vtable)
-      end
-    end
-  end
-end

data/test/parser/spec_block-parser.rb

@@ -1,5 +0,0 @@
-require_relative '../test-util'
-
-describe 'Pione::Parser::BlockParser' do
-  TestUtil::Parser.spec(Pione::Parser::BlockParser, __FILE__, self)
-end

data/test/parser/spec_block-parser.yml

@@ -1,94 +0,0 @@
-flow_block_begin_line:
-  valid:
-    - "Flow"
-    - "Flow-"
-    - "Flow--"
-    - "Flow---"
-    - "Flow----"
-    - "Flow-----"
-  invalid:
-    - "-Flow"
-    - "--Flow"
-    - "---Flow"
-action_block_begin_line:
-  valid:
-    - "Action"
-    - "Action-"
-    - "Action--"
-    - "Action---"
-    - "Action----"
-    - "Action-----"
-  invalid:
-    - "-Action"
-    - "--Action"
-    - "---Action"
-block_end_line:
-  valid:
-    - "End"
-    - "-End"
-    - "--End"
-    - "---End"
-    - "----End"
-    - "-----End"
-  invalid:
-    - "End-"
-    - "End--"
-    - "End---"
-flow_block:
-  valid:
-    - |
-      Flow
-        rule Test
-      End
-    - |
-      Flow
-        rule Test1
-        rule Test2
-        rule Test3
-      End
-    - |
-      Flow
-        rule Test1
-        if $Var
-          rule Test2
-        end
-      End
-    - |
-      Flow
-        rule Test1
-        case $Var
-        when 2
-          rule Test2
-        when 3
-          rule Test3
-        end
-      End
-    - |
-      Flow
-        rule Test1
-        if $Var1
-          rule Test2
-        end
-        case $Var2
-        when 3
-          rule Test3
-        when 4
-          rule Test4
-        end
-      End
-  invalid:
-    - |
-      Flow
-      End
-    - |
-      Flow
-        rule Test
-action_block:
-  valid:
-    - |
-      Action
-        echo "abc" > A.txt
-      End
-empty_block:
-  valid:
-    - "End"