pione 0.1.0

data/test/transformer/spec_block-transformer.rb

@@ -0,0 +1,26 @@
+require_relative '../test-util'
+
+describe 'Pione::Transformer::BlockTransformer' do
+  transformer_spec("action_block", :action_block) do
+    tc(<<-STRING) do
+      Action
+        echo "a"
+      End
+    STRING
+      ActionBlock.new("        echo \"a\"\n")
+    end
+  end
+
+  transformer_spec("flow_block", :flow_block) do
+    tc(<<-STRING) do
+      Flow
+        rule Test
+      End
+    STRING
+      FlowBlock.new(
+        CallRule.new(RuleExpr.new(Package.new("main"), "Test"))
+      )
+    end
+
+  end
+end

data/test/transformer/spec_expr-transformer.rb

@@ -0,0 +1,106 @@
+require_relative '../test-util'
+
+describe 'Pione::Transformer::ExprTransformer' do
+  transformer_spec("binary operator", :expr) do
+    tc "1 + 2" do
+      BinaryOperator.new(
+        "+",
+        PioneInteger.new(1),
+        PioneInteger.new(2)
+      )
+    end
+    tc '"a" + "b"' do
+      BinaryOperator.new(
+        "+",
+        PioneString.new("a"),
+        PioneString.new("b")
+      )
+    end
+    tc "false || true" do
+      BinaryOperator.new(
+        "||",
+        PioneBoolean.false,
+        PioneBoolean.true
+      )
+    end
+    tc "$var * 3" do
+      BinaryOperator.new(
+        "*",
+        Variable.new("var"),
+        PioneInteger.new(3)
+      )
+    end
+    tc "($Var1 == \"a\") && ($Var2 == \"b\")" do
+      BinaryOperator.new(
+        "&&",
+        BinaryOperator.new(
+          "==",
+          Variable.new("Var1"),
+          PioneString.new("a")
+        ),
+        BinaryOperator.new(
+          "==",
+          Variable.new("Var2"),
+          PioneString.new("b")
+        )
+      )
+    end
+  end
+
+  transformer_spec("message", :expr) do
+    tc "1.next" do
+      Message.new("next", PioneInteger.new(1))
+    end
+    tc "1.next.next" do
+      Message.new(
+        "next",
+        Message.new("next", PioneInteger.new(1))
+      )
+    end
+    tc "\"abc\".index(1,1)" do
+      Message.new(
+        "index",
+        PioneString.new("abc"),
+        PioneInteger.new(1),
+        PioneInteger.new(1)
+      )
+    end
+    tc "(1 + 2).prev" do
+      Message.new(
+        "prev",
+        BinaryOperator.new(
+          "+",
+          PioneInteger.new(1),
+          PioneInteger.new(2)
+        )
+      )
+    end
+    tc "abc.sync" do
+      Message.new("sync", RuleExpr.new(Package.new("main"), "abc"))
+    end
+    tc "'*.txt'.all" do
+      Message.new("all", DataExpr.new("*.txt"))
+    end
+    tc "'*.txt'.all()" do
+      Message.new("all", DataExpr.new("*.txt"))
+    end
+    tc "'*.txt'.all(true)" do
+      Message.new("all", DataExpr.new("*.txt"), PioneBoolean.true)
+    end
+  end
+
+  transformer_spec("parameters", :expr) do
+    tc "{}" do
+      Parameters.new({})
+    end
+    tc "{var1: 1}" do
+      {"var1" => 1}.to_params
+    end
+    tc "{var1: 1, var2: 2}" do
+      {"var1" => 1, "var2" => 2}.to_params
+    end
+    tc "{var1: \"a\", var2: \"b\", var3: \"c\"}" do
+      {"var1" => "a", "var2" => "b", "var3" => "c"}.to_params
+    end
+  end
+end

data/test/transformer/spec_feature-expr-transformer.rb

