gisele 0.2.0 → 0.3.0

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,44 @@
+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, "diagKnown", [:event_set], [:event_set], nil],
+          [:task_call_st, "Task2"]]
+      ast(expr, :task_def).should eq(expected)
+    end
+
+    it 'uses :nop if no statement' do
+      expr = <<-EXPR.strip
+        task Task1
+          fluent diagKnown {}, {}
+        end
+      EXPR
+      expected = \
+        [:task_def, "Task1",
+          [:fluent, "diagKnown", [:event_set], [:event_set], nil],
+          [:nop]]
+      ast(expr, :task_def).should eq(expected)
+    end
+
+    it 'uses :nop when empty' do
+      expr = <<-EXPR.strip
+        task Task1
+        end
+      EXPR
+      expected = \
+        [:task_def, "Task1",
+          [:nop]]
+      ast(expr, :task_def).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+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,
+                   "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
+end

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

@@ -0,0 +1,28 @@
+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]]]
+      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]],
+          [:task_def, "Task2", [:nop]] ]
+      ast(expr, :unit_def).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,24 @@
+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_ast.rb

@@ -5,13 +5,13 @@ module Gisele::Language
     describe 'ast' do
 
       it 'returns a node' do
-        node = [:unit].extend(AST::Node)
+        node = [:unit_def].extend(AST::Node)
         AST.node(node).object_id.should eq(node.object_id)
       end
 
       it 'coerces an array' do
-        AST.node([:unit]).should eq([:unit])
-        AST.node([:unit]).should be_a(AST::Unit)
+        AST.node([:unit_def]).should eq([:unit_def])
+        AST.node([:unit_def]).should be_a(AST::UnitDef)
       end
 
       it 'falls back to Node' do
@@ -20,7 +20,7 @@ module Gisele::Language
       end
 
       it 'applies coercions recursively' do
-        source = [:unit, [:hello, "world"]]
+        source = [:unit_def, [:hello, "world"]]
         AST.node(source).should eq(source)
         AST.node(source).last.should be_a(AST::Node)
       end

data/spec/unit/language/test_elsif_flattener.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+module Gisele::Language
+  describe ElsifFlattener do
+
+    def ast(source)
+      Syntax.ast(source.strip, :root => :if_st)
+    end
+
+    def rewrite(ast)
+      ElsifFlattener.new.call(ast)
+    end
+
+    it 'rewrites a single if correctly' do
+      source = ast("if goodCond Task1 end")
+      rewrite(source).should eq(source)
+    end
+
+    it 'rewrites a if/else correctly' do
+      source = ast("if goodCond Task1 else Task2 end")
+      rewrite(source).should eq(source)
+    end
+
+    it 'rewrites a if/elsif correctly' do
+      source   = ast("if good Task1 elsif bad Task2 end")
+      expected = ast("if good Task1 else if bad Task2 end end")
+      rewrite(source).should eq(expected)
+    end
+
+    it 'rewrites a if/elsif/else correctly' do
+      source   = ast("if good Task1 elsif bad Task2 else Task3 end")
+      expected = ast("if good Task1 else if bad Task2 else Task3 end end")
+      rewrite(source).should eq(expected)
+    end
+
+    it 'rewrites a if/elsif/elsif/else correctly' do
+      source = ast(<<-EOF.strip)
+        if good Task1
+        elsif bad Task2
+        elsif none Task3
+        else Task4
+        end
+      EOF
+      expected = ast(<<-EOF.strip)
+        if good
+          Task1
+        else
+          if bad
+            Task2
+          else
+            if none
+              Task3
+            else
+              Task4
+            end
+          end
+        end
+      EOF
+      rewrite(source).should eq(expected)
+    end
+
+    it 'recurses by default' do
+      source = ast(<<-EOF.strip)
+        if goodCond
+          Task1
+        else
+          if bad
+            Task2
+          elsif middle
+            Task3
+          end
+        end
+      EOF
+      expected = ast(<<-EOF.strip)
+        if goodCond
+          Task1
+        else
+          if bad
+            Task2
+          else
+            if middle
+              Task3
+            end
+          end
+        end
+      EOF
+      rewrite(source).should eq(expected)
+    end
+
+  end
+end

