gisele 0.1.0 → 0.2.0

data/lib/gisele/language.rb

@@ -1,6 +1,8 @@
 module Gisele
   module Language
 
+    DOT_ATTRIBUTES = YAML.load_file(Path.dir/"language/dot.yml")
+
     def rule2mod(rule)
       rule.to_s.gsub(/(^|_)([a-z])/){|x| $2.capitalize}.to_sym
     end
@@ -17,4 +19,5 @@ end # module Gisele
 require_relative 'language/syntax'
 require_relative 'language/ast'
 require_relative 'language/transformer'
-require_relative 'language/sugar_removal'
+require_relative 'language/sugar_removal'
+require_relative 'language/to_graph'

data/lib/gisele/loader.rb

@@ -2,3 +2,4 @@ require "citrus"
 require "epath"
 require "quickl"
 require "awesome_print"
+require "yargi"

data/lib/gisele/version.rb

@@ -2,7 +2,7 @@ module Gisele
   module Version
 
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     def self.to_s

data/spec/command/main/gisele_ast_ruby.stdout

@@ -26,10 +26,13 @@
                 [
                     :if_st,
                     [
-                        :bool_not,
+                        :bool_expr,
                         [
-                            :var_ref,
-                            "diagKnown"
+                            :bool_not,
+                            [
+                                :var_ref,
+                                "diagKnown"
+                            ]
                         ]
                     ],
                     [

data/spec/command/main/gisele_graph.cmd

@@ -0,0 +1 @@
+gisele --graph tasks/complete.gis

data/spec/command/main/gisele_graph.stdout

@@ -0,0 +1,30 @@
+digraph G {
+  graph[]
+  V0 [shape="circle" style="filled" fillcolor="black" fixed="true" width="0.1" label=""]
+  V1 [shape="circle" style="filled" fillcolor="black" fixed="true" width="0.1" label=""]
+  V2 [shape="box" label="FirstTask"]
+  V3 [shape="diamond" label=""]
+  V4 [shape="box" height="0.1" style="filled" fillcolor="black" label=""]
+  V5 [shape="box" height="0.1" style="filled" fillcolor="black" label=""]
+  V6 [shape="box" label="MakeJoy"]
+  V7 [shape="box" label="DrinkBeers"]
+  V8 [shape="box" label="DrinkBeer"]
+  V9 [shape="box" label="DoNothingSpecial"]
+  V10 [shape="diamond" label="not(endOfTheDay)"]
+  V11 [shape="box" label="WaitAndSee"]
+  V2 -> V3 []
+  V6 -> V5 []
+  V4 -> V6 []
+  V7 -> V5 []
+  V4 -> V7 []
+  V3 -> V4 [label="everyoneHappy"]
+  V5 -> V10 []
+  V8 -> V10 []
+  V3 -> V8 [label="(someoneHappy and not(everyoneHappy))"]
+  V9 -> V10 []
+  V3 -> V9 [label="(not(someoneHappy) and not(everyoneHappy))"]
+  V11 -> V10 []
+  V10 -> V1 [label="false"]
+  V10 -> V11 [label="true"]
+  V0 -> V2 []
+}

data/spec/command/main/gisele_help.stdout

@@ -3,11 +3,12 @@ Gisele - A Process Analyzer Toolset
 
 SYNOPSIS
   gisele [--version] [--help]
-  gisele [--ast] PROCESS_FILE
+  gisele [--ast | --graph] PROCESS_FILE
 
 OPTIONS
       --ast=[MODE]                 Prints the process abstract syntax tree (debug,ruby)
       --no-sugar                   Apply syntactic sugar removal
+      --graph=[MODE]               Converts and print a graph (dot)
       --help                       Show this help message
       --version                    Show version and exit
 
@@ -15,13 +16,17 @@ DESCRIPTION
   The Gisele process analyzer toolset provides tools and technique to model and analyze
   complex process models such as care processes.
 
-  When --ast is used, the command parses a process file and prints its Abstract Syntax
+  When --no-sugar is specified, syntactic sugar is first removed before making any other
+  transformation. For now, this rewrites all `if` statements as explicit `case` guarded
+  commands.
+
+  When --ast is used, the command parses the process file and prints its Abstract Syntax
   Tree (AST) on standard output. By default, this option prints the AST for manual
   debugging, that is with colors and extra information. Use --ast=ruby to get a ruby
   array for automatic processing.
 
-  When --no-sugar is specified, syntactic sugar is first removed before making any other
-  transformation. For now, this rewrites all `if` statements as explicit `case` guarded
-  commands.
+  When --graph is used, the command parses the process file. It then converts the AST into
+  a directed graph representing the process as a box-and-arrow workflow and outputs it on 
+  standard output. For now, the only output format available is dot (from graphviz).
 
 SystemExit

data/spec/command/main/gisele_no_sugar.stdout

@@ -28,10 +28,13 @@
                     [
                         :when_clause,
                         [
-                            :bool_not,
+                            :bool_expr,
                             [
-                                :var_ref,
-                                "diagKnown"
+                                :bool_not,
+                                [
+                                    :var_ref,
+                                    "diagKnown"
+                                ]
                             ]
                         ],
                         [
@@ -42,8 +45,11 @@
                     [
                         :when_clause,
                         [
-                            :var_ref,
-                            "diagKnown"
+                            :bool_expr,
+                            [
+                                :var_ref,
+                                "diagKnown"
+                            ]
                         ],
                         [
                             :task_call_st,

data/spec/command/main/gisele_version.stdout

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

data/spec/fixtures/tasks/complete.gis

@@ -0,0 +1,18 @@
+task Complete
+  refinement
+    FirstTask
+    if everyoneHappy
+      par
+        MakeJoy
+        DrinkBeers
+      end
+    elsif someoneHappy
+      DrinkBeer
+    else
+      DoNothingSpecial
+    end
+    while not(endOfTheDay)
+      WaitAndSee
+    end
+  end
+end

data/spec/fixtures/tasks/simple.ast

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

data/spec/spec_helper.rb

@@ -21,6 +21,14 @@ module SpecHelpers
     fixtures_dir.glob(glob)
   end
 
+  def simple_ast
+    Gisele::ast(fixtures_dir/:tasks/"simple.gis")
+  end
+
+  def complete_ast
+    Gisele::ast(fixtures_dir/:tasks/"complete.gis")
+  end
+
 end
 
 RSpec.configure do |c|

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

@@ -21,6 +21,14 @@ module Gisele::Language::AST
 
     end # children
 
+    describe 'markers' do
+
+      it 'defaults to an empty hash' do
+        node([:hello]).markers.should eq({})
+      end
+
+    end # markers
+
     describe 'copy' do
 
       it 'collects block results ala `inject`' do
@@ -40,6 +48,13 @@ module Gisele::Language::AST
         target.should be_a(Unit)
       end
 
+      it 'keeps the markers unchanged' do
+        node = node([:unit], {: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)
+      end
+
     end
 
     describe 'dup' do
@@ -55,6 +70,13 @@ module Gisele::Language::AST
         node(arr).dup.should be_a(Node)
       end
 
+      it 'keeps the markers unchanged' do
+        node = node([:unit, "etc."], {:hello => "World"})
+        copy = node.dup
+        copy.markers.should eq({:hello => "World"})
+        copy.markers.object_id.should_not eq(node.markers.object_id)
+      end
+
     end # dup
 
   end

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

@@ -16,7 +16,9 @@ module Gisele::Language
         source   = ast("if goodCond Task1 end")
         expected = \
           [:case_st,
-            [:when_clause, [:var_ref, "goodCond"], [:task_call_st, "Task1"] ]]
+            [:when_clause,
+              [:bool_expr, [:var_ref, "goodCond"]],
+              [:task_call_st, "Task1"] ]]
         rewrite(source).should eq(expected)
       end
 
@@ -24,8 +26,12 @@ module Gisele::Language
         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"] ]
+            [: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
@@ -41,26 +47,26 @@ module Gisele::Language
         expected = \
           [:case_st,
             [:when_clause,
-              [:var_ref, "c1"],
+              [:bool_expr, [:var_ref, "c1"]],
               [:task_call_st, "Task1"] ],
             [:when_clause,
-              [:bool_and,
+              [:bool_expr, [:bool_and,
                 [:var_ref, "c2"],
-                [:bool_not, [:var_ref, "c1"]] ],
+                [:bool_not, [:var_ref, "c1"]] ]],
               [:task_call_st, "Task2"] ],
             [:when_clause,
-              [:bool_and,
+              [:bool_expr, [:bool_and,
                 [:var_ref, "c3"],
                 [:bool_and,
                   [:bool_not, [:var_ref, "c2"]],
-                  [:bool_not, [:var_ref, "c1"]] ]],
+                  [:bool_not, [:var_ref, "c1"]] ]]],
               [:task_call_st, "Task3"] ],
             [:when_clause,
-              [:bool_and,
+              [:bool_expr, [:bool_and,
                 [:bool_not, [:var_ref, "c3"]],
                 [:bool_and,
                   [:bool_not, [:var_ref, "c2"]],
-                  [:bool_not, [:var_ref, "c1"]]]],
+                  [:bool_not, [:var_ref, "c1"]]]]],
               [:task_call_st, "Task4"] ],
           ]
         rewrite(source).should eq(expected)
@@ -71,10 +77,10 @@ module Gisele::Language
         expected = \
           [:case_st,
             [:when_clause,
-              [:bool_not, [:var_ref, "goodCond"]],
+              [:bool_expr, [:bool_not, [:var_ref, "goodCond"]]],
               [:task_call_st, "Task1"] ],
             [:when_clause,
-              [:var_ref, "goodCond"],
+              [:bool_expr, [:var_ref, "goodCond"]],
               [:task_call_st, "Task2"] ] ]
         rewrite(source).should eq(expected)
       end
@@ -85,6 +91,20 @@ module Gisele::Language
         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
 end

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

@@ -11,20 +11,27 @@ module Gisele::Language::Syntax
     describe "the bool_expr rule" do
 
       it 'returns expected ast on simple expressions' do
-        expected = [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]]
+        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_or, [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]], [:var_ref, "platHigh"]]
+        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_not, [:bool_not, [:var_ref, "diagKnown"]]]
+        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 # bool_expr
 
     describe 'the event_set rule' do
@@ -131,7 +138,7 @@ module Gisele::Language::Syntax
         expr     = "while goodCond Task1 end"
         expected = \
           [:while_st,
-            [:var_ref, "goodCond"],
+            [:bool_expr, [:var_ref, "goodCond"]],
             [:task_call_st, "Task1"]]
         ast(expr, :while_st).should eq(expected)
       end
@@ -140,7 +147,7 @@ module Gisele::Language::Syntax
         expr     = "while goodCond Task1 Task2 end"
         expected = \
           [:while_st,
-            [:var_ref, "goodCond"],
+            [:bool_expr, [:var_ref, "goodCond"]],
             [:seq_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]]
         ast(expr, :while_st).should eq(expected)
       end
@@ -163,7 +170,9 @@ module Gisele::Language::Syntax
       it 'parses as expected' do
         expr     = "elsif goodCond Task1 "
         expected = \
-          [:elsif_clause, [:var_ref, "goodCond"], [:task_call_st, "Task1"]]
+          [:elsif_clause,
+            [:bool_expr, [:var_ref, "goodCond"]],
+            [:task_call_st, "Task1"]]
         ast(expr, :elsif_clause).should eq(expected)
       end
 
@@ -174,7 +183,9 @@ module Gisele::Language::Syntax
       it 'parses as expected' do
         expr     = "if goodCond Task1 end"
         expected = \
-          [:if_st, [:var_ref, "goodCond"], [:task_call_st, "Task1"]]
+          [:if_st,
+            [:bool_expr, [:var_ref, "goodCond"]],
+            [:task_call_st, "Task1"]]
         ast(expr, :if_st).should eq(expected)
       end
 
@@ -182,7 +193,8 @@ module Gisele::Language::Syntax
         expr     = "if goodCond Task1 else Task2 end"
         expected = \
           [:if_st,
-            [:var_ref, "goodCond"], [:task_call_st, "Task1"],
+            [:bool_expr, [:var_ref, "goodCond"]],
+            [:task_call_st, "Task1"],
             [:else_clause, [:task_call_st, "Task2"]] ]
         ast(expr, :if_st).should eq(expected)
       end
@@ -191,11 +203,11 @@ module Gisele::Language::Syntax
         expr     = "if goodCond Task1 elsif otherCond Task2 elsif stillAnother Task3 else Task4 end"
         expected = \
           [:if_st,
-            [:var_ref, "goodCond"], [:task_call_st, "Task1"],
+            [:bool_expr, [:var_ref, "goodCond"]], [:task_call_st, "Task1"],
             [:elsif_clause,
-              [:var_ref, "otherCond"], [:task_call_st, "Task2"]],
+              [:bool_expr, [:var_ref, "otherCond"]], [:task_call_st, "Task2"]],
             [:elsif_clause,
-              [:var_ref, "stillAnother"], [:task_call_st, "Task3"]],
+              [:bool_expr, [:var_ref, "stillAnother"]], [:task_call_st, "Task3"]],
             [:else_clause,
               [:task_call_st, "Task4"]] ]
         ast(expr, :if_st).should eq(expected)

data/spec/unit/language/test_syntax.rb

@@ -30,6 +30,11 @@ module Gisele::Language
         ast.first.should eq(:if_st)
       end
 
+      it 'sets traceability marks correctly' do
+        ast = ast("if goodCond Task1 end", :root => :if_st)
+        ast.markers[:match].should_not be_nil
+      end
+
       fixture_files('tasks/**/*.gis').each do |file|
         it "works on #{file}" do
           parsed = Syntax.ast(file)

data/spec/unit/language/test_to_graph.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Gisele::Language
+  describe ToGraph do
+
+    it 'returns a Digraph' do
+      ToGraph.new.call(complete_ast).should be_a(Yargi::Digraph)
+    end
+
+  end
+end