pione 0.1.3 → 0.1.4

data/test/rule-handler/spec_update-criteria.pione

@@ -0,0 +1,39 @@
+Rule NoOutputConditions
+  input '*'
+End
+
+Rule A2B
+  input '*.a'
+  output '*.b'
+Action
+  cat {$I[1]} > {$O[1]}
+End
+
+Rule A2Null
+  input '*.a'
+  output null
+End
+
+Rule RemoveA
+  input '*.a'
+  output '*.a'.remove
+End
+
+Rule RemoveAB
+  input '*.a'
+  input '*.b'
+  output '*.a'.remove
+  output '*.b'.remove
+End
+
+Rule Touch
+  input '*.a'
+  output '*.b'.touch
+End
+
+Rule NeglectOutput
+  input '*.a'
+  output '*.b'.neglect
+Action
+  echo {$I[1]} > {$O[1]}
+End

data/test/rule-handler/spec_update-criteria.rb

@@ -0,0 +1,53 @@
+require_relative '../test-util'
+
+path = Pathname.new(File.join(File.dirname(__FILE__), "spec_update-criteria.pione"))
+document = Document.parse(path.read)
+
+time = 10.times.map {sleep 0.001; Time.now}
+tuple = {}
+['a', 'b', 'c'].map do |ext|
+  10.times do |i|
+    name = 't%d.%s' % [i, ext]
+    tuple[name] = Tuple[:data].new('test', name, nil, time[i])
+  end
+end
+
+UC = Pione::RuleHandler::UpdateCriteria
+
+#
+# test cases
+#
+yamlname = 'spec_update-criteria.yml'
+ymlpath = File.join(File.dirname(__FILE__), yamlname)
+testcases = YAML.load_file(ymlpath)
+
+describe 'RuleHandler::UpdateCriteria' do
+  testcases.each do |rule_name, cases|
+    rule = document["&main:%s" % rule_name]
+    describe rule_name do
+      cases.each do |case_name, testcase|
+        describe case_name do
+          inputs = testcase["inputs"].map do |input|
+            input.kind_of?(Array) ? input.map {|i| tuple[i]} : tuple[input]
+          end
+          outputs = (testcase["outputs"] || []).map do |output|
+            output.kind_of?(Array) ? output.map {|i| tuple[i]} : tuple[output]
+          end
+          vtable = VariableTable.new
+
+          testcase["criteria"].each do |criterion, truth|
+            it "should be %s on criterion of %s" % [truth, criterion] do
+              UC.send("%s?" % criterion, rule, inputs, outputs, vtable).should == truth
+            end
+          end
+
+          it "should get update order" do
+            order = testcase["order"]
+            order = order.to_sym if order
+            UC.order(rule, inputs, outputs, vtable).should == order
+          end
+        end
+      end
+    end
+  end
+end

data/test/rule-handler/spec_update-criteria.yml

@@ -0,0 +1,158 @@
+NoOutputConditions:
+  case1:
+    inputs:
+      - "t1.a"
+    criteria:
+      no_output_conditions: true
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+    order: "force"
+A2B:
+  case1:
+    inputs:
+      - "t1.a"
+    outputs:
+      - "t1.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+  case2:
+    inputs:
+      - "t1.a"
+    outputs:
+      - "t2.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+  case3:
+    inputs:
+      - "t2.a"
+    outputs:
+      - "t1.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: true
+    order: "force"
+A2Null:
+  case1:
+    inputs:
+      - "t1.a"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+RemoveA:
+  case1:
+    inputs:
+      - "t1.a"
+    outputs:
+      - "t1.a"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: true
+      exist_newer_input_data: false
+    order: "weak"
+RemoveAB:
+  case1:
+    inputs:
+      - "t1.a"
+      - "t2.b"
+    outputs:
+      - "t1.a"
+      - "t2.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: true
+      exist_newer_input_data: true
+    order: "force"
+Touch:
+  case1:
+    inputs:
+      - "t1.a"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: true
+      exist_output_data: false
+      exist_newer_input_data: false
+    order: "weak"
+  case2:
+    inputs:
+      - "t1.a"
+    outputs:
+      - "t1.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+  case3:
+    inputs:
+      - "t1.a"
+    outputs:
+      - "t2.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+  case4:
+    inputs:
+      - "t2.a"
+    outputs:
+      - "t1.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: true
+    order: "force"
+NeglectOutput:
+  case1:
+    inputs:
+      - "t1.a"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: true
+      exist_output_data: false
+      exist_newer_input_data: false
+    order: "weak"
+  case2:
+    inputs:
+      - "t1.a"
+    outputs:
+      - "t1.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+  case3:
+    inputs:
+      - "t1.a"
+    outputs:
+      - "t2.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false
+  case4:
+    inputs:
+      - "t2.a"
+    outputs:
+      - "t1.b"
+    criteria:
+      no_output_conditions: false
+      not_exist_output_data: false
+      exist_output_data: false
+      exist_newer_input_data: false

