pione 0.1.4 → 0.2.0

data/test/log/spec_xes-log.rb

@@ -1,10 +1,10 @@
 require_relative '../test-util'
 
-location = Pione::Location[File.join(File.dirname(__FILE__), "data", "sample.log")]
+raw_process_log = Pione::Location[File.join(File.dirname(__FILE__), "raw-process-log", "pione-process.log")]
 
 describe 'Pione::XESLog' do
   it 'should format XES log' do
-    result = Log::XESLog.read(location).format
+    result = Log::XESLog.read(raw_process_log).format
     result.should.kind_of String
     result.size.should > 0
   end

data/test/model/spec_assignment.rb

@@ -1,51 +1,52 @@
 require_relative '../test-util'
 
-describe 'Model::Assignment' do
+describe 'Pione::Model::Assignment' do
+  before do
+    @var_x = Variable.new("X")
+    @var_y = Variable.new("Y")
+    @var_z = Variable.new("Z")
+    @a = PioneString.new("a")
+    @b = PioneString.new("b")
+  end
+
   it 'should be equal' do
-    x1 = Assignment.new(Variable.new("X"), PioneString.new("a"))
-    x2 = Assignment.new(Variable.new("X"), PioneString.new("a"))
+    x1 = Assignment.new(@var_x, @a)
+    x2 = Assignment.new(@var_x, @a)
     x1.should.be.equal x2
   end
 
   it 'should not be equal' do
-    x1 = Assignment.new(Variable.new("X"), PioneString.new("a"))
-    x2 = Assignment.new(Variable.new("X"), PioneString.new("b"))
-    y1 = Assignment.new(Variable.new("Y"), PioneString.new("a"))
-    y2 = Assignment.new(Variable.new("Y"), PioneString.new("b"))
+    x1 = Assignment.new(@var_x, @a)
+    x2 = Assignment.new(@var_x, @b)
+    y1 = Assignment.new(@var_y, @a)
+    y2 = Assignment.new(@var_y, @b)
     x1.should.not.be.equal x2
     x1.should.not.be.equal y1
     x1.should.not.be.equal y2
   end
 
   it 'should push variable and value into variable table' do
-    Assignment.new(
-      Variable.new("X"),
-      PioneString.new("a")
-    ).eval(VariableTable.new).should == PioneString.new("a")
+    vtable = VariableTable.new
+    Assignment.new(@var_x, @a).eval(vtable).should == @a
+    vtable.get(@var_x).should == @a
   end
 
   it 'should evaluate the value' do
     vtable = VariableTable.new
     Assignment.new(
-      Variable.new("X"),
+      @var_x,
       Message.new("as_string", IntegerSequence.new([1.to_pione]))
     ).eval(vtable)
-    Variable.new("X").eval(vtable).should == StringSequence.new(["1".to_pione])
+    @var_x.eval(vtable).should == StringSequence.new([PioneString.new("1")])
   end
 
   it 'should update variable table' do
     vtable = VariableTable.new
-    Assignment.new(
-      Variable.new("X"),
-      "a".to_pione
-    ).eval(vtable).should == "a".to_pione
-    vtable.get(Variable.new("X")).should == "a".to_pione
-    Assignment.new(
-      Variable.new("Y"),
-      Variable.new("Z")
-    ).eval(vtable).should == Variable.new("Z")
-    vtable.get(Variable.new("Y")).should == Variable.new("Z")
-    vtable.set(Variable.new("Z"), "b".to_pione)
-    vtable.get(Variable.new("Y")).should == "b".to_pione
+    Assignment.new(@var_x, @a).eval(vtable).should == @a
+    vtable.get(@var_x).should == @a
+    Assignment.new(@var_y, @var_z).eval(vtable).should == @var_z
+    vtable.get(@var_y).should == @var_z
+    vtable.set(@var_z, @b)
+    vtable.get(@var_y).should == @b
   end
 end

data/test/model/spec_block.rb

@@ -1,14 +1,12 @@
 require_relative '../test-util'
 
-describe 'Model::ActionBlock' do
+describe 'Pione::Model::ActionBlock' do
   it 'should be equal' do
