pione 0.2.2 → 0.3.0

data/test/lang/spec_document-parser.rb

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

data/test/lang/spec_document-transformer.rb

@@ -0,0 +1,10 @@
+require 'pione/test-helper'
+
+describe 'Pione::Transformer::DocumentTransformer' do
+  it "should transform" do
+    parser = Pione::Lang::DocumentParser.new.parse("$X := 1")
+    opts = {package_name: "Test", filename: "Test"}
+    context = Pione::Lang::DocumentTransformer.new.apply(parser, opts)
+    context.should.kind_of(Lang::PackageContext)
+  end
+end

data/test/lang/spec_environment.rb

@@ -0,0 +1,129 @@
+require 'pione/test-helper'
+
+describe 'Pione::Lang::Environment' do
+  before do
+    @env = TestHelper::Lang.env
+  end
+
+  it 'should update variable table' do
+    # declare a variable in current package
+    TestHelper::Lang.declaration!(@env, "$x := 1")
+
+    # declare a variable in other package
+    TestHelper::Lang.declaration!(@env, "package $p <- &Test")
+    TestHelper::Lang.declaration!(@env, "$p.var($y) := 2")
+
+    # test
+    TestHelper::Lang.expr!(@env, "$x").should == Lang::IntegerSequence.of(1)
+    TestHelper::Lang.expr!(@env, "$p.var($y)").should  == Lang::IntegerSequence.of(2)
+  end
+
+  it 'should append new package' do
+    # append a package
+    TestHelper::Lang.declaration!(@env, "package $p <- &Test")
+
+    # test
+    child_id = @env.variable_get(Lang::Variable.new("p")).pieces.first.package_id
+    definition = @env.package_get(Lang::PackageExpr.new(package_id: child_id))
+    definition.parent_ids.should == [@env.current_package_id]
+  end
+
+  it 'should delegate to find variable' do
+    # create a new package
+    TestHelper::Lang.declaration!(@env, "package $p <- &Test")
+
+    # bind variables in the parent package
+    TestHelper::Lang.declaration!(@env, "$x := 1")
+
+    # test
+    TestHelper::Lang.expr!(@env, "$x").should == Lang::IntegerSequence.of(1)
+    TestHelper::Lang.expr!(@env, "$p.var($x)").should == Lang::IntegerSequence.of(1)
+  end
+
+  it 'should override parent variable by the child' do
+    # bind package
+    TestHelper::Lang.declaration!(@env, "package $p <- &Test")
+
+    # bind variables
+    TestHelper::Lang.declaration!(@env, "$x := 1")
+    TestHelper::Lang.declaration!(@env, "$p.var($x) := 2")
+
+    # test
+    TestHelper::Lang.expr!(@env, "$x").should == Lang::IntegerSequence.of(1)
+    TestHelper::Lang.expr!(@env, "$p.var($x)").should == Lang::IntegerSequence.of(2)
+  end
+
+  it "should get rule" do
+    TestHelper::Lang.package_context!(@env, <<-CONTEXT)
+      Rule R1
+        input '*.i'
+        output '{$*}.o'.touch
+        param $X := 1
+      End
+
+      rule R2 := R1 {X: 2}
+    CONTEXT
+
+    # test
+    r1 = @env.rule_get(Lang::RuleExpr.new("R1"))
+    r2 = @env.rule_get(Lang::RuleExpr.new("R2"))
+    r1.rule_condition_context.should == r2.rule_condition_context
+    r1.param_sets.should == TestHelper::Lang.expr!(@env, "{}")
+    r2.param_sets.should == TestHelper::Lang.expr!(@env, "{X: 2}")
+  end
+
+  it 'should delegate to find rule' do
+    TestHelper::Lang.package_context!(@env, <<-CONTEXT)
+      package $p <- &Test
+
+      Rule R1
+        input '*.i'
+        output '{$*}.o'.touch
+        param $X := 1
+      End
+
+      rule R2 := R1 {X: 2}
+    CONTEXT
+
+    # test
+    r1 = @env.rule_get(Lang::RuleExpr.new("R1"))
+    pr1 = @env.rule_get(TestHelper::Lang.expr!(@env, "$p.rule(R1)").pieces.first)
+    pr2 = @env.rule_get(TestHelper::Lang.expr!(@env, "$p.rule(R2)").pieces.first)
+    pr1.rule_condition_context.should == r1.rule_condition_context
+    pr2.rule_condition_context.should == r1.rule_condition_context
+    pr1.param_sets.should == TestHelper::Lang.expr!(@env, "{}")
+    pr2.param_sets.should == TestHelper::Lang.expr!(@env, "{X: 2}")
+  end
+
+  it 'should override parent rule by the child' do
+    TestHelper::Lang.package_context!(@env, <<-CONTEXT)
+      package $p <- &Test
+
+      Rule R
+        input '*.i'
+        output '{$*}.o'.touch
+        param $X := 1
+      End
+
+      rule R1 := R {X: 2}
+
+      Rule $p.rule(R)
+        input '*.i'
+        output '{$*}.o'.touch
+        param $X := 3
+      End
+
+      rule $p.rule(R1) := $p.rule(R) {X: 4}
+    CONTEXT
+
+    # test
+    r = @env.rule_get(Lang::RuleExpr.new("R"))
+    pr = @env.rule_get(TestHelper::Lang.expr!(@env, "$p.rule(R)").pieces.first)
+    pr1 = @env.rule_get(TestHelper::Lang.expr!(@env, "$p.rule(R1)").pieces.first)
+    pr.rule_condition_context.should != r.rule_condition_context
+    pr1.rule_condition_context.should != r.rule_condition_context
+    pr.param_sets.should == TestHelper::Lang.expr!(@env, "{}")
+    pr1.param_sets.should == TestHelper::Lang.expr!(@env, "{X: 4}")
+  end
+end
+

