gisele 0.0.1 → 0.1.0

data/spec/unit/language/sugar_removal/test_if_to_guarded_commands.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+module Gisele::Language
+  describe SugarRemoval do
+    describe "if_st to case_st" do
+      include AST::Helpers
+
+      def ast(source)
+        Syntax.ast(source.strip, :root => :if_st)
+      end
+
+      def rewrite(ast)
+        SugarRemoval.new.call(ast)
+      end
+
+      it 'rewrites single if correctly' do
+        source   = ast("if goodCond Task1 end")
+        expected = \
+          [:case_st,
+            [:when_clause, [:var_ref, "goodCond"], [:task_call_st, "Task1"] ]]
+        rewrite(source).should eq(expected)
+      end
+
+      it 'negates the else clause' do
+        source   = ast("if goodCond Task1 else Task2 end")
+        expected = \
+          [:case_st,
+            [:when_clause, [:var_ref, "goodCond"], [:task_call_st, "Task1"] ],
+            [:when_clause, [:bool_not, [:var_ref, "goodCond"]], [:task_call_st, "Task2"] ]
+          ]
+        rewrite(source).should eq(expected)
+      end
+
+      it 'handles elsif clauses correctly' do
+        source = ast(<<-IF)
+          if    c1 Task1
+          elsif c2 Task2
+          elsif c3 Task3
+          else  Task4
+          end
+        IF
+        expected = \
+          [:case_st,
+            [:when_clause,
+              [:var_ref, "c1"],
+              [:task_call_st, "Task1"] ],
+            [:when_clause,
+              [:bool_and,
+                [:var_ref, "c2"],
+                [:bool_not, [:var_ref, "c1"]] ],
+              [:task_call_st, "Task2"] ],
+            [:when_clause,
+              [:bool_and,
+                [:var_ref, "c3"],
+                [:bool_and,
+                  [:bool_not, [:var_ref, "c2"]],
+                  [:bool_not, [:var_ref, "c1"]] ]],
+              [:task_call_st, "Task3"] ],
+            [:when_clause,
+              [:bool_and,
+                [:bool_not, [:var_ref, "c3"]],
+                [:bool_and,
+                  [:bool_not, [:var_ref, "c2"]],
+                  [:bool_not, [:var_ref, "c1"]]]],
+              [:task_call_st, "Task4"] ],
+          ]
+        rewrite(source).should eq(expected)
+      end
+
+      it 'avoids double negations' do
+        source   = ast("if not(goodCond) Task1 else Task2 end")
+        expected = \
+          [:case_st,
+            [:when_clause,
+              [:bool_not, [:var_ref, "goodCond"]],
+              [:task_call_st, "Task1"] ],
+            [:when_clause,
+              [:var_ref, "goodCond"],
+              [:task_call_st, "Task2"] ] ]
+        rewrite(source).should eq(expected)
+      end
+
+      it 'recurse on other nodes' do
+        if_st = ast("if goodCond Task1 end")
+        rw_st = rewrite(if_st)
+        rewrite([:unit, if_st]).should eq([:unit, rw_st])
+      end
+
+    end
+  end
+end

data/spec/unit/language/{test_grammar.rb → syntax/test_grammar.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
-module Gisele::Language
+module Gisele::Language::Syntax
   describe Grammar do
 
-    let(:grammar){ Gisele::Language::Grammar }
+    let(:grammar){ Gisele::Language::Syntax::Grammar }
 
     def parse(text, rule, consume = true)
       grammar.parse(text, :root => rule, :consume => consume)
@@ -130,22 +130,6 @@ module Gisele::Language
 
     end # event
 
-    describe 'the event_commalist rule' do
-
-      it 'parses a singleton list' do
-        parse('Task:start', :event_commalist).should eq('Task:start')
-      end
-
-      it 'parses multiple events' do
-        parse('Task:start, an_event', :event_commalist).should eq('Task:start, an_event')
-      end
-
-      it 'recognizes invalid events' do
-        lambda{ parse('Task:start, NotAnEvent', :event_commalist) }.should raise_error(Citrus::ParseError)
-      end
-
-    end # event_commalist
-
     describe 'the event_set rule' do
 
       it 'parses empty sets' do
@@ -158,6 +142,10 @@ module Gisele::Language
         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
@@ -238,51 +226,51 @@ module Gisele::Language
 
     ### Process statements
 
-    describe 'the par_statement rule' do
+    describe 'the par_st rule' do
 
       it 'parses a single parallel statement' do
         expr = 'par Task1 Task2 end'
-        parse(expr, :par_statement).should eq(expr)
+        parse(expr, :par_st).should eq(expr)
       end
 
-    end # par_statement
+    end # par_st
 
-    describe 'the seq_statement rule' do
+    describe 'the seq_st rule' do
 
       it 'parses a single sequence statement' do
         expr = 'seq Task1 Task2 end'
-        parse(expr, :seq_statement).should eq(expr)
+        parse(expr, :seq_st).should eq(expr)
       end
 
-    end # seq_statement
+    end # seq_st
 
     describe 'the while_statement rule' do
 
       it 'parses a single while statement' do
         expr = 'while badCond Task end'
-        parse(expr, :while_statement).should eq(expr)
+        parse(expr, :while_st).should eq(expr)
       end
 
     end # while_statement
 
-    describe 'the if_statement rule' do
+    describe 'the if_st rule' do
 
       it 'parses a single if statement' do
         expr = 'if goodCond Task end'
-        parse(expr, :if_statement).should eq(expr)
+        parse(expr, :if_st).should eq(expr)
       end
 
       it 'supports an optional else' do
         expr = 'if goodCond GoodTask else BadTask end'
-        parse(expr, :if_statement).should eq(expr)
+        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_statement).should eq(expr)
+        parse(expr, :if_st).should eq(expr)
       end
 