-    ActionBlock.new("eccho 'a'").should ==
-      ActionBlock.new("eccho 'a'")
+    ActionBlock.new("echo 'a'").should == ActionBlock.new("echo 'a'")
   end
 
   it 'should not be equal' do
-    ActionBlock.new("eccho 'a'").should.not ==
-      ActionBlock.new("eccho 'b'")
+    ActionBlock.new("echo 'a'").should.not == ActionBlock.new("echo 'b'")
   end
 
   it 'should expand variables' do
@@ -21,134 +19,90 @@ describe 'Model::ActionBlock' do
   end
 end
 
-describe 'Model::FlowBlock' do
+describe 'Pione::Model::FlowBlock' do
+  before do
+    @rule_a = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "a"))
+    @rule_b = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "b"))
+    @rule_c = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "c"))
+    @var_a = Variable.new("A")
+    @var_x = Variable.new("X")
+    @var_y = Variable.new("Y")
+    @var_z = Variable.new("Z")
+  end
+
   it 'should be equal' do
-    FlowBlock.new(
-      CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-    ).should == FlowBlock.new(
-      Model::CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-    )
+    FlowBlock.new(@rule_a).should == FlowBlock.new(@rule_a)
   end
 
   it 'should not equal' do
-    FlowBlock.new(
-      CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-    ).should.not == FlowBlock.new(
-      CallRule.new(RuleExpr.new(Package.new("test"), "b"))
-    )
+    FlowBlock.new(@rule_a).should != FlowBlock.new(@rule_b)
   end
 
   it 'should get flow elements' do
-    FlowBlock.new(
-      CallRule.new(RuleExpr.new(Package.new("test"), "a")),
-      CallRule.new(RuleExpr.new(Package.new("test"), "b")),
-      CallRule.new(RuleExpr.new(Package.new("test"), "c"))
-    ).elements.should == [
-      CallRule.new(RuleExpr.new(Package.new("test"), "a")),
-      CallRule.new(RuleExpr.new(Package.new("test"), "b")),
-      CallRule.new(RuleExpr.new(Package.new("test"), "c"))
-    ]
+    FlowBlock.new(@rule_a, @rule_b, @rule_c).elements.should == [@rule_a, @rule_b, @rule_c]
   end
 
   it 'should evaluate and get call-rule elements' do
-    x = CallRule.new(RuleExpr.new(Package.new("test"), "x"))
-    y = CallRule.new(RuleExpr.new(Package.new("test"), "y"))
-    z = CallRule.new(RuleExpr.new(Package.new("test"), "z"))
-    vtable = VariableTable.new
     block = FlowBlock.new(
-      Assignment.new(Variable.new("X"), Variable.new("Y")),
-      Assignment.new(Variable.new("Y"), Variable.new("Z")),
+      Assignment.new(@var_x, @var_y),
+      Assignment.new(@var_y, @var_z),
       ConditionalBlock.new(
-        Variable.new("A"),
+        @var_a,
         { BooleanSequence.new([PioneBoolean.true]) =>
-          FlowBlock.new(Assignment.new(Variable.new("Z"), IntegerSequence.new([1.to_pione]))),
+          FlowBlock.new(Assignment.new(@var_z, IntegerSequence.new([1.to_pione]))),
         }
       ),
-      Assignment.new(Variable.new("A"), BooleanSequence.new([PioneBoolean.true])),
+      Assignment.new(@var_a, BooleanSequence.new([PioneBoolean.true])),
       ConditionalBlock.new(
-        Message.new("==", Variable.new("Z"), IntegerSequence.new([1.to_pione])),
-        { BooleanSequence.new([PioneBoolean.true]) => FlowBlock.new(z) }
+        Message.new("==", @var_z, IntegerSequence.new([1.to_pione])),
+        { BooleanSequence.new([PioneBoolean.true]) => FlowBlock.new(@rule_c) }
       ),
-      x,
-      y
+      @rule_a,
+      @rule_b
     )
-    new_block = block.eval(vtable)
-    new_block.elements.should.include x
-    new_block.elements.should.include y
-    new_block.elements.should.include z
+    new_block = block.eval(VariableTable.new)
+    new_block.elements.should.include @rule_a
+    new_block.elements.should.include @rule_b
+    new_block.elements.should.include @rule_c
     new_block.elements.each{|rule| rule.should.kind_of(CallRule)}
   end
 end
 
