pione 0.1.3 → 0.1.4

data/test/model/spec_rule.rb

@@ -5,14 +5,14 @@ describe 'Model::RuleCondition' do
     a = RuleCondition.new(
       [DataExpr.new("a")],
       [DataExpr.new("a")],
-      Parameters.new(Variable.new("var") => "a".to_pione),
-      Feature.and(Feature::RequisiteExpr.new("a"))
+      params: Parameters.new(Variable.new("var") => "a".to_pione),
+      features: Feature.and(Feature::RequisiteExpr.new("a"))
     )
     b = RuleCondition.new(
       [DataExpr.new("a")],
       [DataExpr.new("a")],
-      Parameters.new(Variable.new("var") => "a".to_pione),
-      Feature.and(Feature::RequisiteExpr.new("a"))
+      params: Parameters.new(Variable.new("var") => "a".to_pione),
+      features: Feature.and(Feature::RequisiteExpr.new("a"))
     )
     a.should == b
   end
@@ -21,14 +21,14 @@ describe 'Model::RuleCondition' do
     a = RuleCondition.new(
       [DataExpr.new("a")],
       [DataExpr.new("a")],
-      Parameters.new(Variable.new("var") => "a".to_pione),
-      Feature.and(Feature::RequisiteExpr.new("a"))
+      parmas: Parameters.new(Variable.new("var") => "a".to_pione),
+      features: Feature.and(Feature::RequisiteExpr.new("a"))
     )
     b = RuleCondition.new(
       [DataExpr.new("b")],
       [DataExpr.new("b")],
-      Parameters.new(Variable.new("var") => "b".to_pione),
-      Feature.and(Feature::RequisiteExpr.new("b"))
+      params: Parameters.new(Variable.new("var") => "b".to_pione),
+      features: Feature.and(Feature::RequisiteExpr.new("b"))
     )
     a.should.not == b
   end
@@ -37,14 +37,14 @@ end
 condition_a = RuleCondition.new(
   [DataExpr.new("a")],
   [DataExpr.new("a")],
-  Parameters.new(Variable.new("var") => "a".to_pione),
-  Feature.and(Feature::RequisiteExpr.new("a"))
+  params: Parameters.new(Variable.new("var") => "a".to_pione),
+  features: Feature.and(Feature::RequisiteExpr.new("a"))
 )
 condition_b = RuleCondition.new(
   [DataExpr.new("b")],
   [DataExpr.new("b")],
-  Parameters.new(Variable.new("var") => "b".to_pione),
-  Feature.and(Feature::RequisiteExpr.new("b"))
+  params: Parameters.new(Variable.new("var") => "b".to_pione),
+  features: Feature.and(Feature::RequisiteExpr.new("b"))
 )
 
 describe 'Model::ActionRule' do

data/test/model/spec_sequence.rb

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

data/test/model/spec_sequence.yml

@@ -0,0 +1,60 @@
+# type check
+- '"integer"' : (1 | 2 | 3).type
+- '"string"' : ("a" | "b" | "c").type
+- '"float"' : (0.1 | 1.0 | 0.1e10).type
+- '"boolean"' : (true | false).type
+
+# each, each?, all, all?
+- true  : '"a".each?'
+- false : '"a".all?'
+- true  : '"a".each.each?'
+- false : '"a".each.all?'
+- true  : '"a".all.all?'
+- false : '"a".all.each?'
+
+# sequence
+- "(1 | 2 | 3)" : ((1 | 2) | 3)
+- "(1 | 2 | 3)" : (1 | (2 | 3))
+
+# length
+- true: '"abc".length == 1'
+- true: '("a" | "b" | "c").length == 3'
+- true: '("a" + "b" + "c").length == 1'
+
+# []
+- '"a"' : '("a" | "b" | "c")[1]'
+- '"b"' : '("a" | "b" | "c")[2]'
+- '"c"' : '("a" | "b" | "c")[3]'
+- '"a" | "b"' : '("a" | "b" | "c")[1 | 2]'
+- '"a" | "b" | "c"' : '("a" | "b" | "c")[1 | 2 | 3]'
+- '"c" | "b" | "a"' : '("a" | "b" | "c")[3 | 2 | 1]'
+- '"a"' : '"a"[1]'
+
+# head
+- '1' : '(1 | 2 | 3).head'
+- '1' : '1.head'
+
+# tail
+- '2 | 3' : '(1 | 2 | 3).tail'
+# - 'error' : '1.tail'
+
+# last
+- '3' : '(1 | 2 | 3).last'
+- '1' : '1.last'
+
+# init
+- '1 | 2' : '(1 | 2 | 3).init'
+# - 'error' : '1.init'
+
+# memeber
+- 'true' : '(1 | 2 | 3).member?(1)'
+- 'true' : '(1 | 2 | 3).member?(2)'
+- 'true' : '(1 | 2 | 3).member?(3)'
+- 'false' : '(1 | 2 | 3).member?(4)'
+- 'true | true | true' : '(1 | 2 | 3).member?(1 | 2 | 3)'
+- 'true | false' : '(1 | 2).member?(1 | 3)'
+
+# reverse
+- '3 | 2 | 1' : '(1 | 2 | 3).reverse'
+- '1' : '1.reverse'
+