data/test/lang/spec_expr-parser.rb

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

data/test/lang/spec_expr-transformer.rb

@@ -0,0 +1,149 @@
+require 'pione/test-helper'
+
+$a = Lang::PioneString.new("a")
+$b = Lang::PioneString.new("b")
+$c = Lang::PioneString.new("c")
+$abc = Lang::PioneString.new("abc")
+$var_x = Lang::Variable.new("X")
+$var_y = Lang::Variable.new("Y")
+$var_z = Lang::Variable.new("Z")
+
+describe 'Pione::Transformer::ExprTransformer' do
+  transformer_spec("binary operator", :expr) do
+    test "1 + 2" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "+"
+      msg.receiver.should == Lang::IntegerSequence.of(1)
+      msg.arguments.size.should == 1
+      msg.arguments[0].should == Lang::IntegerSequence.of(2)
+    end
+
+    test '"a" + "b"' do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "+"
+      msg.receiver.should == Lang::StringSequence.new([$a])
+      msg.arguments.size.should == 1
+      msg.arguments[0].should == Lang::StringSequence.new([$b])
+    end
+
+    test "false || true" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "||"
+      msg.receiver.should == Lang::BooleanSequence.of(false)
+      msg.arguments.size.should == 1
+      msg.arguments[0].should == Lang::BooleanSequence.of(true)
+    end
+
+    test "$X * 3" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "*"
+      msg.receiver.should == $var_x
+      msg.arguments.size.should == 1
+      msg.arguments[0].should == Lang::IntegerSequence.of(3)
+    end
+
+    test "($X == \"a\") && ($Y == \"b\")" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "&&"
+      msg.receiver.should == Lang::Message.new("==", $var_x, [Lang::StringSequence.new([$a])])
+      msg.arguments.size.should == 1
+      msg.arguments[0].should == Lang::Message.new("==", $var_y, [Lang::StringSequence.new([$b])])
+    end
+  end
+
+  transformer_spec("message", :expr) do
+    test "1.next" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "next"
+      msg.receiver.should == Lang::IntegerSequence.of(1)
+      msg.arguments.should.empty
+    end
+
+    test "1.next.next" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "next"
+      msg.receiver.tap do |rec|
+        rec.should.kind_of Lang::Message
+        rec.name.should == "next"
+        rec.receiver.should == Lang::IntegerSequence.of(1)
+        rec.arguments.should.empty
+      end
+      msg.arguments.should.empty
+    end
+
+    test "\"abc\".index(1,1)" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "index"
+      msg.receiver.should == Lang::StringSequence.new([$abc])
+      msg.arguments.size.should == 2
+      msg.arguments[0].should == Lang::IntegerSequence.of(1)
+      msg.arguments[1].should == Lang::IntegerSequence.of(1)
+    end
+
+    test "(1 + 2).prev" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "prev"
+      msg.receiver.tap do |rec|
+        rec.should.kind_of Lang::Message
+        rec.name.should == "+"
+        rec.receiver.should == Lang::IntegerSequence.of(1)
+        rec.arguments.size.should == 1
+        rec.arguments[0].should == Lang::IntegerSequence.of(2)
+      end
+      msg.arguments.should.empty
+    end
+
+    test "Test.as_string" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "as_string"
+      msg.receiver.should == Lang::RuleExprSequence.of("Test")
+      msg.arguments.should.empty
+    end
+
+    test "'*.txt'.all" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "all"
+      msg.receiver.should == Lang::DataExprSequence.of("*.txt")
+      msg.arguments.should.empty
+    end
+
+    test "'*.txt'.all()" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "all"
+      msg.receiver.should == Lang::DataExprSequence.of("*.txt")
+      msg.arguments.should.empty
+    end
+
+    test "'*.txt'.all(true)" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "all"
+      msg.receiver.should == Lang::DataExprSequence.of("*.txt")
+      msg.arguments.size.should == 1
+      msg.arguments[0].should == Lang::BooleanSequence.of(true)
+    end
+
+    test "$var[1]" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "[]"
+      msg.receiver.should == Lang::Variable.new("var")
+      msg.arguments.size.should == 1
+      msg.arguments[0].should == Lang::IntegerSequence.of(1)
+    end
+
+    test "$var[1, 2]" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "[]"
+      msg.receiver.should == Lang::Variable.new("var")
+      msg.arguments.size.should == 2
+      msg.arguments[0].should == Lang::IntegerSequence.of(1)
+      msg.arguments[1].should == Lang::IntegerSequence.of(2)
+    end
+
+    test "not :: true" do |msg|
+      msg.should.kind_of Lang::Message
+      msg.name.should == "not"
+      msg.receiver.should == Lang::BooleanSequence.of(true)
+      msg.arguments.should.empty
+    end
+  end
+end