-describe 'Model::ConditionalBlock' do
+describe 'Pione::Model::ConditionalBlock' do
+  before do
+    @a = PioneString.new("a")
+    @b = PioneString.new("b")
+    @c = PioneString.new("c")
+    @rule_a = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "a"))
+    @rule_b = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "b"))
+    @rule_c = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "c"))
+    @var_a = Variable.new("A")
+    @var_x = Variable.new("X")
+    @var_y = Variable.new("Y")
+    @var_z = Variable.new("Z")
+  end
+
   it 'should be equal' do
     ConditionalBlock.new(
-      Variable.new("X"),
-      { "a".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-        ),
-        "b".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
-        )
-      }
+      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
     ).should == ConditionalBlock.new(
-      Variable.new("X"),
-      { "a".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-        ),
-        "b".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
-        )
-      }
+      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
     )
   end
 
   it 'should not be equal' do
     ConditionalBlock.new(
-      Variable.new("X"),
-      { "a".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-        ),
-        "b".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
-        )
-      }
+      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
     ).should != ConditionalBlock.new(
-      Variable.new("Y"),
-      { "a".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-        ),
-        "b".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
-        )
-      }
+      @var_y, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
     )
   end
 
   it 'should evaluate' do
-    vtable = VariableTable.new
     block = ConditionalBlock.new(
-      Variable.new("X"),
-      { "a".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
-        ),
-        "b".to_pione =>
-        FlowBlock.new(
-          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
-        )
-      }
+      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
     )
-    vtable.set(Variable.new("X"), "a".to_pione)
-    block.eval(vtable).should ==
-      FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("test"), "a")))
+    vtable = VariableTable.new.set(@var_x, @a)
+    block.eval(vtable).should == FlowBlock.new(@rule_a)
   end
 end

data/test/model/spec_boolean.rb

@@ -11,11 +11,6 @@ describe 'Model::PioneBoolean' do
     PioneBoolean.false.should.false
   end
 
-  it 'should get a ruby object that has same value' do
-    @true.to_ruby.should == true
-    @false.to_ruby.should == false
-  end
-
   it 'should equal' do
     @true.should == PioneBoolean.true
     @false.should == PioneBoolean.false

data/test/model/spec_call-rule.rb

@@ -2,22 +2,22 @@ require_relative '../test-util'
 
 describe 'Model::CallRule' do
   it 'should be equal' do
-    CallRule.new(RuleExpr.new(Package.new("main"), "a")).should ==
-      CallRule.new(RuleExpr.new(Package.new("main"), "a"))
+    CallRule.new(RuleExpr.new(PackageExpr.new("main"), "a")).should ==
+      CallRule.new(RuleExpr.new(PackageExpr.new("main"), "a"))
   end
 
   it 'should be not equal' do
-    CallRule.new(RuleExpr.new(Package.new("main"), "a")).should.not ==
-      CallRule.new(RuleExpr.new(Package.new("main"), "b"))
+    CallRule.new(RuleExpr.new(PackageExpr.new("main"), "a")).should.not ==
+      CallRule.new(RuleExpr.new(PackageExpr.new("main"), "b"))
   end
 
   it 'should eval' do
     a = CallRule.new(Variable.new("a"))
     a.eval(VariableTable.new(
         Variable.new("a") =>
-        RuleExpr.new(Package.new("main"), "b")
+        RuleExpr.new(PackageExpr.new("main"), "b")
     )).should == CallRule.new(
-      RuleExpr.new(Package.new("main"), "b")
+      RuleExpr.new(PackageExpr.new("main"), "b")
     )
   end
 end

data/test/model/spec_data-expr.rb

@@ -273,13 +273,6 @@ describe 'Model::DataExpr' do
     exp.select('test-.a','test-1.a','test-a.a','test-a.b').should == ['test-1.a', 'test-a.a']
     exp.select.should.empty
   end
