pione 0.2.2 → 0.3.0

data/test/{parser/spec_flow-element-parser.yml → lang/data/conditional-branch-parser.yml}

@@ -1,15 +1,4 @@
-call_rule_line:
-  valid:
-    - rule Test
-    - rule :Test
-    - "rule &package:Test"
-    - rule $var
-  invalid:
-    - rule
-    - "rule &package:$var"
-    # - rule $var:Test # should be invalid?
-    - rule :$var
-if_block_begin:
+if_branch_header:
   valid:
     - "if $Var"
     - "if 1"
@@ -23,17 +12,8 @@ if_block_begin:
     - "if ?A"
   invalid:
     - "if $$"
-conditional_block_end:
-  valid:
-    - "end"
-else_block:
-  valid:
-    - |
-      else
-        rule Test
-    - |
-      else
-if_block:
+
+if_branch:
   valid:
     - |
       if $Var
@@ -80,7 +60,8 @@ if_block:
       else
         rule Test
       end
-case_block_begin:
+
+case_branch_header:
   valid:
     - case $Var
     - case 1
@@ -90,7 +71,8 @@ case_block_begin:
     - case +A
     - case -A
     - case ?A
-when_block_begin:
+
+when_context_header:
   valid:
     - when $Var
     - when 1
@@ -100,11 +82,12 @@ when_block_begin:
     - when +A
     - when -A
     - when ?A
-    - when @
+    - when **
     - when *
     - "when !A"
     - when ^A
-when_block:
+
+when_context:
   valid:
     - when $Var
     - |
@@ -115,7 +98,8 @@ when_block:
         rule Test1
         rule Test2
         rule Test3
-case_block:
+
+case_branch:
   valid:
     - |
       case $Var
@@ -156,25 +140,3 @@ case_block:
         rule Test2
       else
       end
-flow_element:
-  valid:
-    - rule Test
-    - |
-      if $Var
-        rule Test
-      end
-    - |
-      case $Var
-      when 1
-        rule Test1
-      when 2
-        rule Test2
-      end
-assignment:
-  valid:
-    - "$X := 1"
-    - "$Var := true"
-    - "$X := $Y"
-    - "$X := 1 + 1"
-    - "$X := true || false || true"
-    - "$X := ($Y := 1)"

data/test/lang/data/context-parser.yml

@@ -0,0 +1,148 @@
+structural_context_element:
+  valid:
+    # variable binding sentence
+    - "$X := 1"
+    # param sentence
+    - "param $X := 1"
+    # rule binding sentence
+    - "rule A := B"
+    # constituent_rule_sentence
+    - "rule A"
+    # input sentence
+    - "input 'a.txt'"
+    # output sentence
+    - "output 'b.txt'"
+    # feature sentence
+    - "feature +A"
+    # constraint sentence
+    - "constraint $X.odd?"
+    # param block
+    - |
+      Param
+        $X := 1
+      End
+    # flow rule block
+    - |
+      Rule A
+        input 'a.txt'
+        output 'b.txt'
+      Flow
+        rule B
+      End
+    # action rule block
+    - |
+      Rule A
+        input 'a.txt'
+        output 'b.txt'
+      Action
+        echo {$I[1]} > {$O[1]}
+      End
+    # empty rule block
+    - |
+      Rule A
+        input 'a.txt'
+        output 'b.txt'.touch
+      End
+    # annotation sentence
+    - ".@ author :: \"Keita Yamaguchi\""
+    # expr sentence
+    - "? 1 + 1"
+    # if branch
+    - |
+      if $X
+        rule A
+      end
+    # case branch
+    - |
+      case $X
+      when 1
+        rule A
+      when 2
+        rule B
+      end
+
+structural_context:
+  valid:
+    - | # full elements
+      $X := 1
+      param $X := 1
+      rule A
+      rule A := B
+      input 'a.txt'
+      output 'b.txt'
+      feature +A
+      constraint $X.odd?
+      Param
+        $X := 1
+      End
+      Rule A
+        input 'a.txt'
+        output 'b.txt'
+      Flow
+        rule B
+      End
+      Rule A
+        input 'a.txt'
+        output 'b.txt'
+      Action
+        echo {$I[1]} > {$O[1]}
+      End
+      Rule A
+        input 'a.txt'
+        output 'b.txt'.touch
+      End
+      .@ author :: "Keita Yamaguchi"
+      ? 1 + 1
+      if $X
+        rule A
+      end
+      case $X
+      when 1
+        rule A
+      when 2
+        rule B
+      end
+    - | # heading empty line
+      
+      rule Test1
+      rule Test2
+    - | # tail empty line
+      rule Test1
+      rule Test2
+      
+    - | # middle empty line
+      rule Test1
+      
+      rule Test2
+    - | # heading commment line
+      # comment
+      rule Test1
+      rule Test2
+    - | # tail comment line
+      rule Test1
+      rule Test2
+      # comment
+    - | # middle comment line
+      rule Test1
+      # comment
+      rule Test2
+
+rule_condition_context:
+  valid:
+    - | # parameters without default values
+      param $X
+      basic param $Y
+      advanced param $Z
+    - | # parameters with default values
+      param $X := 1
+      basic param $Y := 2
+      advanced param $Z := 3
+
+literal_context:
+  valid:
+    - | # shell script
+      echo "abc" > A.txt
+    - | # Any literals are OK.
+      This is a line.
+      This is a line, too.
+