data/test/test-util.rb

@@ -169,6 +169,31 @@ class Bacon::Context
   end
 end
 
+module TestUtil
+  def test_pione_method(name)
+    #
+    # test cases
+    #
+    yamlname = 'spec_%s.yml' % name
+    ymlpath = File.join(File.dirname(__FILE__), 'model', yamlname)
+    testcases = YAML.load_file(ymlpath)
+
+    describe "pione method test cases" do
+      testcases.each do |testcase|
+        expect = testcase.keys.first
+        expr = testcase[expect].to_s
+        expect = expect.to_s
+        vtable = VariableTable.new
+        it '%s should be %s' % [expr, expect] do
+          expect = DocumentTransformer.new.apply(DocumentParser.new.expr.parse(expect))
+          expr = DocumentTransformer.new.apply(DocumentParser.new.expr.parse(expr))
+          expect.eval(vtable).should == expr.eval(vtable)
+        end
+      end
+    end
+  end
+end
+
 module Pione::TupleSpace
   class TupleSpaceServer
     # Return all tuples of the tuple space.

data/test/transformer/spec_block-transformer.rb

@@ -21,6 +21,13 @@ describe 'Pione::Transformer::BlockTransformer' do
         CallRule.new(RuleExpr.new(Package.new("main"), "Test"))
       )
     end
+  end
 
+  transformer_spec("empty_block", :empty_block) do
+    tc(<<-STRING) do
+      End
+    STRING
+      EmptyBlock.instance
+    end
   end
 end

data/test/transformer/spec_expr-transformer.rb

@@ -3,70 +3,106 @@ require_relative '../test-util'
 describe 'Pione::Transformer::ExprTransformer' do
   transformer_spec("binary operator", :expr) do
     tc "1 + 2" do
-      BinaryOperator.new("+", 1.to_pione, 2.to_pione)
+      BinaryOperator.new(
+        "+",
+        IntegerSequence.new([1.to_pione]),
+        IntegerSequence.new([2.to_pione])
+      )
     end
 
     tc '"a" + "b"' do
-      BinaryOperator.new("+", "a".to_pione, "b".to_pione)
+      BinaryOperator.new(
+        "+",
+        StringSequence.new(["a".to_pione]),
+        StringSequence.new(["b".to_pione])
+      )
     end
 
     tc "false || true" do
-      BinaryOperator.new("||", PioneBoolean.false, PioneBoolean.true)
+      BinaryOperator.new(
+        "||",
+        BooleanSequence.new([PioneBoolean.false]),
+        BooleanSequence.new([PioneBoolean.true])
+      )
     end
 
     tc "$Var * 3" do
-      BinaryOperator.new("*", Variable.new("Var"), 3.to_pione)
+      BinaryOperator.new(
+        "*",
+        Variable.new("Var"),
+        IntegerSequence.new([3.to_pione])
+      )
     end
 
     tc "($Var1 == \"a\") && ($Var2 == \"b\")" do