data/spec/unit/language/test_if_to_case.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+module Gisele::Language
+  describe IfToCase do
+
+    def ast(source)
+      Syntax.ast(source.strip, :root => :if_st)
+    end
+
+    def rewrite(ast)
+      IfToCase.new.call(ast)
+    end
+
+    it 'rewrites single if correctly' do
+      source   = ast("if goodCond Task1 end")
+      expected = \
+        [:case_st, nil,
+          [:when_clause,
+            [:bool_expr, [: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, nil,
+          [:when_clause,
+            [:bool_expr, [:var_ref, "goodCond"]],
+            [:task_call_st, "Task1"] ],
+          [:when_clause,
+            [:bool_expr, [: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, nil,
+          [:when_clause,
+            [:bool_expr, [:var_ref, "c1"]],
+            [:task_call_st, "Task1"] ],
+          [:when_clause,
+            [:bool_expr, [:bool_and,
+              [:var_ref, "c2"],
+              [:bool_not, [:var_ref, "c1"]] ]],
+            [:task_call_st, "Task2"] ],
+          [:when_clause,
+            [:bool_expr, [:bool_and,
+              [:var_ref, "c3"],
+              [:bool_and,
+                [:bool_not, [:var_ref, "c2"]],
+                [:bool_not, [:var_ref, "c1"]] ]]],
+            [:task_call_st, "Task3"] ],
+          [:when_clause,
+            [:bool_expr, [: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, nil,
+          [:when_clause,
+            [:bool_expr, [:bool_not, [:var_ref, "goodCond"]]],
+            [:task_call_st, "Task1"] ],
+          [:when_clause,
+            [:bool_expr, [: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
+
+    it 'keeps traceability markers on a single if' do
+      if_st = ast("if goodCond Task1 end")
+      rw_st = rewrite(if_st)
+      rw_st.markers.should eq(if_st.markers)
+      rw_st.last.markers.should eq(if_st.markers)
+    end
+
+    it 'keeps traceability markers when a else if present' do
+      if_st = ast("if goodCond Task1 else Task2 end")
+      rw_st = rewrite(if_st)
+      rw_st.markers.should eq(if_st.markers)
+      rw_st.last.markers.should eq(if_st.last.markers)
+    end
+
+  end
+end

data/spec/unit/language/{test_transformer.rb → test_rewriter.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
 module Gisele::Language
-  describe Transformer do
+  describe Rewriter do
 
-    let(:transformer_class){
-      Class.new(Transformer) do
+    let(:rewriter_class){
+      Class.new(Rewriter) do
 
         def on_hello(node)
           [:seen_hello, node]
@@ -23,33 +23,46 @@ module Gisele::Language
 
       end
     }
-    let(:transformer){ transformer_class.new }
+    let(:rewriter){ rewriter_class.new }
+
+    describe 'mainflow' do
+
+      it 'defaults to self' do
+        rewriter.mainflow.should eq(rewriter)
+      end
+
+      it 'may be passed through options' do
+        rw = rewriter_class.new(:mainflow => :hello)
+        rw.mainflow.should eq(:hello)
+      end
+
+    end # mainflow
 
     describe 'call' do
 
       it 'dispatches to existing methods' do
         ast = [:hello, "world"]
-        transformer.call(ast).should eq([:seen_hello, [:hello, "world"]])
+        rewriter.call(ast).should eq([:seen_hello, [:hello, "world"]])
       end
 
       it 'calls on_missing when not found' do
         ast = [:nosuchone, "world"]
-        transformer.call(ast).should eq([:seen_missing, [:nosuchone, "world"]])
+        rewriter.call(ast).should eq([:seen_missing, [:nosuchone, "world"]])
       end
 
       it 'raises unexpected by default in on_missing' do
         ast = [:nonono, "world"]
-        lambda{ transformer.call(ast) }.should raise_error(Gisele::UnexpectedNodeError, /nonono/)
+        lambda{ rewriter.call(ast) }.should raise_error(Gisele::UnexpectedNodeError, /nonono/)
       end
 
       it 'performs post node transformation if required' do
         ast = [:hello, "world"]
-        transformer.call(ast).should be_a(AST::Node)
+        rewriter.call(ast).should be_a(AST::Node)
       end
 
       it 'raises an ArgumentError unless called on a non terminal' do
         lambda{
-          transformer.call("world").should raise_error(ArgumentError, /world/)
+          rewriter.call("world").should raise_error(ArgumentError, /world/)
         }
       end
 
@@ -59,10 +72,10 @@ module Gisele::Language
 
       it 'provides a friendly way of applying copy/recurse' do
         ast = [:copy, [:hello, 'world'], "!"]
-        transformer.call(ast).should eq([:copy, [:seen_hello, [:hello, "world"]], "!"])
+        rewriter.call(ast).should eq([:copy, [:seen_hello, [:hello, "world"]], "!"])
       end
 
     end
 
   end
-end
+end

data/spec/unit/language/test_syntax.rb

@@ -40,7 +40,7 @@ module Gisele::Language
           parsed = Syntax.ast(file)
           parsed.should be_a(Array)
           parsed.should be_a(AST::Node)
-          parsed.first.should eq(:unit)
+          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

data/spec/unit/language/test_to_graph.rb

@@ -2,8 +2,15 @@ require 'spec_helper'
 module Gisele::Language
   describe ToGraph do
 
-    it 'returns a Digraph' do
-      ToGraph.new.call(complete_ast).should be_a(Yargi::Digraph)
+    it 'returns an array of Digraphs when called on a unit_def' do
+      got = ToGraph.new.call(complete_ast)
+      got.should be_a(Array)
+      got.all?{|x| x.is_a? Yargi::Digraph}.should be_true
+    end
+
+    it 'returns a Digraph when called on a task_def' do
+      got = ToGraph.new.call(complete_ast.last)
+      got.should be_a(Yargi::Digraph)
     end
 
   end