data/test/lang/data/data-expr.yml

@@ -0,0 +1,93 @@
+"#|":
+  # make sequence
+  - "'a' | 'b' | 'c'" : "'a' | 'b' | 'c'"
+
+"#all & #all?":
+  # default is "each"
+  - "false" : "'a'.all?"
+  # turn to be all
+  - "true" : "'a'.all.all?"
+  # turn to be each
+  - "false" : "'a'.each.all?"
+  # sequential receiver
+  - "false" : "('a' | 'b' | 'c').all?"
+  # sequential receiver turns to be all
+  - "true" :  "('a' | 'b' | 'c').all.all?"
+  # sequential receiver truns to be each
+  - "false" :  "('a' | 'b' | 'c').each.all?"
+
+"#each & #each?":
+  # default is "each"
+  - "true" : "'a'.each?"
+  # turn to be all
+  - "false" : "'a'.all.each?"
+  # trun to be each
+  - "true" : "'a'.each.each?"
+  # sequential receiver
+  - "true" : "('a' | 'b' | 'c').each?"
+  # sequential receiver turns to be all
+  - "false" : "('a' | 'b' | 'c').all.each?"
+  # sequential receiver turns to be each
+  - "true" : "('a' | 'b' | 'c').each.each?"
+
+"#or":
+  # make sequence
+  - "'a' | 'b' | 'c'" : "'a' or 'b' or 'c'"
+  # with null
+  - "'a' | null" : "'a' or null"
+
+"#except & #exceptions":
+  # return data-expr
+  - '"data-expr"' : "'a'.except('b').type"
+  # set single exception
+  - "'b'" : "'a'.except('b').exceptions"
+  # set exception of exception
+  - "'b'.except('c')" : "'a'.except('b'.except('c')).exceptions"
+  # multiple exceptions
+  - "'b' | 'c'" : "'a'.except('b').except('c').exceptions"
+
+"#accept_nonexistence?":
+  # single
+  - "false" : "'a'.accept_nonexistence?"
+  # single null
+  - "true" : "null.accept_nonexistence?"
+  # with footing null
+  - "true" : "('a' | null).accept_nonexistence?"
+  # with heading null
+  - "true" : "(null | 'a').accept_nonexistence?"
+  # sequential null
+  - "true" : "(null | null).accept_nonexistence?"
+  # sequential receiver
+  - "false" : "('a' | 'b' | 'c').accept_nonexistence?"
+  # sequential receiver with null
+  - "true" : "('a' or null | 'b' | 'c').accept_nonexistence?"
+  - "true" : "('a' | 'b' or null | 'c').accept_nonexistence?"
+  - "true" : "('a' | 'b' | 'c' or null).accept_nonexistence?"
+
+"#as_string":
+  # simple conversion
+  - '"1.a"' : "'1.a'.as_string"
+  # with wildcard
+  - '"*.a"' : "'*.a'.as_string"
+  # null is empty string
+  - '""' : 'null.as_string'
+  # sequential receiver
+  - '"a" | "b" | "c"' : "('a' | 'b' | 'c').as_string"
+
+"#suffix":
+  # simple replacement
+  - "'abc.b'" : "'abc.a'.suffix('b')"
+  # with string
+  - "'abc.b'" : "'abc.a'.suffix(\"b\")"
+  # with wildcard
+  - "'*.b'" : "'*.a'.suffix(\"b\")"
+  # null is reflexive
+  - "null" : "null.suffix(\"b\")"
+  # sequential receiver
+  - "'X.b' | 'Y.b' | 'Z.b'" : "('X.a' | 'Y.a' | 'Z.a').suffix(\"b\")"
+  # sequential argument
+  - "'*.x' | '*.y' | '*.z'" : "'*.a'.suffix(\"x\" | \"y\" | \"z\")"
+  # sequential receiver and argument
+  - "'*.x' | '*.y' | '*.z' | '*.x' | '*.y' | '*.z' | '*.x' | '*.y' | '*.z'" :
+      "('*.a' | '*.b' | '*.c').suffix('x' | 'y' | 'z')"
+