data/test/lang/spec_feature-expr.rb

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

data/test/lang/spec_float.rb

@@ -0,0 +1,23 @@
+require 'pione/test-helper'
+
+describe 'Pione::Lang::PioneFloat' do
+  before do
+    @one = Lang::PioneFloat.new(1.0)
+    @two = Lang::PioneFloat.new(2.0)
+  end
+
+  it 'should get a ruby object that has same value' do
+    @one.value.should == 1.0
+  end
+
+  it 'should equal' do
+    @one.should == Lang::PioneFloat.new(1.0)
+  end
+
+  it 'should not equal' do
+    @one.should.not == Lang::PioneFloat.new(2.0)
+    @one.should.not == Lang::PioneInteger.new(1)
+  end
+
+  TestHelper::Lang.test_pione_method(__FILE__)
+end

data/test/lang/spec_integer.rb

@@ -0,0 +1,29 @@
+require 'pione/test-helper'
+
+describe 'Pione::Lang::PioneInteger' do
+  before do
+    @zero = Lang::PioneInteger.new(0)
+    @one = Lang::PioneInteger.new(1)
+    @two = Lang::PioneInteger.new(2)
+  end
+
+  it 'should get a ruby object that has same value' do
+    @zero.value.should == 0
+    @one.value.should == 1
+    @two.value.should == 2
+  end
+
+  it 'should equal' do
+    @zero.should == Lang::PioneInteger.new(0)
+    @one.should == Lang::PioneInteger.new(1)
+    @two.should == Lang::PioneInteger.new(2)
+  end
+
+  it 'should not equal' do
+    @zero.should.not == Lang::PioneBoolean.new(false)
+    @one.should.not == Lang::PioneInteger.new(2)
+    @one.should.not == Lang::PioneFloat.new(1.0)
+  end
+
+  TestHelper::Lang.test_pione_method(__FILE__)
+end

data/test/lang/spec_interpolator-parser.rb

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

data/test/lang/spec_interpolator-transformer.rb

@@ -0,0 +1,15 @@
+require 'pione/test-helper'
+
+describe 'Pione::Transformer::InterpolatorTransformer' do
+  opts = {
+    parser_class: Lang::InterpolatorParser,
+    transformer_class: Lang::InterpolatorTransformer
+  }
+
+  transformer_spec("embeded_variable", :embeded_variable, opts) do
+    test("{$x}", TestHelper::Lang.expr("$x"))
+    test("{$x.as_string}", TestHelper::Lang.expr("$x.as_string"))
+    test("{$x.m(A, 1, true)}", TestHelper::Lang.expr("$x.m(A, 1, true)"))
+    test("{$x + $y}", TestHelper::Lang.expr("$x + $y"))
+  end
+end

data/test/lang/spec_keyed-sequence.rb

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

data/test/lang/spec_literal-parser.rb

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

data/test/lang/spec_literal-transformer.rb