-      left = BinaryOperator.new("==", Variable.new("Var1"), "a".to_pione)
-      right = BinaryOperator.new("==", Variable.new("Var2"), PioneString.new("b"))
+      left = BinaryOperator.new(
+        "==",
+        Variable.new("Var1"),
+        StringSequence.new(["a".to_pione])
+      )
+      right = BinaryOperator.new(
+        "==",
+        Variable.new("Var2"),
+        StringSequence.new([PioneString.new("b")])
+      )
       BinaryOperator.new("&&", left, right)
     end
   end
 
   transformer_spec("data_expr", :expr) do
     tc "'test.a'" do
-      DataExpr.new("test.a")
+      DataExpr.new("test.a").to_seq
     end
 
     tc "null" do
-      DataExprNull.instance
+      DataExprNull.instance.to_seq
     end
   end
 
   transformer_spec("message", :expr) do
     tc "1.next" do
-      Message.new("next", 1.to_pione)
+      Message.new("next", IntegerSequence.new([1.to_pione]))
     end
 
     tc "1.next.next" do
-      Message.new("next", Message.new("next", 1.to_pione))
+      Message.new("next", Message.new("next", IntegerSequence.new([1.to_pione])))
     end
 
     tc "\"abc\".index(1,1)" do
-      Message.new("index", "abc".to_pione, 1.to_pione, 1.to_pione)
+      Message.new(
+        "index",
+        StringSequence.new(["abc".to_pione]),
+        IntegerSequence.new([1.to_pione]),
+        IntegerSequence.new([1.to_pione])
+      )
     end
 
     tc "(1 + 2).prev" do
-      Message.new("prev", BinaryOperator.new("+", 1.to_pione, 2.to_pione))
+      Message.new(
+        "prev",
+        BinaryOperator.new(
+          "+",
+          IntegerSequence.new([1.to_pione]),
+          IntegerSequence.new([2.to_pione])
+        )
+      )
     end
 
     tc "abc.sync" do
-      rule = RuleExpr.new(Package.new("main"), "abc", Parameters.empty, TicketExpr.empty, TicketExpr.empty)
+      rule = RuleExpr.new(Package.new("main"), "abc")
       Message.new("sync", rule)
     end
 
     tc "'*.txt'.all" do
-      Message.new("all", DataExpr.new("*.txt"))
+      Message.new("all", DataExpr.new("*.txt").to_seq)
     end
 
     tc "'*.txt'.all()" do
-      Message.new("all", DataExpr.new("*.txt"))
+      Message.new("all", DataExpr.new("*.txt").to_seq)
     end
 
     tc "'*.txt'.all(true)" do
-      Message.new("all", DataExpr.new("*.txt"), PioneBoolean.true)
+      Message.new("all", DataExpr.new("*.txt").to_seq, BooleanSequence.new([PioneBoolean.true]))
     end
   end
 
@@ -76,15 +112,24 @@ describe 'Pione::Transformer::ExprTransformer' do
     end
 
     tc "{var1: 1}" do
-      {"var1" => 1}.to_params
+      Parameters.new(
+        {Variable.new("var1") => IntegerSequence.new([PioneInteger.new(1)])}
+      )
     end
 
     tc "{var1: 1, var2: 2}" do
-      {"var1" => 1, "var2" => 2}.to_params
+      Parameters.new(
+        { Variable.new("var1") => IntegerSequence.new([PioneInteger.new(1)]),
+          Variable.new("var2") => IntegerSequence.new([PioneInteger.new(2)]) }
+      )
     end
 
     tc "{var1: \"a\", var2: \"b\", var3: \"c\"}" do
-      {"var1" => "a", "var2" => "b", "var3" => "c"}.to_params
+      Parameters.new(
+        { Variable.new("var1") => StringSequence.new([PioneString.new("a")]),
+          Variable.new("var2") => StringSequence.new([PioneString.new("b")]),
+          Variable.new("var3") => StringSequence.new([PioneString.new("c")]) }
+      )
     end
   end
 end

data/test/transformer/spec_flow-element-transformer.rb