data/test/lang/data/data-expr_match.yml

@@ -0,0 +1,59 @@
+"literal match":
+  "'1.a'":
+    match:
+      - "1.a"
+    unmatch:
+      - "01.a"
+      - "1.ab"
+      - "1..a"
+
+"wildcard match":
+  "'*.a'":
+    match:
+      - "1.a"
+      - "2.a"
+      - "3.a"
+      - "123.a"
+    unmatch:
+      - "1.b"
+      - ".a"
+      - "a"
+      - "1.1a"
+      - "1.aa"
+      - "123.aa"
+
+"':' is not special":
+  "'A:B'":
+    unmatch:
+      - "A"
+      - "B"
+      - "AB"
+      - "BA"
+  "'*.a:*.b'":
+    unmatch:
+      - "1.a"
+      - "1.b"
+      - "1.ab"
+      - "1.ba"
+      - ".a"
+      - ".b"
+
+"or-relation match":
+  "'A' or 'B'":
+    match:
+      - "A"
+      - "B"
+    unmatch:
+      - "AB"
+      - "BA"
+
+"or-relation match with wildcard":
+  "'*.a' or '*.b'":
+    match:
+      - "1.a" # first pattern match
+      - "1.b" # second pattern match
+    unmatch:
+      - "1.ab"
+      - "1.ba"
+      - ".a" # wildcard needs one or more characters
+      - ".b"

data/test/lang/data/declaration-parser.yml

