gisele 0.2.0 → 0.3.0

data/spec/command/main/gisele_no_sugar.stdout

@@ -1,45 +1,136 @@
 [
-    :unit,
+    :unit_def,
     [
         :task_def,
-        "Simple",
+        "Complete",
         [
-            :task_signature,
+            :trackvar,
+            "everyOneHappy",
             [
-                :fluent,
-                "diagKnown",
+                :event_set,
+                "FirstTask:start"
+            ],
+            [
+                :event_set
+            ],
+            nil
+        ],
+        [
+            :fluent,
+            "someoneHappy",
+            [
+                :event_set,
+                "DrinkBeer:start",
+                "DrinkBeers:start"
+            ],
+            [
+                :event_set,
+                "DoNothingSpecial:end"
+            ],
+            false
+        ],
+        [
+            :task_def,
+            "DrinkBeers",
+            [
+                :while_st,
                 [
-                    :event_set,
-                    "Diagnosis:start"
+                    :bool_expr,
+                    [
+                        :bool_not,
+                        [
+                            :var_ref,
+                            "drunk"
+                        ]
+                    ]
                 ],
                 [
-                    :event_set,
-                    "Treatment:end"
-                ],
-                nil
+                    :task_call_st,
+                    "DrinkBeer"
+                ]
             ]
         ],
         [
-            :task_refinement,
+            :seq_st,
+            [
+                :task_call_st,
+                "FirstTask"
+            ],
             [
-                :seq_st,
+                :if_st,
+                [
+                    :bool_expr,
+                    [
+                        :var_ref,
+                        "everyoneHappy"
+                    ]
+                ],
+                [
+                    :par_st,
+                    [
+                        :task_call_st,
+                        "MakeJoy"
+                    ],
+                    [
+                        :task_call_st,
+                        "DrinkBeers"
+                    ]
+                ],
+                [
+                    :else_clause,
+                    [
+                        :if_st,
+                        [
+                            :bool_expr,
+                            [
+                                :var_ref,
+                                "someoneHappy"
+                            ]
+                        ],
+                        [
+                            :task_call_st,
+                            "DrinkBeer"
+                        ],
+                        [
+                            :else_clause,
+                            [
+                                :task_call_st,
+                                "DoNothingSpecial"
+                            ]
+                        ]
+                    ]
+                ]
+            ],
+            [
+                :while_st,
+                [
+                    :bool_expr,
+                    [
+                        :bool_not,
+                        [
+                            :var_ref,
+                            "endOfTheDay"
+                        ]
+                    ]
+                ],
                 [
                     :case_st,
+                    [
+                        :var_ref,
+                        "curState"
+                    ],
                     [
                         :when_clause,
                         [
                             :bool_expr,
                             [
-                                :bool_not,
-                                [
-                                    :var_ref,
-                                    "diagKnown"
-                                ]
+                                :var_ref,
+                                "somethingToDo"
                             ]
                         ],
                         [
                             :task_call_st,
-                            "Diagnosis"
+                            "DoSomething"
                         ]
                     ],
                     [
@@ -48,18 +139,21 @@
                             :bool_expr,
                             [
                                 :var_ref,
-                                "diagKnown"
+                                "nothingToDo"
                             ]
                         ],
                         [
                             :task_call_st,
-                            "NoDiag"
+                            "DoNothing"
+                        ]
+                    ],
+                    [
+                        :else_clause,
+                        [
+                            :task_call_st,
+                            "WaitAndSee"
                         ]
                     ]
-                ],
-                [
-                    :task_call_st,
-                    "Treatment"
                 ]
             ]
         ]

data/spec/command/main/gisele_version.stdout

@@ -1,2 +1,2 @@
-gisele 0.2.0 (c) The University of Louvain
+gisele 0.3.0 (c) The University of Louvain
 SystemExit

data/spec/fixtures/tasks/complete.gis

@@ -1,5 +1,20 @@
 task Complete
-  refinement
+
+  trackvar everyOneHappy
+    {FirstTask:start}
+
+  fluent someoneHappy
+    {DrinkBeer:start, DrinkBeers:start},
+    {DoNothingSpecial:end}
+  initially false
+
+  task DrinkBeers
+    while not(drunk)
+      DrinkBeer
+    end
+  end
+
+  seq
     FirstTask
     if everyoneHappy
       par
@@ -12,7 +27,14 @@ task Complete
       DoNothingSpecial
     end
     while not(endOfTheDay)
-      WaitAndSee
+      case curState
+      when somethingToDo
+        DoSomething
+      when nothingToDo
+        DoNothing
+      else
+        WaitAndSee
+      end
     end
   end
 end

data/spec/fixtures/tasks/simple.ast