@@ -20,7 +20,7 @@ describe 'Pione::Transformer::FlowElementTransformer' do
   transformer_spec("assignment", :assignment) do
     tc(
       "$var := 1" =>
-      Assignment.new(Variable.new("var"), PioneInteger.new(1))
+      Assignment.new(Variable.new("var"), IntegerSequence.new([PioneInteger.new(1)]))
     )
     tc(
       "$a := $b" =>
@@ -45,9 +45,9 @@ describe 'Pione::Transformer::FlowElementTransformer' do
         BinaryOperator.new(
           "==",
           Variable.new("Var"),
-          PioneInteger.new(1)
+          IntegerSequence.new([PioneInteger.new(1)])
         ),
-        { PioneBoolean.true =>
+        { BooleanSequence.new([PioneBoolean.true]) =>
           FlowBlock.new(
             CallRule.new(RuleExpr.new(Package.new("main"), "A"))
           )
@@ -65,9 +65,9 @@ describe 'Pione::Transformer::FlowElementTransformer' do
         BinaryOperator.new(
           "==",
           Variable.new("Var"),
-          PioneString.new("a")
+          StringSequence.new([PioneString.new("a")])
         ),
-        { PioneBoolean.true =>
+        { BooleanSequence.new([PioneBoolean.true]) =>
           FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "A"))),
           :else =>
           FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "B")))
@@ -88,7 +88,7 @@ describe 'Pione::Transformer::FlowElementTransformer' do
       inner_block = FlowBlock.new(
         ConditionalBlock.new(
           Variable.new("b"),
-          { PioneBoolean.true =>
+          { BooleanSequence.new([PioneBoolean.true]) =>
             FlowBlock.new(
               CallRule.new(RuleExpr.new(Package.new("main"), "Test1"))
             ),
@@ -101,7 +101,7 @@ describe 'Pione::Transformer::FlowElementTransformer' do
       )
       ConditionalBlock.new(
         Variable.new("a"),
-        { PioneBoolean.true => inner_block,
+        { BooleanSequence.new([PioneBoolean.true]) => inner_block,
           :else =>
           FlowBlock.new(
             CallRule.new(RuleExpr.new(Package.new("main"), "Test3"))
@@ -124,11 +124,11 @@ describe 'Pione::Transformer::FlowElementTransformer' do
     STRING
       ConditionalBlock.new(
         Variable.new("Var"),
-        { PioneString.new("a") =>
+        { StringSequence.new([PioneString.new("a")]) =>
           FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "A"))),
-          PioneString.new("b") =>
+          StringSequence.new([PioneString.new("b")]) =>
           FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "B"))),
-          PioneString.new("c") =>
+          StringSequence.new([PioneString.new("c")]) =>
           FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "C")))
         }
       )
@@ -143,7 +143,7 @@ describe 'Pione::Transformer::FlowElementTransformer' do
     STRING
       ConditionalBlock.new(
         Variable.new("Var"),
-        { PioneString.new("a") =>
+        { StringSequence.new([PioneString.new("a")]) =>
           FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "Test1"))),
           :else =>
           FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "Test2")))

data/test/transformer/spec_literal-transformer.rb

@@ -2,37 +2,37 @@ require_relative '../test-util'
 
 describe 'Pione::Transformer::LiteralTransformer' do
   transformer_spec('boolean', :boolean) do
-    tc('true' => PioneBoolean.true)
-    tc('false' => PioneBoolean.false)
+    tc('true' => BooleanSequence.new([PioneBoolean.true]))
+    tc('false' => BooleanSequence.new([PioneBoolean.false]))
   end
 
   transformer_spec('string', :string) do
-    tc('"abc"' => PioneString.new('abc'))
-    tc('"a\bc"' => PioneString.new('abc'))
-    tc('"a\'"' => PioneString.new('a\''))
-    tc('"a\""' => PioneString.new('a"'))
+    tc('"abc"' => StringSequence.new([PioneString.new('abc')]))
+    tc('"a\bc"' => StringSequence.new([PioneString.new('abc')]))
+    tc('"a\'"' => StringSequence.new([PioneString.new('a\'')]))
+    tc('"a\""' => StringSequence.new([PioneString.new('a"')]))
   end
 
   transformer_spec('integer', :integer) do