data/test/model/spec_string.rb

@@ -20,8 +20,8 @@ describe 'Model::PioneString' do
 
   it 'should expand variables' do
     vtable = VariableTable.new({
-        Variable.new("var1") => PioneString.new("a"),
-        Variable.new("var2") => PioneString.new("b")
+        Variable.new("var1") => PioneString.new("a").to_seq,
+        Variable.new("var2") => PioneString.new("b").to_seq
       })
     PioneString.new("{$var1}:{$var2}").eval(vtable).should ==
       PioneString.new("a:b")
@@ -35,72 +35,5 @@ describe 'Model::PioneString' do
       PioneString.new("1 + 2 = 3")
   end
 
-  describe 'pione method ==' do
-    it 'should true' do
-      @a.call_pione_method("==", PioneString.new("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("!=", PioneString.new("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 +' do
-    it 'should get appended string' do
-      @a.call_pione_method("+", @b).should == PioneString.new("ab")
-    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 == @a
-    end
-  end
-
-  describe 'pione method length' do
-    it 'should get length of string' do
-      @a.call_pione_method("length").should == PioneInteger.new(1)
-    end
-  end
-
-  describe 'pione method include?' do
-    it 'should get truth' do
-      PioneString.new("acd").call_pione_method("include?", @a).should.true
-      PioneString.new("acd").call_pione_method("include?", @b).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        @a.call_pione_method("include?", PioneInteger.new(1))
-      end
-    end
-  end
+  test_pione_method("string")
 end

data/test/model/spec_string.yml

@@ -0,0 +1,83 @@
+# ==, !=
+- 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)'
+
+# []
+- true: '"abc"[0] == "abc"'
+- true: '("a" | "b" | "c")[0] == "abc"'
+
+# 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,67 +1,17 @@
 require_relative '../test-util'
 
 describe 'Model::TicketExpr' do
-  it 'should get empty ticket expression' do
-    TicketExpr.empty.should.empty
-  end
-
   it 'should equal between same name ticket expressions' do
-    TicketExpr.new(["T"]).should == TicketExpr.new(["T"])
+    TicketExpr.new("T").should == TicketExpr.new("T")
   end
 
   it 'should not equal' do
-    TicketExpr.new(["T"]).should.not == TicketExpr.new(["t"])
+    TicketExpr.new("T").should.not == TicketExpr.new("t")
   end
 
   it 'should get names' do
-    TicketExpr.new(["T"]).names.should == Set.new(["T"])
-  end
-
-  it 'should make complex ticket' do
-    (TicketExpr.new(["T1"]) + TicketExpr.new(["T2"])).should == TicketExpr.new(["T1", "T2"])
-  end
-
-  describe 'pione method: ==' do
-    it 'should true' do
-      TicketExpr.new(["T"]).call_pione_method("==", TicketExpr.new(["T"])).should.true
-    end
-
-    it 'should false' do
-      TicketExpr.new(["T"]).call_pione_method("==", TicketExpr.new(["t"])).should.not.true
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        TicketExpr.new(["T"]).call_pione_method("==", PioneString.new("T"))
-      end
-    end
+    TicketExpr.new("T").name.should == "T"
   end
 
-  describe 'pione method: !=' do
-    it 'should true' do
-      TicketExpr.new(["T"]).call_pione_method("!=", TicketExpr.new(["t"])).should.true
-    end
-
-    it 'should false' do
-      TicketExpr.new(["T"]).call_pione_method("!=", TicketExpr.new(["T"])).should.false
-    end
-
-    it 'should raise type error' do
-      should.raise(PioneModelTypeError) do
-        TicketExpr.new(["T"]).call_pione_method("==", PioneString.new("T"))
-      end
-    end
-  end
-
-  describe 'pione method: +' do
-    it 'should make complex ticket expression' do
-      TicketExpr.new(["T1"]).call_pione_method("+", TicketExpr.new(["T2"]))
-        .should == TicketExpr.new(["T1", "T2"])
-    end
-
-    it 'should get itself' do
-      TicketExpr.new(["T"]).call_pione_method("+", TicketExpr.new(["T"]))
-        .should == TicketExpr.new(["T"])
-    end
-  end
+  test_pione_method("ticket-expr")
 end

data/test/model/spec_ticket-expr.yml

@@ -0,0 +1,11 @@
+# ==
+- "true" : "<T1> == <T1>"
+- "false" : "<T1> == <T2>"
+
+# !=
+- "true" : "<T1> != <T2>"
+- "false" : "<T1> != <T1>"
+
+# |
+- "true" : "(<T1> | <T2>)[1] == <T1>"
+

data/test/model/spec_variable-table.rb

@@ -3,9 +3,9 @@ require_relative '../test-util'
 describe 'Model::VariableTable' do
   before do
     @table = VariableTable.new
-    @table.set(Variable.new('A'), PioneInteger.new(1))
-    @table.set(Variable.new('B'), PioneInteger.new(2))
-    @table.set(Variable.new('C'), PioneInteger.new(3))
+    @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
@@ -13,9 +13,9 @@ describe 'Model::VariableTable' do
   end
 
   it 'should get a variable value' do
-    @table.get(Variable.new('A')).should == PioneInteger.new(1)
-    @table.get(Variable.new('B')).should == PioneInteger.new(2)
-    @table.get(Variable.new('C')).should == PioneInteger.new(3)
+    @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
@@ -29,9 +29,9 @@ describe 'Model::VariableTable' do
 
   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))