@@ -1,56 +1,50 @@
 [
-    :unit,
+    :unit_def,
     [
         :task_def,
         "Simple",
         [
-            :task_signature,
+            :fluent,
+            "diagKnown",
             [
-                :fluent,
-                "diagKnown",
-                [
-                    :event_set,
-                    "Diagnosis:start"
-                ],
-                [
-                    :event_set,
-                    "Treatment:end"
-                ],
-                nil
-            ]
+                :event_set,
+                "Diagnosis:start"
+            ],
+            [
+                :event_set,
+                "Treatment:end"
+            ],
+            nil
         ],
         [
-            :task_refinement,
+            :seq_st,
             [
-                :seq_st,
+                :if_st,
                 [
-                    :if_st,
+                    :bool_expr,
                     [
-                        :bool_expr,
+                        :bool_not,
                         [
-                            :bool_not,
-                            [
-                                :var_ref,
-                                "diagKnown"
-                            ]
-                        ]
-                    ],
-                    [
-                        :task_call_st,
-                        "Diagnosis"
-                    ],
-                    [
-                        :else_clause,
-                        [
-                            :task_call_st,
-                            "NoDiag"
+                            :var_ref,
+                            "diagKnown"
                         ]
                     ]
                 ],
                 [
                     :task_call_st,
-                    "Treatment"
+                    "Diagnosis"
+                ],
+                [
+                    :else_clause,
+                    [
+                        :task_call_st,
+                        "NoDiag"
+                    ]
                 ]
+            ],
+            [
+                :task_call_st,
+                "Treatment"
             ]
         ]
     ]

data/spec/fixtures/tasks/simple.gis

@@ -1,6 +1,10 @@
 task Simple
-  fluent diagKnown {Diagnosis:start}, {Treatment:end}
-  refinement
+
+  fluent diagKnown
+    {Diagnosis:start},
+    {Treatment:end}
+
+  seq
     if not(diagKnown)
       Diagnosis
     else
@@ -8,4 +12,5 @@ task Simple
     end
     Treatment
   end
+
 end

data/spec/spec_helper.rb

@@ -12,6 +12,16 @@ ensure
 end
 
 module SpecHelpers
+  include Gisele::Language::AST::Helpers
+
+  def parse(text, rule, consume = true)
+    grammar = Gisele::Language::Syntax::Grammar
+    grammar.parse(text, :root => rule, :consume => consume)
+  end
+
+  def ast(text, rule, consume = true)
+    parse(text, rule, consume).to_ast
+  end
 
   def fixtures_dir
     (Path.dir/:fixtures)

data/spec/unit/language/ast/test_node.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 module Gisele::Language::AST
   describe Node do
-    include Helpers
 
     describe 'rule_name' do
       it 'returns the first array element' do
@@ -32,24 +31,24 @@ module Gisele::Language::AST
     describe 'copy' do
 
       it 'collects block results ala `inject`' do
-        source = node([:unit, "world", "gisele"])
+        source = node([:unit_def, "world", "gisele"])
         target = source.copy do |memo,child|
           memo << child.upcase
         end
-        target.should be_a(Unit)
-        target.should eq([:unit, "WORLD", "GISELE"])
+        target.should be_a(UnitDef)
+        target.should eq([:unit_def, "WORLD", "GISELE"])
       end
 
       it 'returns a real equal copy when no children' do
-        source = node([:unit])
+        source = node([:unit_def])
         target = source.copy do |memo,child| end
         target.should eq(source)
         target.object_id.should_not eq(source.object_id)
-        target.should be_a(Unit)
+        target.should be_a(UnitDef)
       end
 
       it 'keeps the markers unchanged' do
-        node = node([:unit], {:hello => "World"})
+        node = node([:unit_def], {:hello => "World"})
         copy = node.copy do |memo,child| end
         copy.markers.should eq({:hello => "World"})
         copy.markers.object_id.should_not eq(node.markers.object_id)
@@ -60,18 +59,18 @@ module Gisele::Language::AST
     describe 'dup' do
 
       it 'duplicates the underlying array' do
-        arr = [:unit, "etc."]
+        arr = [:unit_def, "etc."]
         node(arr).dup.should eq(arr)
       end
 
       it 'ensures duplicated array is still a node' do
-        arr = [:unit, "etc."]
-        node(arr).dup.should be_a(Unit)
+        arr = [:unit_def, "etc."]
+        node(arr).dup.should be_a(UnitDef)
         node(arr).dup.should be_a(Node)
       end
 
       it 'keeps the markers unchanged' do
-        node = node([:unit, "etc."], {:hello => "World"})
+        node = node([:unit_def, "etc."], {:hello => "World"})
         copy = node.dup
         copy.markers.should eq({:hello => "World"})
         copy.markers.object_id.should_not eq(node.markers.object_id)