-    end # if_statement
+    end # if_st
 
     describe 'the process_statement rule' do
 

data/spec/unit/language/syntax/test_to_ast.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, "to_ast" do
+
+    def ast(text, rule, consume = true)
+      @parsed = Grammar.parse(text, :root => rule, :consume => consume).to_ast
+    end
+
+    after{ @parsed.should be_a(Gisele::Language::AST::Node) }
+
+    describe "the bool_expr rule" do
+
+      it 'returns expected ast on simple expressions' do
+        expected = [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]]
+        ast("diagKnown and platLow", :bool_expr).should eq(expected)
+      end
+
+      it 'respects priorities' do
+        expected = [: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_not, [:bool_not, [:var_ref, "diagKnown"]]]
+        ast("not not(diagKnown)", :bool_expr).should eq(expected)
+      end
+
+    end # bool_expr
+
+    describe 'the event_set rule' do
+
+      it 'parses empty lists as expected' do
+        expr     = '{ }'
+        expected = [:event_set]
+        ast(expr, :event_set).should eq(expected)
+      end
+
+      it 'parses singleton lists as expected' do
+        expr     = '{Diagnosis:start}'
+        expected = [:event_set, "Diagnosis:start"]
+        ast(expr, :event_set).should eq(expected)
+      end
+
+      it 'parses 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 # event_set
+
+    describe "the fluent_def rule" do
+
+      it 'parses 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 # fluent_def rule
+
+    describe "the trackvar_def rule" do
+
+      it 'parses tracking variable definitions as expected' do
+        defn     = "trackvar mplus {Diagnosis:start}"
+        expected = [:trackvar,
+                     "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,
+                     "mplus",
+                     [:event_set, "Diagnosis:start"],
+                     [:event_set, "Treatment:end"],
+                     true]
+        ast(defn, :trackvar_def).should eq(expected)
+      end
+
+    end # trackvar_def rule
+
+    describe "the task_call_st rule" do
+
+      it 'parses as expected' do
+        ast("Diagnosis", :task_call_st).should eq([:task_call_st, "Diagnosis"])
+      end
+
+    end # task_call_statement
+
+    describe "the par_st rule" 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 # par_st
+
+    describe "the seq_st rule" 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 # seq_st
+
+    describe "the while_statement rule" do
+
+      it 'parses as expected' do
+        expr     = "while goodCond Task1 end"
+        expected = \
+          [:while_st,
+            [: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,
+            [:var_ref, "goodCond"],
+            [:seq_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]]
+        ast(expr, :while_st).should eq(expected)
+      end
+
+    end # while_statement
+
+    describe "the else_clause rule" 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 # else_clause
+
+    describe "the elsif_clause rule" do
+
+      it 'parses as expected' do
+        expr     = "elsif goodCond Task1 "
+        expected = \
+          [:elsif_clause, [:var_ref, "goodCond"], [:task_call_st, "Task1"]]
+        ast(expr, :elsif_clause).should eq(expected)
+      end
+
+    end # elsif_clause
+
+    describe "the if_statement rule" do
+
+      it 'parses as expected' do
+        expr     = "if goodCond Task1 end"
+        expected = \
+          [:if_st, [: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,
+            [: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,
+            [:var_ref, "goodCond"], [:task_call_st, "Task1"],
+            [:elsif_clause,
+              [:var_ref, "otherCond"], [:task_call_st, "Task2"]],
+            [:elsif_clause,
+              [:var_ref, "stillAnother"], [:task_call_st, "Task3"]],
+            [:else_clause,
+              [:task_call_st, "Task4"]] ]
+        ast(expr, :if_st).should eq(expected)
+      end
+
+    end # if_statement
+
+    describe 'the task_refinement rule' do
+
+      it 'parses as expected' do
+        expr     = "refinement Task1 end"
+        expected = [:task_refinement, [:task_call_st, "Task1"]]
+        ast(expr, :task_refinement).should eq(expected)
+      end
+
+    end # task_refinement
+
+    describe 'the task_signature rule' do
+
+      it 'parses as expected' do
+        expr     = "fluent diagKnown {}, {}\ntrackvar mplus {}"
+        expected = \
+          [ :task_signature,
+            [:fluent, "diagKnown", [:event_set], [:event_set], nil],
+            [:trackvar, "mplus", [:event_set], [:event_set], nil]]
+        ast(expr, :task_signature).should eq(expected)
+      end
+
+    end # task_signature
+
+    describe 'the task_def rule' do
+
+      it 'parses as expected' do
+        expr     = "task Task1 fluent diagKnown {}, {} refinement Task2 end end"
+        expected = \
+          [:task_def, "Task1",
+            [:task_signature,
+              [:fluent, "diagKnown", [:event_set], [:event_set], nil]],
+            [:task_refinement,
+              [:task_call_st, "Task2"]]]
+        ast(expr, :task_def).should eq(expected)
+      end
+
+    end # task_def
+
+  end
+end