@@ -0,0 +1,111 @@
+require 'pione/test-helper'
+
+describe 'Pione::Transformer::LiteralTransformer' do
+  transformer_spec('boolean', :boolean) do
+    # literal true
+    test('true', Lang::BooleanSequence.of(true))
+
+    # literal false
+    test('false', Lang::BooleanSequence.of(false))
+  end
+
+  transformer_spec('string', :string) do
+    test('"abc"', Lang::StringSequence.of('abc'))
+    test('"a\bc"', Lang::StringSequence.of('abc'))
+    test('"a\'"', Lang::StringSequence.of('a\''))
+    test('"a\""', Lang::StringSequence.of('a"'))
+  end
+
+  transformer_spec('integer', :integer) do
+    test('1', Lang::IntegerSequence.of(1))
+    test('123', Lang::IntegerSequence.of(123))
+    test('01', Lang::IntegerSequence.of(1))
+    test('000123', Lang::IntegerSequence.of(123))
+    test('-1', Lang::IntegerSequence.of(-1))
+    test('-01', Lang::IntegerSequence.of(-1))
+    test('+1', Lang::IntegerSequence.of(1))
+    test('+01', Lang::IntegerSequence.of(1))
+  end
+
+  transformer_spec('float', :float) do
+    test('0.1', Lang::FloatSequence.of(0.1))
+    test('123.1', Lang::FloatSequence.of(123.1))
+    test('01.23', Lang::FloatSequence.of(1.23))
+    test('000123.456', Lang::FloatSequence.of(123.456))
+    test('-1.2', Lang::FloatSequence.of(-1.2))
+    test('-01.1', Lang::FloatSequence.of(-1.1))
+    test('+1.9', Lang::FloatSequence.of(1.9))
+    test('+01.8', Lang::FloatSequence.of(1.8))
+  end
+
+  transformer_spec('variable', :variable) do
+    test("$Var", Lang::Variable.new('Var'))
+    test("$var", Lang::Variable.new('var'))
+  end
+
+  transformer_spec("data_expr", :expr) do
+    # literal data expression
+    test("'test.a'", Lang::DataExprSequence.of("test.a"))
+
+    # wildcard
+    test("'*.a'", Lang::DataExprSequence.of("*.a"))
+
+    # with escape
+    test("'a\\bc'", Lang::DataExprSequence.of('abc'))
+
+    # sigle quote with escape
+    test("'a\\''", Lang::DataExprSequence.of("a'"))
+
+    # double quote with escape
+    test("'a\\\"'", Lang::DataExprSequence.of("a\""))
+
+    # null
+    test("null", Lang::DataExprSequence.of(Lang::DataExprNull.new))
+  end
+
+  transformer_spec('package_expr', :package_expr) do
+    test("&abc", Lang::PackageExprSequence.of('abc'))
+    test("&ABC", Lang::PackageExprSequence.of('ABC'))
+  end
+
+  transformer_spec('rule_expr', :rule_expr) do
+    test("abc", Lang::RuleExprSequence.of("abc"))
+  end
+
+  transformer_spec('ticket_expr', :ticket_expr) do
+    test("<T>", Lang::TicketExprSequence.of("T"))
+    test("<t>", Lang::TicketExprSequence.of("t"))
+  end
+
+  transformer_spec("parameters", :expr) do
+    test("{}", Lang::ParameterSetSequence.new)
+
+    test "{X: 1}" do |params|
+      params.should.kind_of Lang::ParameterSetSequence
+      params.pieces.first.table["X"].should == Lang::IntegerSequence.of(1)
+    end
+
+    test "{X: 1, Y: 2}" do |params|
+      params.should.kind_of Lang::ParameterSetSequence
+      params.pieces.first.table["X"].should == Lang::IntegerSequence.of(1)
+      params.pieces.first.table["Y"].should == Lang::IntegerSequence.of(2)
+    end
+
+    test "{X: \"a\", Y: \"b\", Z: \"c\"}" do |params|
+      params.should.kind_of Lang::ParameterSetSequence
+      params.pieces.first.table["X"].should == Lang::StringSequence.of("a")
+      params.pieces.first.table["Y"].should == Lang::StringSequence.of("b")
+      params.pieces.first.table["Z"].should == Lang::StringSequence.of("c")
+    end
+  end
+
+  transformer_spec("feature", :feature) do
+    test('+A', Lang::FeatureSequence.of(Lang::RequisiteFeature.new("A")))
+    test('-A', Lang::FeatureSequence.of(Lang::BlockingFeature.new("A")))
+    test('?A', Lang::FeatureSequence.of(Lang::PreferredFeature.new("A")))
+    test('^A', Lang::FeatureSequence.of(Lang::PossibleFeature.new("A")))
+    test('!A', Lang::FeatureSequence.of(Lang::RestrictiveFeature.new("A")))
+    test('*', Lang::FeatureSequence.of(Lang::EmptyFeature.new))
+    test('**', Lang::FeatureSequence.of(Lang::AlmightyFeature.new))
+  end
+end