data/spec/unit/language/rewriter/test_helper.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+module Gisele::Language
+  class Rewriter
+    describe Helper do
+
+      class FooHelper < Helper
+        module Methods end
+
+        def on_hello(rw, node)
+          raise unless rw.is_a?(FooRewriter)
+          [:foo_hello, yield(rw, node)]
+        end
+
+      end
+
+      class FooRewriter < Rewriter
+        FooHelper.install_on(self)
+      end
+
+      describe "install_on" do
+
+        it 'installs the methods module on the rewriter' do
+          modules = FooRewriter.included_modules
+          modules.include?(FooHelper::Methods).should be_true
+        end
+
+        it 'adds an instance of the helper to the helpers list' do
+          helper = FooRewriter.helpers.last
+          helper.should be_a(FooHelper)
+        end
+
+        it 'does not polute the Rewriter class' do
+          Rewriter.helpers.size.should eq(1)
+        end
+
+      end # install_on
+
+      describe 'call' do
+
+        let(:helper)   { FooHelper.new   }
+        let(:rewriter) { FooRewriter.new }
+        let(:toplevel) {
+          Proc.new do |rw,node|
+            rw.should eq(rewriter)
+            [:toplevel, node]
+          end
+        }
+
+        it 'dispatches to the method when it exists' do
+          expected = \
+            [:foo_hello,
+              [:toplevel,
+                [:hello, "world"] ]]
+          got = helper.call(rewriter, [:hello, "world"], &toplevel)
+          got.should eq(expected)
+        end
+
+        it 'falls back to yielding when no method' do
+          expected = \
+            [:toplevel,
+              [:nosuchone] ]
+          got = helper.call(rewriter, [:nosuchone], &toplevel)
+          got.should eq(expected)
+        end
+
+        it 'calls next_in_chain when set' do
+          helper.next_in_chain = Class.new do
+            def call(rw, node)
+              raise unless rw.is_a?(FooRewriter)
+              yield rw, [:next, node]
+            end
+          end.new
+
+          expected = \
+            [:foo_hello,
+              [:toplevel,
+                [:next,
+                  [:hello, "world"] ]]]
+          got = helper.call(rewriter, [:hello, "world"], &toplevel)
+          got.should eq(expected)
+        end
+
+      end # call
+
+    end
+  end
+end

data/spec/unit/language/rewriter/test_scoping.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Gisele::Language
+  class Rewriter
+    describe Scoping do
+
+      let(:rw_class) do
+        Class.new(Rewriter) do
+
+          def on_hello(node)
+            scope_stack.dup
+          end
+
+          def on_missing(node)
+            call(node.children.last)
+          end
+
+          Scoping.install_on self
+        end
+      end
+      let(:rw){ rw_class.new }
+
+      it 'installs the methods on the rewriter' do
+        rw.respond_to?(:scope_stack).should be_true
+      end
+
+      it 'does nothing special on non _def nodes' do
+        node = [:hello, "world"]
+        rw.call(node).should eq([])
+      end
+
+      it 'keeps _def nodes as successive scopes' do
+        second = [:task_def, [:hello]]
+        first  = [:task_def, second]
+        rw.call(first).should eq([first, second])
+      end
+
+      it 'pops scopes when returning along the stack' do
+        second = [:task_def, [:hello]]
+        first  = [:task_def, second]
+        rw.call(first)
+        rw.scope_stack.should eq([])
+      end
+
+    end
+  end
+end

data/spec/unit/language/rewriter/test_work_on_nodes.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Gisele::Language
+  class Rewriter
+    describe WorkOnNodes do
+
+      let(:won){ WorkOnNodes.new }
+
+      it 'extends input nodes' do
+        node = [:hello, "world"]
+        seen = won.call(:rw, node) do |_,n|
+          n.should be_a(AST::Node)
+          n
+        end
+        seen.should eq(node)
+      end
+
+      it 'extends output nodes' do
+        node = [:hello, "world"]
+        seen = won.call(:rw, node) do |_,n|
+          n.should be_a(AST::Node)
+          [:result]
+        end
+        seen.should eq([:result])
+        seen.should be_a(AST::Node)
+      end
+
+      it 'does not require the output to be a node' do
+        node = [:hello, "world"]
+        seen = won.call(:rw, node) do |_,n|
+          n.should be_a(AST::Node)
+          "blah"
+        end
+        seen.should eq("blah")
+        seen.should_not be_a(AST::Node)
+      end
+
+      it 'fails unless the input looks a node' do
+        lambda{
+          won.call(:rw, "blah") do |_,n| end
+        }.should raise_error(ArgumentError, /blah/)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'bool_expr' do
+
+    it 'parses single variable references' do
+      parse('diagKnown', :bool_expr).should eq('diagKnown')
+    end
+
+    it 'parses boolean literals' do
+      parse('true',  :bool_expr).should eq('true')
+      parse('false', :bool_expr).should eq('false')
+    end
+
+    it 'parses negated expression' do
+      parse('not diagKnown', :bool_expr).should eq('not diagKnown')
+      parse('not true', :bool_expr).should eq('not true')
+      parse('not false', :bool_expr).should eq('not false')
+    end
+
+    it 'parses or expressions' do
+      parse('diagKnown or platLow', :bool_expr).should eq('diagKnown or platLow')
+    end
+
+    it 'parses and expressions' do
+      parse('diagKnown and platLow', :bool_expr).should eq('diagKnown and platLow')
+    end
+
+    it 'parses complex expressions' do
+      expr = 'diagKnown and (platLow or not(metastased and mplus))'
+      parse(expr, :bool_expr).should eq(expr)
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe Grammar, 'boolean_literal' do
+
+    it 'parses booleans' do
+      parse('true',  :boolean_literal).should eq('true')
+      parse('false', :boolean_literal).should eq('false')
+    end
+
+    it 'does not parses integers' do
+      lambda{
+        parse('0', :boolean_literal)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end