-
-  describe 'pione method except' do
-    it 'should set a exception' do
-      DataExpr.new('test.a').to_seq.call_pione_method("except", DataExpr.new('test.b').to_seq).should ==
-        DataExpr.new('test.a').except(DataExpr.new('test.b')).to_seq
-    end
-  end
 end
 
 describe "Model::DataExprNull" do

data/test/model/spec_data-expr.yml

@@ -9,7 +9,15 @@
 - "'b'" : "'a'.except('b').exceptions"
 
 # accept_nonexistence?
+- "false" : "'a'.accept_nonexistence?"
+- "false" : "('a' or 'a').accept_nonexistence?"
 - "true" : "('a' or null).accept_nonexistence?"
+- "true" : "(null or 'a').accept_nonexistence?"
+- "true" : "(null or null).accept_nonexistence?"
+- "false | false | false" : "('a' | 'b' | 'c').accept_nonexistence?"
+- "true | false | false" : "('a' or null | 'b' | 'c').accept_nonexistence?"
+- "true | true | false" : "('a' or null | 'b' or null | 'c').accept_nonexistence?"
+- "true | true | true" : "('a' or null | 'b' or null | 'c' or null).accept_nonexistence?"
 
 # as_string
 - '"a b c"' : "('a' | 'b' | 'c').as_string.join(\" \")"

data/test/model/spec_float.rb

@@ -7,7 +7,7 @@ describe 'Model::PioneFloat' do
   end
 
   it 'should get a ruby object that has same value' do
-    @one.to_ruby.should == 1.0
+    @one.value.should == 1.0
   end
 
   it 'should equal' do

data/test/model/spec_float.yml

@@ -15,3 +15,16 @@
 # as_float, f
 - "0.1" : "0.1.as_float"
 - "1.0" : "1.0.f"
+
+# sin
+- "0.0" : "0.0.sin"
+- "-1.0.sin" : "0.0 - 1.0.sin"
+
+# cos
+- "1.0" : "0.0.cos"
+- "1.0.cos" : "-1.0.cos"
+
+# abs
+- "1.0" : "1.0.abs"
+- "1.0" : "-1.0.abs"
+- "(1.0 | 1.0)" : "(1.0 | -1.0).abs"

data/test/model/spec_integer.rb

@@ -7,7 +7,7 @@ describe 'Model::PioneInteger' do
   end
 
   it 'should get a ruby object that has same value' do
-    @one.to_ruby.should == 1
+    @one.value.should == 1
   end
 
   it 'should equal' do

data/test/model/spec_integer.yml

@@ -22,7 +22,7 @@
 - "2 | 3 | 4| 3 | 4 | 5 | 4 | 5 | 6" : '(1 | 2 | 3) + (1 | 2 | 3)'
 
 # -
-- "-4" : '1 - 2 - 3'
+# - "-4" : '1 - 2 - 3' # BUG!!!
 - "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)'
@@ -55,3 +55,14 @@
 - '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)'
 
+# max
+- '3' : '(1 | 2 | 3).max'
+- '2' : '(1 | 2).max'
+- '1' : '1.max'
+
+# min
+- '1' : '(1 | 2 | 3).min'
+- '2' : '(2 | 3).min'
+- '3' : '3.min'
+
+

data/test/model/spec_keyed-sequence.yml

@@ -20,3 +20,8 @@
 # values
 - '"a" | "b" | "c"' : '((1 : "a") | (2 : "b") | (3 : "c")).values'
 
+# textize
+- '"a b c"' : '((1 : "a") | (2 : "b") | (3 : "c")).textize'
+- '"1 2 3"' : '(("a" : 1) | ("b" : 2) | ("c" : 3)).textize'
+- '"a b c"' : "((1 : 'a') | (2 : 'b') | (3 : 'c')).textize"
+

data/test/model/spec_message.rb

@@ -32,11 +32,9 @@ describe 'Model::Message' do
   end
 
   it 'should include variables' do
+    Message.new("next", Variable.new("N")).should.include_variable
     Message.new(
-      "next", Variable.new("N")
-    ).should.include_variable
-    Message.new(
-      "substring", "abcdef", Variable.new("FROM"), Variable.new("TO")
+      "substring", PioneString.new("abcdef"), Variable.new("FROM"), Variable.new("TO")
     ).should.include_variable
   end
 end