@@ -0,0 +1,279 @@
+variable_binding_sentence:
+  valid:
+    # simple binding
+    - "$X := true"
+    # bind declarator
+    - "bind $X := true"
+    # variable binding variable
+    - "$X := $Y"
+    # with operator
+    - "$X := 1 + 1"
+    # message with no arguments
+    - "$X := 'a.txt'.str"
+    # message with arguments
+    - "$X := 'a.txt'.suffix(\".res\")"
+    # variable name permits any expressions(but raises model error maybe)
+    - "1 := 1"
+    # split lines
+    - "$V \n := \n 1"
+  invalid:
+    # just variable
+    - "$X"
+    # binding of variable binding
+    - "$X := ($Y := 1)"
+
+package_binding_sentence:
+  valid:
+    # simple
+    - "package $P <- &Package"
+    # with parameter
+    - "package $P <- &Package{X: 1, Y:2}"
+    # with messages
+    - 'package $P <- &Package.editor("A").tag("v1.2.3")'
+    # split lines
+    - "package \n $P \n <- \n &Package"
+  invalid:
+    # no binding values
+    - "package $P"
+    # no variables
+    - "package <- &P"
+
+param_sentence:
+  valid:
+    # simple
+    - "param $X"
+    # simple with default value
+    - "param $X := 1"
+    # implicit basic parameter
+    - "basic param $X"
+    # implicit basic parameter with default value
+    - "basic param $X := 1"
+    # advanced parameter
+    - "advanced param $X"
+    # adevanced parameter with default value
+    - "advanced param $X := 1"
+    # parameter name permits any expressions(but raises model error maybe)
+    - "param 1"
+  invalid:
+    # with invalid variable
+    - "param $"
+    # with block basic modifier
+    - "Basic param $X"
+    # invalid keyword
+    - "basicparam $X"
+    # with block advanced modifier
+    - "Advanced param $X"
+    # invalid keyword
+    - "advancedparam $X"
+
+rule_binding_sentence:
+  valid:
+    # simple alias
+    - "rule A := B"
+    # alias of other package
+    - "rule A := $P.rule(B)"
+    # overload rule in other package
+    - "rule $P.rule(A) := B"
+    # rule name permits any expressions(but raises model error maybe)
+    - "rule 1 := A"
+    # rule value permits any expressions(but raises model error maybe)
+    - "rule A := 1"
+  invalid:
+    # no rule value
+    - "rule A"
+
+constituent_rule_sentence:
+  valid:
+    # simple
+    - "rule X"
+    # variable
+    - "rule $X"
+    # rule expression of other package
+    - "rule $P.rule(A)"
+    # permit any expressions (but raises model error maybe)
+    - "rule 1"
+  invalid:
+    # no rule exprs
+    - "rule"
+    # rule binding
+    - "rule A := B"
+
+input_sentence:
+  valid:
+    # literal
+    - "input 'a.txt'"
+    # wildcard
+    - "input '*.txt'"
+    # with method
+    - "input \"*.txt\".as_data_expr"
+    # with sequence
+    - "input 'a' | 'b' | 'c'"
+    # with variable
+    - "input $X"
+    # with embedded variable
+    - "input '{$I[1][1]}.a'"
+
+output_sentence:
+  valid:
+    # literal
+    - "output 'a.txt'"
+    # wildcard
+    - "output '*.txt'"
+    # with method
+    - "output \"*.txt\".as_data_expr"
+    # with sequence
+    - "output 'a' | 'b' | 'c'"
+    # with variable
+    - "output $X"
+    # with embedded variable
+    - "output '{$I[1][1]}.a'"
+
+feature_sentence:
+  valid:
+    # feature expressions
+    - "feature +A"
+    - "feature -A"
+    - "feature ?A"
+    # with message
+    - "feature \"A\".as_requisite_feature"
+    # permits any expression, but raises model error maybe
+    - "feature 1"
+  invalid:
+    # no feature expressions
+    - "feature"
+    # invalid expressions
+    - "feature +"
+
+constraint_sentence:
+  valid:
+    # with conditions
+    - "constraint $X.odd?"
+    # permits any expressions, but raises model error maybe
+    - "constraint 1"
+  invalid:
+    # with no expressions
+    - "constraint"
+
+annotation_sentence:
+  valid:
+    # with annotation expression
+    - ".@ author :: \"Keita Yamaguchi\""
+    # permits any expressions, but raises model error maybe
+    - ".@ 1"
+  invalid:
+    # with no expressions
+    - ".@"
+
+expr_sentence:
+  valid:
+    # with declarator
+    - "? 1"
+    # with no declarator
+    - "1"
+
+param_block:
+  valid:
+    - | # empty block
+      Param
+      End
+    - | # one line block
+      Param
+        $X := 1
+      End
+    - | # multi line block
+      Param
+        $X := 1
+        $Y := 2
+        $Z := 3
+      End
+    - | # multi line with empty line
+      Param
+        $X := 1
+        
+        $Y := 2
+      End
+    - | # one line with comment
+      Param
+        # param $X := 1
+        $X := 1
+      End
+    - | # multi line with comments
+      Param
+        # param $X := 1
+        $X := 1
+        # param $Y := 2
+        $Y := 2
+        # param $Z := 3
+        $Z := 3
+      End
+    - | # basic param block
+      Basic Param
+        $X := 1
+        $Y := 2
+        $Z := 3
+      End
+    - | # advanced param block
+      Advanced Param
+        $X := 1
+        $Y := 2
+        $Z := 3
+      End
+
+flow_rule_block:
+  valid:
+    - | # simple flow rule
+      Rule Test
+        input '*.a'
+        output '*.b'
+      Flow
+        rule Test1
+      End
+    - |
+      Rule Test
+        input '*.a'
+        output '{$I[1][1]}.b'
+      Flow
+        rule TestA
+        rule TestB
+      End
+    - |
+      Rule Test
+        output 'test.txt'
+        param $N := 1
+      Flow
+        rule TestA
+      End
+
+action_rule_block:
+  valid:
+    - | # simple action rule
+      Rule Test
+        input '*.a'
+        output '*.b'
+      Action
+        echo "a"
+      End
+    - |
+      Rule Test
+        input  '*.a'
+        output '{$I[1][1]}.b'
+      Action
+        echo "test" > {$O[1].NAME}
+      End
+
+empty_rule_block:
+  valid:
+    - | # simple empty rule
+      Rule Test
+        input '*.a'
+        output '*.a'.update
+      End
+    - | # empty rule with parameters
+      Rule Test
+        input '*.a'
+        output '*.a'.update
+        param $X := 1
+        basic param $Y := 2
+        advanced param $Z := 3
+      End
+