-      @table.set(Variable.new('B'), PioneInteger.new(2))
-      @table.set(Variable.new('C'), PioneInteger.new(3))
+      @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
 
@@ -69,49 +69,48 @@ describe 'Model::VariableTable' do
 
   it 'should have input auto variables' do
     input_exprs = [
-      DataExpr.new('*.a'),
-      DataExpr.new('*.b').all
+      DataExpr.new('*.a').to_seq,
+      DataExpr.new('*.b').to_seq.set_all
     ]
     input_tuples = [
-      Tuple[:data].new(name: '1.a', uri: 'test'),
-      [ Tuple[:data].new(name: '1.b', uri: 'test1'),
-        Tuple[:data].new(name: '2.b', uri: 'test2'),
-        Tuple[:data].new(name: '3.b', uri: 'test3')]
+      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(RuleIOList)
+    input.should.kind_of(KeyedSequence)
     input.should == @table.get(Variable.new('INPUT'))
 
-    input1 = input[0]
-    input1.should.kind_of(RuleIOElement)
-    input1.name.should == "1.a".to_pione
-    input1.match.size.should == 2
-    input1.match[0] == "1.a".to_pione
-    input1.match[1] == "1".to_pione
-    input1.uri = "test"
+    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[1]
-    input2.should.kind_of(RuleIOList)
+    input2 = input.get(PioneInteger.new(2))
     input2.size.should == 3
-    input2[0].should.kind_of(RuleIOElement)
-    input2[0].name.should == "1.b".to_pione
-    input2[0].match.size.should == 2
-    input2[0].match[0].should == "1.b".to_pione
-    input2[0].match[1].should == "1".to_pione
-    input2[1].should.kind_of(RuleIOElement)
-    input2[1].name.should == "2.b".to_pione
-    input2[1].match.size.should == 2
-    input2[1].match[0].should == "2.b".to_pione
-    input2[1].match[1].should == "2".to_pione
-    input2[2].should.kind_of(RuleIOElement)
-    input2[2].name.should == "3.b".to_pione
-    input2[2].match.size.should == 2
-    input2[2].match[0].should == "3.b".to_pione
-    input2[2].match[1].should == "3".to_pione
-
-    @table.get(Variable.new('*')).should == PioneString.new('1')
+    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

@@ -16,23 +16,22 @@ describe 'Model::Variable' do
 
   describe 'pione method ==' do
     it 'should true' do
-      @a.call_pione_method("==", @a).should.true
       vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1))
