pione 0.2.2 → 0.3.0

data/test/lang/data/parameter-set.yml

@@ -0,0 +1,14 @@
+"==":
+  - "true"  : "{A: 1} == {A: 1}"
+  - "false" : "{A: 1} == {A: 2}"
+  - "false" : "{A: 1} == {B: 1}"
+
+"!=":
+  - "false" : "{A: 1} != {A: 1}"
+  - "true"  : "{A: 1} != {A: 2}"
+  - "true"  : "{A: 1} != {B: 1}"
+
+"+":
+  - "{A: 1, B: 2}" : "{A: 1} + {B: 2}"
+  - "{A: 2}" : "{A: 1} + {A: 2}"
+

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

@@ -0,0 +1,27 @@
+"==":
+  - "true" : "Main == Main"
+  - "false" : "Main == Count"
+
+"!=":
+  - "true" : "Main != Count"
+  - "false" : "Main != Main"
+
+"param":
+  - "Main {N: 1}" : "Main.param({N: 1})"
+  - "Main {N: 2}" : "Main.param({N: 1}).param({N: 2})"
+  - "Main {B: 1}" : "Main.param({A: 1}).param({B: 1})"
+
+"==>":
+  - "<T>" : "(A ==> <T>).output_tickets"
+  - "<T1> | <T2>" : "(A ==> (<T1> | <T2>)).output_tickets"
+  - "<T>" : "((A | B) ==> <T>)[1].output_tickets"
+  - "<T>" : "((A | B) ==> <T>)[2].output_tickets"
+
+">>>":
+  - "2" : "(A >>> B).length"
+  - "0" : "(A >>> B)[1].input_tickets.length"
+  - "1" : "(A >>> B)[1].output_tickets.length"
+  - "1" : "(A >>> B)[2].input_tickets.length"
+  - "0" : "(A >>> B)[2].output_tickets.length"
+  # generate each ticket for each pairs
+  - "false" : "(A >>> B)[1].output_tickets == (A >>> B)[2].input_tickets"

data/test/lang/data/sequence.yml

@@ -0,0 +1,66 @@
+"#type":
+  - '"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)'
+
+"#empty?":
+  # literal for empty sequences don't not exist now
+  - 'false' : '(1 | 2 | 3).empty?'
+  - 'false' : '(1 | 2).empty?'
+  - 'false' : '1.empty?'
+
+"#reverse":
+  - '3 | 2 | 1' : '(1 | 2 | 3).reverse'
+  - '1' : '1.reverse'
+

data/test/lang/data/string.yml

@@ -0,0 +1,92 @@
+"#==, #!=":
+  - 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)'
+
+"#nth":
+  - '"abc"' : '"abc".nth(1)'
+  - '"a"' : '("a" | "b" | "c").nth(1)'
+  - '"b"' : '("a" | "b" | "c").nth(2)'
+  - '"c"' : '("a" | "b" | "c").nth(3)'
+
+"#[]":
+  - '"abc"' : '"abc"[1]'
+  - '"a"' : '("a" | "b" | "c")[1]'
+  - '"b"' : '("a" | "b" | "c")[2]'
+  - '"c"' : '("a" | "b" | "c")[3]'
+
+"#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/lang/spec_boolean.rb

@@ -0,0 +1,5 @@
+require 'pione/test-helper'
+
+describe 'Pione::Lang::PioneBoolean' do
+  TestHelper::Lang.test_pione_method(__FILE__)
+end

data/test/{parser → lang}/spec_common-parser.rb

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
-require_relative '../test-util'
+require 'pione/test-helper'
 
 class TestParser < Parslet::Parser
