gisele 0.5.0 → 0.5.1

data/spec/unit/language/syntax/to_ast/test_seq_st.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe SeqSt, "to_ast" do
-
-    it 'parses as expected' do
-      expr     = "seq Task1 Task2 end"
-      expected = [:seq_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]
-      ast(expr, :seq_st).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_task_call_st.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe TaskCallSt, "to_ast" do
-
-    it 'converts a call as expected' do
-      ast("Diagnosis", :task_call_st).should eq([:task_call_st, "Diagnosis"])
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_task_def.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe TaskDef, "to_ast" do
-
-    it 'parses an explicit definition as expected' do
-      expr = <<-EXPR.strip
-        task Task1
-          fluent diagKnown {}, {}
-          Task2
-        end
-      EXPR
-      expected = \
-        [:task_def, "Task1",
-          [:fluent_def, "diagKnown", [:event_set], [:event_set], nil],
-          [:task_call_st, "Task2"]]
-      ast(expr, :task_def).should eq(expected)
-    end
-
-    it 'uses :nop_st if no statement' do
-      expr = <<-EXPR.strip
-        task Task1
-          fluent diagKnown {}, {}
-        end
-      EXPR
-      expected = \
-        [:task_def, "Task1",
-          [:fluent_def, "diagKnown", [:event_set], [:event_set], nil],
-          [:nop_st]]
-      ast(expr, :task_def).should eq(expected)
-    end
-
-    it 'uses :nop_st when empty' do
-      expr = <<-EXPR.strip
-        task Task1
-        end
-      EXPR
-      expected = \
-        [:task_def, "Task1",
-          [:nop_st]]
-      ast(expr, :task_def).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_trackvar_def.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe TrackvarDef, "to_ast" do
-
-    it 'converts tracking variable definitions as expected' do
-      defn     = "trackvar mplus {Diagnosis:start}"
-      expected = [:trackvar_def,
-                   "mplus",
-                   [:event_set, "Diagnosis:start"],
-                   [:event_set],
-                   nil]
-      ast(defn, :trackvar_def).should eq(expected)
-    end
-
-    it 'supports obsolete events and initial value' do
-      defn     = "trackvar mplus {Diagnosis:start}, {Treatment:end} initially true"
-      expected = [:trackvar_def,
-                   "mplus",
-                   [:event_set, "Diagnosis:start"],
-                   [:event_set, "Treatment:end"],
-                   true]
-      ast(defn, :trackvar_def).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_unit_def.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe UnitDef, 'to_ast' do
-
-    it 'converts a single task definition as expected' do
-      expr = <<-UNIT.strip
-        task Task1 end
-      UNIT
-      expected = \
-        [:unit_def,
-          [:task_def, "Task1", [:nop_st]]]
-      ast(expr, :unit_def).should eq(expected)
-    end
-
-    it 'accepts multiple task definitions' do
-      expr = <<-UNIT.strip
-        task Task1 end
-        task Task2 end
-      UNIT
-      expected = \
-        [:unit_def,
-          [:task_def, "Task1", [:nop_st]],
-          [:task_def, "Task2", [:nop_st]] ]
-      ast(expr, :unit_def).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_var_ref.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe VarRef, "to_ast" do
-
-    it 'converts a reference as expected' do
-      defn     = "goodCond"
-      expected = [:var_ref, "goodCond"]
-      ast(defn, :var_ref).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_when_clause.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe WhenClause, 'to_ast' do
-
-    it 'converts a when clause as expected' do
-      expr = 'when goodCond Task'
-      expected = \
-        [:when_clause,
-          [:bool_expr, [:var_ref, "goodCond"] ],
-          [:task_call_st, "Task"]]
-      ast(expr, :when_clause).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_while_st.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe WhileSt, "to_ast" do
-
-    it 'parses as expected' do
-      expr     = "while goodCond Task1 end"
-      expected = \
-        [:while_st,
-          [:bool_expr, [:var_ref, "goodCond"]],
-          [:task_call_st, "Task1"]]
-      ast(expr, :while_st).should eq(expected)
-    end
-
-    it 'recognizes implicit sequences' do
-      expr     = "while goodCond Task1 Task2 end"
-      expected = \
-        [:while_st,
-          [:bool_expr, [:var_ref, "goodCond"]],
-          [:seq_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]]
-      ast(expr, :while_st).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/test_syntax.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-describe Gisele do
-  include Gisele
-
-  describe "parse" do
-
-    it 'works with a file' do
-      parsed = parse(fixtures_dir/:tasks/"simple.gis")
-      parsed.should be_a(Citrus::Match)
-    end
-
-    it 'works on a String' do
-      parsed = parse("task Hello end")
-      parsed.should be_a(Citrus::Match)
-    end
-
-    it 'accepts parse options' do
-      parsed = parse("if goodCond Task1 end", :root => :if_st)
-      parsed.should be_a(Citrus::Match)
-    end
-
-  end
-
-  describe "ast" do
-
-    it 'accepts parse options' do
-      ast = ast(parse("if goodCond Task1 end", :root => :if_st))
-      ast.should be_a(Sexpr)
-      ast.first.should eq(:if_st)
-    end
-
-    it 'sets traceability marks correctly' do
-      ast = ast(parse("if goodCond Task1 end", :root => :if_st))
-      ast.tracking_markers[:citrus_match].should_not be_nil
-    end
-
-    fixture_files('tasks/**/*.gis').each do |file|
-      it "works on #{file}" do
-        parsed = ast(parse(file))
-        parsed.should be_a(Array)
-        parsed.should be_a(Sexpr)
-        parsed.first.should eq(:unit_def)
-        if (astfile = file.sub_ext(".ast")).exist?
-          parsed.should eq(Kernel::eval(astfile.read, TOPLEVEL_BINDING, astfile.to_s))
-        end
-      end
-    end
-
-  end
-
-end