-      vtable.set(@b, PioneInteger.new(1))
-      BinaryOperator.new("==", @a, @b).eval(vtable).should.true
+      vtable.set(@a, PioneInteger.new(1).to_seq)
+      vtable.set(@b, PioneInteger.new(1).to_seq)
+      BinaryOperator.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))
-      vtable.set(@b, PioneInteger.new(2))
-      BinaryOperator.new("==", @a, @b).eval(vtable).should.false
+      vtable.set(@a, PioneInteger.new(1).to_seq)
+      vtable.set(@b, PioneInteger.new(2).to_seq)
+      BinaryOperator.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))
+      vtable.set(@a, PioneInteger.new(1).to_seq)
       should.raise(UnboundVariableError) do
         BinaryOperator.new("==", @a, @b).eval(vtable)
       end
@@ -40,9 +39,9 @@ describe 'Model::Variable' do
 
     it 'should raise type error' do
       vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1))
-      vtable.set(@b, PioneFloat.new(1.0))
-      should.raise(PioneModelTypeError) do
+      vtable.set(@a, PioneInteger.new(1).to_seq)
+      vtable.set(@b, PioneFloat.new(1.0).to_seq)
+      should.raise(MethodNotFound) do
         BinaryOperator.new("==", @a, @b).eval(vtable)
       end
     end
@@ -51,22 +50,21 @@ describe 'Model::Variable' do
   describe 'pione method !=' do
     it 'should true' do
       vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1))
-      vtable.set(@b, PioneInteger.new(2))
-      BinaryOperator.new("!=", @a, @b).eval(vtable).should.true
+      vtable.set(@a, PioneInteger.new(1).to_seq)
+      vtable.set(@b, PioneInteger.new(2).to_seq)
+      BinaryOperator.new("!=", @a, @b).eval(vtable).should == PioneBoolean.new(true).to_seq
     end
 
     it 'should false' do
-      @a.call_pione_method("!=", @a).should.false
       vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1))
-      vtable.set(@b, PioneInteger.new(1))
-      BinaryOperator.new("!=", @a, @b).eval(vtable).should.false
+      vtable.set(@a, PioneInteger.new(1).to_seq)
+      vtable.set(@b, PioneInteger.new(1).to_seq)
+      BinaryOperator.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))
+      vtable.set(@a, PioneInteger.new(1).to_seq)
       should.raise(UnboundVariableError) do
         BinaryOperator.new("!=", @a, @b).eval(vtable)
       end
@@ -74,9 +72,9 @@ describe 'Model::Variable' do
 
     it 'should raise type error' do
       vtable = VariableTable.new
-      vtable.set(@a, PioneInteger.new(1))
-      vtable.set(@b, PioneFloat.new(1.0))
-      should.raise(PioneModelTypeError) do
+      vtable.set(@a, PioneInteger.new(1).to_seq)
+      vtable.set(@b, PioneFloat.new(1.0).to_seq)
+      should.raise(MethodNotFound) do
         BinaryOperator.new("!=", @a, @b).eval(vtable)
       end
     end

data/test/parser/spec_block-parser.yml

@@ -83,3 +83,12 @@ flow_block:
     - |
       Flow
         rule Test
+action_block:
+  valid:
+    - |
+      Action
+        echo "abc" > A.txt
+      End
+empty_block:
+  valid:
+    - "End"

data/test/parser/spec_expr-parser.yml

@@ -1,20 +1,3 @@
-expr_operator:
-  valid:
-    - "=="
-    - "!="
-    - ">="
-    - "<="
-    - ">"
-    - "<"
-    - "&&"
-    - "||"
-    - "+"
-    - "-"
-    - "*"
-    - "%"
-    - "/"
-    - ">>>"
-    - "==>"
 expr_operator_application:
   valid:
     - "true == true"

data/test/parser/spec_flow-element-parser.yml

@@ -7,7 +7,7 @@ call_rule_line:
   invalid:
     - rule
     - "rule &package:$var"
-    - rule $var:Test
+    # - rule $var:Test # should be invalid?
     - rule :$var
 if_block_begin:
   valid:

data/test/parser/spec_rule-definition-parser.yml

@@ -2,14 +2,10 @@ input_line:
   valid:
     - input '*.txt'
     - input "*.txt".as_data_expr
-  invalid:
-    - input @@@
 output_line:
   valid:
     - output '*.txt'
     - output "*.txt".as_data_expr
-  invalid:
-    - output @@@
 param_line:
   valid:
     - "param $abc"