-  include Pione::Parser::CommonParser
+  include Pione::Lang::CommonParser
 
   rule(:test_line_end) {
     str('begin') >> line_end >> str('end')
@@ -28,7 +28,7 @@ end
 describe 'Pione::Parser::CommonParser' do
   describe 'symbols' do
     it 'should parse symbols' do
-      Parser::CommonParser::SYMBOLS.values.each do |val|
+      Lang::CommonParser::SYMBOLS.values.each do |val|
         should.not.raise(Parslet::ParseFailed) do
           TestParser.new.symbols.parse(val)
         end
@@ -46,7 +46,7 @@ describe 'Pione::Parser::CommonParser' do
 
   describe 'keywords' do
     it 'should parse keywords' do
-      Parser::CommonParser::KEYWORDS.each do |key, val|
+      Lang::CommonParser::KEYWORDS.each do |key, val|
         should.not.raise(Parslet::ParseFailed) do
           TestParser.new.send(key).parse(val)
         end
@@ -55,7 +55,7 @@ describe 'Pione::Parser::CommonParser' do
 
     it 'should fail with other words' do
       words = ['abc', '', 'RULE', 'enD', 'Input']
-      Parser::CommonParser::KEYWORDS.keys.each do |key|
+      Lang::CommonParser::KEYWORDS.keys.each do |key|
         words.each do |word|
           should.raise(Parslet::ParseFailed) do
             TestParser.new.send(key).parse(word)
@@ -65,32 +65,6 @@ describe 'Pione::Parser::CommonParser' do
     end
   end
 
-  describe 'digit' do
-    it 'should parse digit' do
-      (0..9).each do |n|
-        should.not.raise(Parslet::ParseFailed) do
-          TestParser.new.digit.parse(n.to_s)
-        end
-      end
-    end
-
-    it 'should fail with number sequences' do
-      (10..100).each do |n|
-        should.raise(Parslet::ParseFailed) do
-          TestParser.new.digit.parse(n.to_s)
-        end
-      end
-    end
-
-    it 'should fail with other characters' do
-      ('a'..'z').each do |char|
-        should.raise(Parslet::ParseFailed) do
-          TestParser.new.digit.parse(char)
-        end
-      end
-    end
-  end
-
   describe 'space / space?' do
     it 'should parse space string' do
       strings = [' ', '  ', "\t", "\t\t", " \t ", "\t \t"]
@@ -270,7 +244,7 @@ describe 'Pione::Parser::CommonParser' do
     end
 
     it 'should fail in test_empty_lines_4' do
-      strings = [ "item item", "item "]
+      strings = ["item item", "item i"]
       strings.each do |s|
         should.raise(Parslet::ParseFailed) do
           TestParser.new.test_empty_lines_4.parse(s)
@@ -278,4 +252,8 @@ describe 'Pione::Parser::CommonParser' do
       end
     end
   end
+
+  TestHelper::Parser.spec(__FILE__, self)
 end
+
+

data/test/lang/spec_conditional-branch-parser.rb

@@ -0,0 +1,5 @@
+require 'pione/test-helper'
+
+describe 'Pione::Parser::ConditionalBranchParser' do
+  TestHelper::Parser.spec(__FILE__, self)
+end

data/test/lang/spec_conditional-branch-transformer.rb

@@ -0,0 +1,97 @@
+require 'pione/test-helper'
+
+describe 'Pione::Transformer::ConditionalBranchTransformer' do
+  transformer_spec("if_branch", :if_branch) do
+    # simple branch
+    test(<<-STRING) do |branch|
+      if $x == 1
+        $y := 1
+      else
+        $y := 2
+      end
+    STRING
+      branch.should.kind_of Lang::IfBranch
+      branch.pos.should.not.nil
+      branch.expr.should == TestHelper::Lang.expr("$x == 1")
+      branch.true_context.should.kind_of Lang::ConditionalBranchContext
+      branch.true_context.elements.size.should == 1
+      branch.true_context.elements[0].should == TestHelper::Lang.declaration("$y := 1")
+      branch.else_context.should.kind_of Lang::ConditionalBranchContext
+      branch.else_context.elements.size.should == 1
+      branch.else_context.elements[0].should == TestHelper::Lang.declaration("$y := 2")
+    end
+
+    # without else-context
+    test(<<-STRING) do |branch|
+      if $x == 1
+        $y := 1
+      end
+    STRING
+      branch.should.kind_of Lang::IfBranch
+      branch.pos.should.not.nil
+      branch.expr.should == TestHelper::Lang.expr("$x == 1")
+      branch.true_context.should.kind_of Lang::ConditionalBranchContext
+      branch.true_context.elements.size.should == 1
+      branch.true_context.elements[0].should == TestHelper::Lang.declaration("$y := 1")
+      branch.else_context.should.kind_of Lang::ConditionalBranchContext
+      branch.else_context.elements.size.should == 0
+    end
+  end
+
+  transformer_spec("case_branch", :case_branch) do
+    # simple case branch
+    test(<<-STRING) do |branch|
+      case $x
+      when 1
+        $y := 1
+      when 2
+        $y := 2
+      else
+        $y := 3
+      end
+    STRING
+      branch.should.kind_of Lang::CaseBranch
+      branch.pos.should.not.nil
+      branch.expr.should == TestHelper::Lang.expr("$x")
+      branch.when_contexts.should.kind_of Array
+      branch.when_contexts.size.should == 2
+      branch.when_contexts[0][0].should == TestHelper::Lang.expr("1")
+      branch.when_contexts[0][1].should.kind_of Lang::ConditionalBranchContext
+      branch.when_contexts[0][1].elements.size.should == 1
+      branch.when_contexts[0][1].elements[0].should == TestHelper::Lang.declaration("$y := 1")
+      branch.when_contexts[1][0].should == TestHelper::Lang.expr("2")
+      branch.when_contexts[0][1].should.kind_of Lang::ConditionalBranchContext
+      branch.when_contexts[1][1].elements.size.should == 1
+      branch.when_contexts[1][1].elements[0].should == TestHelper::Lang.declaration("$y := 2")
+      branch.else_context.should.kind_of Lang::ConditionalBranchContext
+      branch.else_context.elements.size.should == 1
+      branch.else_context.elements[0].should == TestHelper::Lang.declaration("$y := 3")
+    end
+
+    # without else context
+    test(<<-STRING) do |branch|
+      case $x
+      when 1
+        $y := 1
+      when 2
+        $y := 2
+      end
+    STRING
+      branch.should.kind_of Lang::CaseBranch
+      branch.pos.should.not.nil
+      branch.expr.should == TestHelper::Lang.expr("$x")
+      branch.when_contexts.should.kind_of Array
+      branch.when_contexts.size.should == 2
+      branch.when_contexts[0][0].should == TestHelper::Lang.expr("1")
+      branch.when_contexts[0][1].should.kind_of Lang::ConditionalBranchContext
+      branch.when_contexts[0][1].elements.size.should == 1
+      branch.when_contexts[0][1].elements[0].should == TestHelper::Lang.declaration("$y := 1")
+      branch.when_contexts[1][0].should == TestHelper::Lang.expr("2")
+      branch.when_contexts[0][1].should.kind_of Lang::ConditionalBranchContext
+      branch.when_contexts[1][1].elements.size.should == 1
+      branch.when_contexts[1][1].elements[0].should == TestHelper::Lang.declaration("$y := 2")
+      branch.else_context.should.kind_of Lang::ConditionalBranchContext
+      branch.else_context.elements.size.should == 0
+    end
+  end
+end

data/test/lang/spec_conditional-branch.rb

@@ -0,0 +1,176 @@
+require 'pione/test-helper'
+
+describe "Pione::Lang::IfBranch" do
+  before do
+    @branch = TestHelper::Lang.conditional_branch(<<-STRING)
+      if $x == 1
+        $y := 1
+      else
+        $y := 2
+      end
+    STRING
+
+    @branch_without_else = TestHelper::Lang.conditional_branch(<<-STRING)
+      if $x == 1
+        $y := 1
+      end
+    STRING
+
+    @fake_branch = TestHelper::Lang.conditional_branch(<<-STRING)
+      if true
+        $y := 1
+      else
+        $y := 2
+      end
+    STRING
+
+    @invalid_branch = TestHelper::Lang.conditional_branch(<<-STRING)
+      if 1
+        $y := 1
+      else
+        $y := 2
+      end
+    STRING
+  end
+
+  it "should get expr" do
+    @branch.expr.should == TestHelper::Lang.expr("$x == 1")
+  end
+
+  it "shold get true-context" do
+    @branch.true_context.should.kind_of Lang::ConditionalBranchContext
+    @branch.true_context.elements.size.should == 1
+    @branch.true_context.elements[0].should == TestHelper::Lang.declaration("$y := 1")
+  end
+
+  it "shold get else-context" do
+    @branch.else_context.should.kind_of Lang::ConditionalBranchContext
+    @branch.else_context.elements.size.should == 1
+    @branch.else_context.elements[0].should == TestHelper::Lang.declaration("$y := 2")
+
+    # if branch has no else context, we expect to get an empty context
+    @branch_without_else.else_context.should.kind_of Lang::ConditionalBranchContext
+    @branch_without_else.else_context.elements.size.should == 0
+  end
+
+  it "should validate inner contexts" do
+    # acceptable
+    should.not.raise(Lang::ContextError) do
+      @branch.validate([Lang::VariableBindingDeclaration])
+    end
+
+    # unacceptable
+    should.raise(Lang::ContextError) do
+      @branch.validate([Lang::PackageBindingDeclaration])
+    end
+  end
+
+  it "should evaluate and return suitable context" do
+    env1 = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(env1, "$x := 1")
+
+    env2 = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(env2, "$x := 2")
+
+    # branch
+    @branch.eval(env1).should == @branch.true_context
+    @branch.eval(env2).should == @branch.else_context
+
+    # branch without else context
+    @branch_without_else.eval(env1).should == @branch_without_else.true_context
+    @branch_without_else.eval(env2).should == @branch_without_else.else_context
+
+    # fake branch
+    @fake_branch.eval(env1).should == @fake_branch.true_context
+    @fake_branch.eval(env2).should == @fake_branch.true_context
+  end
+
+  it "should raise structural error when condition is not boolean" do
+    should.raise(Lang::StructuralError) do
+      @invalid_branch.eval(TestHelper::Lang.env)
+    end
+  end
+end
+
+describe "Pione::Lang::CaseBranch" do
+  before do
+    @branch = TestHelper::Lang.conditional_branch(<<-STRING)
+      case $x
+      when 1
+        $y := 1
+      when 2
+        $y := 2
+      else
+        $y := 3
+      end
+    STRING
+
+    @branch_without_else = TestHelper::Lang.conditional_branch(<<-STRING)
+      case $x
+      when 1
+        $y := 1
+      when 2
+        $y := 2
+      end
+    STRING
+
+    @sequential = TestHelper::Lang.conditional_branch(<<-STRING)
+      case $x
+      when 1 | 2 | 3
+        $y := 1
+      when (1 | 2 | 3).all
+        $y := 2
+      else
+        $y := 3
+      end
+    STRING
+  end
+
+  it "should get expr" do
+    @branch.expr.should == TestHelper::Lang.expr("$x")
+  end
+
+  it "should get when_contexts" do
+    @branch.when_contexts.size.should == 2
+  end
+
+  it "should get else context" do
+    @branch.else_context.should == TestHelper::Lang.conditional_branch_context("$y := 3")
+  end
+
+  it "should get contexts" do
+    env1 = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(env1, "$x := 1")
+
+    env2 = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(env2, "$x := 2")
+
+    env3 = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(env3, "$x := 3")
+
+    env4 = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(env4, "$x := 1 | 2 | 3")
+
+    env5 = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(env5, "$x := (1 | 2 | 3).all")
+
+    @branch.eval(env1).should == @branch.when_contexts[0][1]
+    @branch.eval(env2).should == @branch.when_contexts[1][1]
+    @branch.eval(env3).should == @branch.else_context
+    @branch.eval(env4).should == @branch.when_contexts[0][1]
+    @branch.eval(env5).should == @branch.else_context
+
+    @branch_without_else.eval(env1).should == @branch_without_else.when_contexts[0][1]
+    @branch_without_else.eval(env2).should == @branch_without_else.when_contexts[1][1]
+    @branch_without_else.eval(env3).should == Lang::ConditionalBranchContext.new([])
+    @branch_without_else.eval(env4).should == @branch_without_else.when_contexts[0][1]
+    @branch_without_else.eval(env5).should == Lang::ConditionalBranchContext.new([])
+
+    @sequential.eval(env1).should == @sequential.when_contexts[0][1]
+    @sequential.eval(env2).should == @sequential.when_contexts[0][1]
+    @sequential.eval(env3).should == @sequential.when_contexts[0][1]
+    @sequential.eval(env4).should == @sequential.when_contexts[0][1]
+    @sequential.eval(env5).should == @sequential.when_contexts[1][1]
+  end
+end
+