@@ -0,0 +1,21 @@
+require_relative '../test-util'
+
+describe 'Pione::Transformer::FeatureExprTransformer' do
+  transformer_spec("feature_expr", :feature_expr) do
+    tc('+A' => Feature::RequisiteExpr.new("A"))
+    tc('-A' => Feature::BlockingExpr.new("A"))
+    tc('?A' => Feature::PreferredExpr.new("A"))
+    tc('^A' => Feature::PossibleExpr.new("A"))
+    tc('!A' => Feature::RestrictiveExpr.new("A"))
+    tc('*' => Feature.empty)
+    tc('@' => Feature.boundless)
+    tc '+A & +B' do
+      Feature::AndExpr.new(Feature::RequisiteExpr.new("A"),
+                           Feature::RequisiteExpr.new("B"))
+    end
+    tc '+A | +B' do
+      Feature::OrExpr.new(Feature::RequisiteExpr.new("A"),
+                          Feature::RequisiteExpr.new("B"))
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+require_relative '../test-util'
+
+describe 'Pione::Transformer::FlowElementTransformer' do
+  transformer_spec("call_rule_line", :call_rule_line) do
+    tc(
+      "rule Test" =>
+      CallRule.new(RuleExpr.new(Package.new("main"), "Test"))
+    )
+    tc(
+      "rule :Test" =>
+      CallRule.new(RuleExpr.new(Package.new("main"), "Test"))
+    )
+    tc(
+      "rule &test:Test" =>
+      CallRule.new(RuleExpr.new(Package.new("test"), "Test"))
+    )
+    tc("rule $var" => CallRule.new(Variable.new("var")))
+  end
+
+  transformer_spec("assignment", :assignment) do
+    tc(
+      "$var := 1" =>
+      Assignment.new(Variable.new("var"), PioneInteger.new(1))
+    )
+    tc(
+      "$a := $b" =>
+      Assignment.new(Variable.new("a"), Variable.new("b"))
+    )
+    tc(
+      "$var := &package:test" =>
+      Assignment.new(
+        Variable.new("var"),
+        RuleExpr.new(Package.new("package"), "test")
+      )
+    )
+  end
+
+  transformer_spec("if_block", :if_block) do
+    tc(<<-STRING) do
+      if $Var == 1
+        rule A
+      end
+    STRING
+      ConditionalBlock.new(
+        BinaryOperator.new(
+          "==",
+          Variable.new("Var"),
+          PioneInteger.new(1)
+        ),
+        { PioneBoolean.true =>
+          FlowBlock.new(
+            CallRule.new(RuleExpr.new(Package.new("main"), "A"))
+          )
+        }
+      )
+    end
+    tc(<<-STRING) do
+      if $Var == "a"
+        rule A
+      else
+        rule B
+      end
+    STRING
+      ConditionalBlock.new(
+        BinaryOperator.new(
+          "==",
+          Variable.new("Var"),
+          PioneString.new("a")
+        ),
+        { PioneBoolean.true =>
+          FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "A"))),
+          :else =>
+          FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "B")))
+        }
+      )
+    end
+    tc(<<-STRING) do
+      if $a
+        if $b
+          rule Test1
+        else
+          rule Test2
+        end
+      else
+        rule Test3
+      end
+    STRING
+      inner_block = FlowBlock.new(
+        ConditionalBlock.new(
+          Variable.new("b"),
+          { PioneBoolean.true =>
+            FlowBlock.new(
+              CallRule.new(RuleExpr.new(Package.new("main"), "Test1"))
+            ),
+            :else =>
+            FlowBlock.new(
+              CallRule.new(RuleExpr.new(Package.new("main"), "Test2"))
+            )
+          }
+        )
+      )
+      ConditionalBlock.new(
+        Variable.new("a"),
+        { PioneBoolean.true => inner_block,
+          :else =>
+          FlowBlock.new(
+            CallRule.new(RuleExpr.new(Package.new("main"), "Test3"))
+          )
+        }
+      )
+    end
+  end
+
+  transformer_spec("case_block", :case_block) do
+    tc(<<-STRING) do
+      case $Var
+      when "a"
+        rule A
+      when "b"
+        rule B
+      when "c"
+        rule C
+      end
+    STRING
+      ConditionalBlock.new(
+        Variable.new("Var"),
+        { PioneString.new("a") =>
+          FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "A"))),
+          PioneString.new("b") =>
+          FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "B"))),
+          PioneString.new("c") =>
+          FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "C")))
+        }
+      )
+    end
+    tc(<<-STRING) do
+      case $Var
+      when "a"
+        rule Test1
+      else
+        rule Test2
+      end
+    STRING
+      ConditionalBlock.new(
+        Variable.new("Var"),
+        { PioneString.new("a") =>
+          FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "Test1"))),
+          :else =>
+          FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("main"), "Test2")))
+        }
+      )
+    end
+  end
+end

data/test/transformer/spec_literal-transformer.rb

@@ -0,0 +1,58 @@
+require_relative '../test-util'
+
+describe 'Pione::Transformer::LiteralTransformer' do
+  transformer_spec('boolean', :boolean) do
+    tc('true' => PioneBoolean.true)
+    tc('false' => 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"'))
+  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))
+  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))
+  end
+
+  transformer_spec('variable', :variable) do
+    tc("$Var" => Variable.new('Var'))
+    tc("$var" => Variable.new('var'))
+  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\""))
+  end
+
+  transformer_spec('package_name', :package_name) do
+    tc("&abc" => Package.new('abc'))
+    tc("&ABC" => Package.new('ABC'))
+  end
+
+  transformer_spec('rule_name', :rule_name) do
+    tc("abc" => RuleExpr.new(Package.new("main"), "abc"))
+  end
+end

data/test/transformer/spec_rule-definition-transformer.rb