-    tc('1' => PioneInteger.new(1))
-    tc('123' => PioneInteger.new(123))
-    tc('01' => PioneInteger.new(1))
-    tc('000123' => PioneInteger.new(123))
-    tc('-1' => PioneInteger.new(-1))
-    tc('-01' => PioneInteger.new(-1))
-    tc('+1' => PioneInteger.new(1))
-    tc('+01' => PioneInteger.new(1))
+    tc('1' => IntegerSequence.new([PioneInteger.new(1)]))
+    tc('123' => IntegerSequence.new([PioneInteger.new(123)]))
+    tc('01' => IntegerSequence.new([PioneInteger.new(1)]))
+    tc('000123' => IntegerSequence.new([PioneInteger.new(123)]))
+    tc('-1' => IntegerSequence.new([PioneInteger.new(-1)]))
+    tc('-01' => IntegerSequence.new([PioneInteger.new(-1)]))
+    tc('+1' => IntegerSequence.new([PioneInteger.new(1)]))
+    tc('+01' => IntegerSequence.new([PioneInteger.new(1)]))
   end
 
   transformer_spec('float', :float) do
-    tc('0.1' => PioneFloat.new(0.1))
-    tc('123.1' => PioneFloat.new(123.1))
-    tc('01.23' => PioneFloat.new(1.23))
-    tc('000123.456' => PioneFloat.new(123.456))
-    tc('-1.2' => PioneFloat.new(-1.2))
-    tc('-01.1' => PioneFloat.new(-1.1))
-    tc('+1.9' => PioneFloat.new(1.9))
-    tc('+01.8' => PioneFloat.new(1.8))
+    tc('0.1' => FloatSequence.new([PioneFloat.new(0.1)]))
+    tc('123.1' => FloatSequence.new([PioneFloat.new(123.1)]))
+    tc('01.23' => FloatSequence.new([PioneFloat.new(1.23)]))
+    tc('000123.456' => FloatSequence.new([PioneFloat.new(123.456)]))
+    tc('-1.2' => FloatSequence.new([PioneFloat.new(-1.2)]))
+    tc('-01.1' => FloatSequence.new([PioneFloat.new(-1.1)]))
+    tc('+1.9' => FloatSequence.new([PioneFloat.new(1.9)]))
+    tc('+01.8' => FloatSequence.new([PioneFloat.new(1.8)]))
   end
 
   transformer_spec('variable', :variable) do
@@ -41,10 +41,10 @@ describe 'Pione::Transformer::LiteralTransformer' do
   end
 
   transformer_spec('data_name', :data_name) do
-    tc("'abc'" => DataExpr.new('abc'))
-    tc("'a\\bc'" => DataExpr.new('abc'))
-    tc("'a\\''" => DataExpr.new("a'"))
-    tc("'a\\\"'" => DataExpr.new("a\""))
+    tc("'abc'" => DataExpr.new('abc').to_seq)
+    tc("'a\\bc'" => DataExpr.new('abc').to_seq)
+    tc("'a\\''" => DataExpr.new("a'").to_seq)
+    tc("'a\\\"'" => DataExpr.new("a\"").to_seq)
   end
 
   transformer_spec('package_name', :package_name) do
@@ -57,8 +57,8 @@ describe 'Pione::Transformer::LiteralTransformer' do
   end
 
   transformer_spec('ticket', :ticket) do
-    tc("<T>" => Ticket.new("T"))
-    tc("< T>" => Ticket.new("T"))
-    tc("<T >" => Ticket.new("T"))
+    tc("<T>" => TicketExpr.new("T").to_seq)
+    tc("< T>" => TicketExpr.new("T").to_seq)
+    tc("<T >" => TicketExpr.new("T").to_seq)
   end
 end