gisele 0.2.0 → 0.3.0

data/spec/unit/language/syntax/grammar/test_case_st.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'case_st' do
+
+    it 'supports a single when clause' do
+      expr = <<-CASE_ST.strip
+        case
+        when goodCond
+          Task1
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports boolean expressions in when clauses' do
+      expr = <<-CASE_ST.strip
+        case
+        when not(goodCond) or badCond
+          Task1
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports a multiple when clauses' do
+      expr = <<-CASE_ST.strip
+        case
+        when goodCond
+          Task1
+        when badCond
+          Task2
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports an else clause' do
+      expr = <<-CASE_ST.strip
+        case
+        when goodCond
+          Task1
+        else
+          Task2
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports an optional variable name' do
+      expr = <<-CASE_ST.strip
+        case someVariable
+        when goodCond
+          Task1
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_event.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'event' do
+
+    it 'parses correct events' do
+      parse('Task:start', :event).should eq('Task:start')
+      parse('Task:end',   :event).should eq('Task:end')
+      parse('an_event',   :event).should eq('an_event')
+    end
+
+    it 'raises on invalid event names' do
+      lambda{
+        parse('Task', :event)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_event_name.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'event_name' do
+
+    it 'parses correct event names' do
+      parse('a',          :event_name).should eq('a')
+      parse('event',      :event_name).should eq('event')
+      parse('event_name', :event_name).should eq('event_name')
+    end
+
+    it 'raises on invalid variable names' do
+      lambda{
+        parse('NotAnEventName',  :event_name)
+      }.should raise_error(Citrus::ParseError)
+      lambda{
+        parse('notAnEventName',  :event_name)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_event_set.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'event_set' do
+
+    it 'parses empty sets' do
+      parse('{}', :event_set).should eq('{}')
+      parse('{   }', :event_set).should eq('{   }')
+    end
+
+    it 'parses event singletons' do
+      parse('{Task:start}', :event_set).should eq('{Task:start}')
+      parse('{  Task:start  }', :event_set).should eq('{  Task:start  }')
+    end
+
+    it 'parses event sets' do
+      parse('{Task:start, Task:end}', :event_set).should eq('{Task:start, Task:end}')
+    end
+
+    it 'recognizes invalid events in the set' do
+      lambda{
+        parse('{Task:start, NotAnEvent}', :event_set)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end
+

data/spec/unit/language/syntax/grammar/test_fluent_def.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'fluent_def' do
+
+    it 'parses valid fluent definitions' do
+      defn = 'fluent diagKnown {Diagnosis:start}, {Treatment:end} initially false'
+      parse(defn, :fluent_def).should eq(defn)
+    end
+
+    it 'supports a missing initial value' do
+      defn = 'fluent diagKnown {Diagnosis:start}, {Treatment:end}'
+      parse(defn, :fluent_def).should eq(defn)
+    end
+
+    it 'supports empty sets for events' do
+      defn = 'fluent diagKnown {}, {} initially true'
+      parse(defn, :fluent_def).should eq(defn)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_if_st.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'if_st' do
+
+    it 'parses a single if statement' do
+      expr = 'if goodCond Task end'
+      parse(expr, :if_st).should eq(expr)
+    end
+
+    it 'supports an optional else' do
+      expr = 'if goodCond GoodTask else BadTask end'
+      parse(expr, :if_st).should eq(expr)
+    end
+
+    it 'supports an optional elsif clauses' do
+      expr = 'if goodCond GoodTask elsif otherCond OtherTask elsif yetAnother BadTask end'
+      parse(expr, :if_st).should eq(expr)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_par_st.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'par_st' do
+
+    it 'parses a single parallel statement' do
+      expr = 'par Task1 Task2 end'
+      parse(expr, :par_st).should eq(expr)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_process_statement.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'process_statement' do
+
+    it 'parses a simple process statement' do
+      expr = <<-PROCESS.strip
+        DoSomething
+        if goodCond
+          DoForGood
+        else
+          DoForBad
+        end
+        CleanDesk
+      PROCESS
+      parse(expr, :process_statement).should eq(expr)
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'seq_st' do
+
+    it 'parses a single sequence statement' do
+      expr = 'seq Task1 Task2 end'
+      parse(expr, :seq_st).should eq(expr)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_spaces.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'spaces' do
+
+    it 'parses all kind of spaces' do
+      parse(' ', :spaces).should eq(' ')
+      parse("\t", :spaces).should eq("\t")
+      parse("\n", :spaces).should eq("\n")
+      parse(" \t\n", :spaces).should eq(" \t\n")
+    end
+
+    it 'enforces mandatory spacing' do
+      lambda{
+        parse('', :spaces)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_spacing.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'spacing' do
+
+    it 'parses all kind of spaces' do
+      parse(' ', :spacing).should eq(' ')
+      parse("\t", :spacing).should eq("\t")
+      parse("\n", :spacing).should eq("\n")
+      parse(" \t\n", :spacing).should eq(" \t\n")
+    end
+
+    it 'does not enforces mandatory spacing' do
+      parse('', :spacing).should eq('')
+    end
+
+  end
+end
+

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'task_def' do
+
+    it 'parses a simple implicit task definition' do
+      taskdef = <<-TASKDEF.strip
+        task Process
+          Diagnosis
+        end
+      TASKDEF
+      parse(taskdef, :task_def).should eq(taskdef)
+    end
+
+    it 'allows any statement' do
+      taskdef = <<-TASKDEF.strip
+        task Process
+          while true Diagnosis end
+        end
+      TASKDEF
+      parse(taskdef, :task_def).should eq(taskdef)
+    end
+
+    it 'supports optional variable definitions in the signature' do
+      taskdef = <<-TASKDEF.strip
+        task Process
+          fluent   diagKnown {Diagnosis:start}, {} initially false
+          trackvar mplus     {Diagnosis:end}
+          Diagnosis
+        end
+      TASKDEF
+      parse(taskdef, :task_def).should eq(taskdef)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_task_name.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar,'task_name' do
+
+    it 'parses correct task names' do
+      parse('A',          :task_name).should eq('A')
+      parse('Diagnosis',  :task_name).should eq('Diagnosis')
+      parse('TaskName',   :task_name).should eq('TaskName')
+      parse('Task_Name',  :task_name).should eq('Task_Name')
+    end
+
+    it 'raises on invalid task names' do
+      lambda{
+        parse('not_a_task_name', :task_name)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_task_start_or_end.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'task_start_or_end' do
+
+    it 'parses correct event names' do
+      parse('Task:start', :task_start_or_end).should eq('Task:start')
+      parse('Task:end',   :task_start_or_end).should eq('Task:end')
+    end
+
+    it 'raises on simple task names' do
+      lambda{
+        parse('Task', :task_start_or_end)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'trackvar_def' do
+
+    it 'parses valid tracking variable definitions' do
+      defn = 'trackvar plateletLow {BloodTest:end}'
+      parse(defn, :trackvar_def).should eq(defn)
+    end
+
+    it 'supports an optional initial value' do
+      defn = 'trackvar plateletLow {BloodTest:end} initially false'
+      parse(defn, :trackvar_def).should eq(defn)
+    end
+
+    it 'supports optional obsolete events' do
+      defn = 'trackvar plateletLow {BloodTest:end}, {Chemotherapy:end}'
+      parse(defn, :trackvar_def).should eq(defn)
+    end
+
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'unit' do
+
+    it 'parses a single task definition' do
+      expr = <<-UNIT.strip
+        task Task1 end
+      UNIT
+      parse(expr, :unit_def).should eq(expr)
+    end
+
+    it 'accepts multiple task definitions' do
+      expr = <<-UNIT.strip
+        task Task1 end
+        task Task2 end
+      UNIT
+      parse(expr, :unit_def).should eq(expr)
+    end
+
+    it 'allows trailing spaces' do
+      expr = <<-UNIT
+        task Task1 end
+        task Task2 end
+      UNIT
+      parse(expr, :unit_def).should eq(expr)
+    end
+
+  end
+end

data/spec/unit/language/syntax/grammar/test_variable_name.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'variable_name' do
+
+    it 'parses correct variable names' do
+      parse('a',         :variable_name).should eq('a')
+      parse('diagnosis', :variable_name).should eq('diagnosis')
+      parse('varName',   :variable_name).should eq('varName')
+    end
+
+    it 'does not allow reserved words' do
+      Gisele::Language::RESERVED_WORDS.each do |word|
+        lambda{
+          parse(word.to_s + " ", :variable_name)
+        }.should raise_error(Citrus::ParseError)
+      end
+    end
+
+    it 'allows a reserved word as prefix' do
+      parse('ifSomething', :variable_name).should eq('ifSomething')
+    end
+
+    it 'raises on invalid variable names' do
+      lambda{
+        parse('NotAVarName', :variable_name)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'when_clause' do
+
+    it 'parses a single when clause statement' do
+      expr = 'when goodCond Task'
+      parse(expr, :when_clause).should eq(expr)
+    end
+
+    it 'supports a boolean expression' do
+      expr = 'when not(goodCond and badCond) Task'
+      parse(expr, :when_clause).should eq(expr)
+    end
+
+    it 'supports an complex process statement' do
+      expr = 'when goodCond Task1 par Task2 Task3 end'
+      parse(expr, :when_clause).should eq(expr)
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'while_st' do
+
+    it 'parses a single while statement' do
+      expr = 'while badCond Task end'
+      parse(expr, :while_st).should eq(expr)
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe BoolExpr, "to_ast" do
+
+    it 'returns expected ast on simple expressions' do
+      expected = \
+        [:bool_expr, [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]]]
+      ast("diagKnown and platLow", :bool_expr).should eq(expected)
+    end
+
+    it 'respects priorities' do
+      expected = [:bool_expr,
+        [:bool_or, [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]], [:var_ref, "platHigh"]]]
+      ast("diagKnown and platLow or platHigh", :bool_expr).should eq(expected)
+    end
+
+    it 'supports double negations' do
+      expected = [:bool_expr, [:bool_not, [:bool_not, [:var_ref, "diagKnown"]]]]
+      ast("not not(diagKnown)", :bool_expr).should eq(expected)
+    end
+
+    it 'makes boolean literals explicit' do
+      ast("true",  :bool_expr).should eq([:bool_expr, [:bool_lit, true]])
+      ast("false", :bool_expr).should eq([:bool_expr, [:bool_lit, false]])
+    end
+
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe CaseSt, "to_ast" do
+
+    it 'arranges when clauses as expected' do
+      expr = <<-CASE_ST.strip
+        case
+        when good
+          Task1
+        when bad
+          Task2
+        end
+      CASE_ST
+      when_clause1 = ast("when good Task1", :when_clause)
+      when_clause2 = ast("when bad Task2", :when_clause)
+      expected = [:case_st, nil, when_clause1, when_clause2]
+      ast(expr, :case_st).should eq(expected)
+    end
+
+    it 'puts the else clause at the end' do
+      expr = <<-CASE_ST.strip
+        case
+        when good
+          Task1
+        else
+          Task2
+        end
+      CASE_ST
+      when_clause = ast("when good Task1", :when_clause)
+      else_clause = ast("else Task2", :else_clause)
+      expected = [:case_st, nil, when_clause, else_clause]
+      ast(expr, :case_st).should eq(expected)
+    end
+
+    it 'supports an optional variable name' do
+      expr = <<-CASE_ST.strip
+        case someVariable
+        when good
+          Task1
+        end
+      CASE_ST
+      expected = [:var_ref, "someVariable"]
+      ast(expr, :case_st)[1].should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe ElseClause, "to_ast" do
+
+    it 'parses as expected' do
+      expr     = "else Task1"
+      expected = \
+        [:else_clause, [:task_call_st, "Task1"]]
+      ast(expr, :else_clause).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe ElsifClause, "to_ast" do
+
+    it 'parses as expected' do
+      expr     = "elsif goodCond Task1"
+      expected = \
+        [:elsif_clause,
+          [:bool_expr, [:var_ref, "goodCond"]],
+          [:task_call_st, "Task1"]]
+      ast(expr, :elsif_clause).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe EventSet, "to_ast" do
+
+    it 'converts empty lists as expected' do
+      expr     = '{ }'
+      expected = [:event_set]
+      ast(expr, :event_set).should eq(expected)
+    end
+
+    it 'converts singleton lists as expected' do
+      expr     = '{Diagnosis:start}'
+      expected = [:event_set, "Diagnosis:start"]
+      ast(expr, :event_set).should eq(expected)
+    end
+
+    it 'converts non empty lists as expected' do
+      expr     = '{Diagnosis:start, an_event, another_one}'
+      expected = [:event_set, "Diagnosis:start", "an_event", "another_one"]
+      ast(expr, :event_set).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe FluentDef, "to_ast" do
+
+    it 'converts fluent definitions as expected' do
+      defn     = "fluent diagKnown {Diagnosis:start, diagnosis}, {Treatment:end} initially false"
+      expected = [:fluent,
+                   "diagKnown",
+                   [:event_set, "Diagnosis:start", "diagnosis"],
+                   [:event_set, "Treatment:end"],
+                   false]
+      ast(defn, :fluent_def).should eq(expected)
+    end
+
+    it 'does not require the initial value' do
+      defn     = "fluent diagKnown {Diagnosis:start, diagnosis}, {Treatment:end}"
+      expected = [:fluent,
+                   "diagKnown",
+                   [:event_set, "Diagnosis:start", "diagnosis"],
+                   [:event_set, "Treatment:end"],
+                   nil]
+      ast(defn, :fluent_def).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe IfSt, "to_ast" do
+
+    it 'parses as expected' do
+      expr     = "if goodCond Task1 end"
+      expected = \
+        [:if_st,
+          [:bool_expr, [:var_ref, "goodCond"]],
+          [:task_call_st, "Task1"]]
+      ast(expr, :if_st).should eq(expected)
+    end
+
+    it 'supports a else clause' do
+      expr     = "if goodCond Task1 else Task2 end"
+      expected = \
+        [:if_st,
+          [:bool_expr, [:var_ref, "goodCond"]],
+          [:task_call_st, "Task1"],
+          [:else_clause, [:task_call_st, "Task2"]] ]
+      ast(expr, :if_st).should eq(expected)
+    end
+
+    it 'supports elsif clauses' do
+      expr     = "if goodCond Task1 elsif otherCond Task2 elsif stillAnother Task3 else Task4 end"
+      expected = \
+        [:if_st,
+          [:bool_expr, [:var_ref, "goodCond"]], [:task_call_st, "Task1"],
+          [:elsif_clause,
+            [:bool_expr, [:var_ref, "otherCond"]], [:task_call_st, "Task2"]],
+          [:elsif_clause,
+            [:bool_expr, [:var_ref, "stillAnother"]], [:task_call_st, "Task3"]],
+          [:else_clause,
+            [:task_call_st, "Task4"]] ]
+      ast(expr, :if_st).should eq(expected)
+    end
+
+  end
+end

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

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