@@ -0,0 +1,168 @@
+require_relative '../test-util'
+
+ConditionLine = Transformer::RuleDefinitionTransformer::ConditionLine
+
+describe 'Pione::Transformer::RuleDefinitionTransformer' do
+  transformer_spec("input_line", :input_line) do
+    tc("input '*.txt'") do
+      ConditionLine.new(:input, DataExpr.new("*.txt"))
+    end
+  end
+
+  transformer_spec("output_line", :output_line) do
+    tc("output '*.txt'") do
+      ConditionLine.new(:output, DataExpr.new("*.txt"))
+    end
+  end
+
+  transformer_spec("param_line", :param_line) do
+    tc("param {var: 1}") do
+      ConditionLine.new(:param, {"var" => 1}.to_params)
+    end
+    tc("param {var1: 1, var2: 2}") do
+      ConditionLine.new(:param, {"var1" => 1, "var2" => 2}.to_params)
+    end
+  end
+
+  transformer_spec("feature_line", :feature_line) do
+    tc("feature +A") do
+      ConditionLine.new(
+        :feature,
+        Feature::RequisiteExpr.new("A")
+      )
+    end
+  end
+
+  transformer_spec("rule_definition", :rule_definitions) do
+    tc(<<STRING) do
+Rule Test
+  input  '*.a'
+output '{$INPUT[1].MATCH[1]}.b'
+Action
+echo "test" > {$OUTPUT[1].NAME}
+End
+STRING
+      [ActionRule.new(
+          RuleExpr.new(Package.new("main"), "Test"),
+          RuleCondition.new(
+            [ DataExpr.new('*.a') ],
+            [ DataExpr.new('{$INPUT[1].MATCH[1]}.b') ],
+            Parameters.empty,
+            Feature.empty
+          ),
+          ActionBlock.new("echo \"test\" > {$OUTPUT[1].NAME}\n")
+      )]
+    end
+
+    tc(<<-STRING) do
+      Rule Test
+        input '*.a'
+        output '{$INPUT[1].MATCH[1]}.b'
+      Flow
+      rule TestA
+      rule TestB
+      End
+    STRING
+      [ FlowRule.new(
+          RuleExpr.new(Package.new("main"), "Test"),
+          RuleCondition.new(
+            [ DataExpr.new('*.a') ],
+            [ DataExpr.new('{$INPUT[1].MATCH[1]}.b') ],
+            Parameters.empty,
+            Feature.empty
+          ),
+          FlowBlock.new(
+            CallRule.new(RuleExpr.new(Package.new("main"), "TestA")),
+            CallRule.new(RuleExpr.new(Package.new("main"), "TestB"))
+          )
+      )]
+    end
+
+    tc(<<-STRING) do
+      Rule Main
+        input '*.txt'.except('summary.txt')
+        output 'summary.txt'
+        param {ConvertCharSet: true}
+      Flow
+      if $ConvertCharset
+        rule NKF.params("-w")
+      end
+      rule CountChar
+      rule Summarize
+      End
+    STRING
+      [ FlowRule.new(
+          RuleExpr.new(Package.new("main"), "Main"),
+          RuleCondition.new(
+            [Message.new(
+                "except",
+                DataExpr.new("*.txt"),
+                DataExpr.new("summary.txt"))],
+            [DataExpr.new("summary.txt")],
+            Parameters.new({Variable.new("ConvertCharSet") => PioneBoolean.true}),
+            Feature.empty
+          ),
+          FlowBlock.new(
+            ConditionalBlock.new(
+              Variable.new("ConvertCharset"),
+              { PioneBoolean.true => FlowBlock.new(
+                  CallRule.new(Message.new(
+                      "params",
+                      RuleExpr.new(Package.new("main"), "NKF"),
+                      PioneString.new("-w")
+                  ))
+              )}
+            ),
+            CallRule.new(
+              RuleExpr.new(Package.new("main"), "CountChar")
+            ),
+            CallRule.new(
+              RuleExpr.new(Package.new("main"), "Summarize")
+            )
+          )
+      )]
+    end
+  end
+
+  transformer_spec("rule_definitions", :rule_definitions) do
+    tc(<<-STRING) do
+      Rule TestA
+        input  '*.a'
+        output '{$INPUT[1].MATCH[1]}.b'
+      Action
+      cat {$INPUT[1].NAME} > {$OUTPUT[1].NAME}
+      End
+
+      Rule TestB
+        input  '*.b'
+        output '{$INPUT[1].MATCH[1]}.c'
+      Action
+      cat {$INPUT[1].NAME} > {$OUTPUT[1].NAME}
+      End
+    STRING
+      [
+        ActionRule.new(
+          RuleExpr.new(Package.new("main"), "TestA"),
+          RuleCondition.new(
+            [ DataExpr.new("*.a") ],
+            [ DataExpr.new('{$INPUT[1].MATCH[1]}.b') ],
+            Parameters.empty,
+            Feature.empty
+          ),
+          ActionBlock.new("      cat {$INPUT[1].NAME} > {$OUTPUT[1].NAME}\n")
+        ),
+        ActionRule.new(
+          RuleExpr.new(Package.new("main"), "TestB"),
+          RuleCondition.new(
+            [ DataExpr.new("*.b") ],
+            [ DataExpr.new('{$INPUT[1].MATCH[1]}.c') ],
+            Parameters.empty,
+            Feature.empty
+          ),
+          ActionBlock.new("      cat {$INPUT[1].NAME} > {$OUTPUT[1].NAME}\n")
+        )
+      ]
+    end
+  end
+end
+