gisele 0.2.0 → 0.3.0

data/lib/gisele/language/sugar_removal.rb

@@ -1,74 +1,12 @@
 module Gisele
   module Language
-    class SugarRemoval < Transformer
+    class SugarRemoval < Rewriter
       alias :on_missing :copy_and_applyall
 
       def on_if_st(node)
-        IfToGuardedCommands.new(self).call(node)
+        ElsifFlattener.new(:mainflow => self).call(node)
       end
 
-      class IfToGuardedCommands < Transformer
-
-        def initialize(main)
-          @main = main
-        end
-
-        def on_if_st(node)
-          condition, dost, *clauses = node.children
-
-          # create case_st with same markers as the if_st
-          when_clause = [:when_clause, condition, @main.call(dost)]
-          when_clause = node(when_clause, node.markers.dup)
-          base        = [:case_st, when_clause]
-          base        = node(base, node.markers.dup)
-
-          # this is the condition for elsif clauses
-          @condition = negate(condition.last)
-
-          # make injection now
-          clauses.inject base do |memo,clause|
-            memo << call(clause)
-          end
-        end
-
-        def on_elsif_clause(node)
-          condition, dost, = node.children
-
-          # install new conditions for me and next elsif clauses
-          condition = condition.last
-          previous  = @condition
-          @condition = [:bool_and, negate(condition), @condition]
-
-          # convert elsif to when and keep the markers
-          base = \
-            [:when_clause,
-              [:bool_expr, [:bool_and, condition, previous]],
-              @main.call(dost) ]
-          node(base, node.markers.dup)
-        end
-
-        def on_else_clause(node)
-          dost, = node.children
-
-          # convert else to when and keep the markers
-          base = \
-            [:when_clause,
-              [:bool_expr, @condition],
-              @main.call(dost)]
-          node(base, node.markers.dup)
-        end
-
-        private
-
-        def negate(cond)
-          if cond.rule_name == :bool_not
-            cond.last
-          else
-            [:bool_not, cond]
-          end
-        end
-
-      end # class IfToGuardedCommands
     end # class SugarRemoval
   end # module Language
 end # module Gisele

data/lib/gisele/language/syntax/case_st.rb

@@ -0,0 +1,19 @@
+module Gisele
+  module Language
+    module Syntax
+      module CaseSt
+        include Node
+
+        def _to_ast
+          var     = captures[:var_ref].first
+          var     = var.to_ast if var
+          var     = nil if var && var.empty?
+          whens   = captures[:when_clause].map{|x| x.to_ast}
+          els     = captures[:else_clause].map{|x| x.to_ast}
+          [:case_st, var] + whens + els
+        end
+
+      end # module CaseSt
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/syntax/grammar.citrus

@@ -2,30 +2,23 @@ grammar Gisele::Language::Syntax::Grammar
 
   ### Units
 
-  rule unit
-    ((spacing task_def)* spacing)
-    <Gisele::Language::Syntax::Unit>
+  rule unit_def
+    (spacing task_def (spaces task_def)* spacing)
+    <Gisele::Language::Syntax::UnitDef>
   end
 
   ### Task definitions
 
   rule task_def
-    ('task' spaces task_name spaces (task_signature spaces)? (task_refinement spaces)? 'end')
+    ('task' spaces task_name spaces 
+      (some_def spaces)*
+      (explicit_statement spaces)?
+    'end')
     <Gisele::Language::Syntax::TaskDef>
   end
 
-  rule task_signature
-    (task_signature_element (spaces task_signature_element)*)
-    <Gisele::Language::Syntax::TaskSignature>
-  end
-
-  rule task_signature_element
-    fluent_def | trackvar_def
-  end
-
-  rule task_refinement
-    ('refinement' spaces process_statement spaces 'end')
-    <Gisele::Language::Syntax::TaskRefinement>
+  rule some_def
+    fluent_def | trackvar_def | task_def
   end
 
   ### Process statements
@@ -46,24 +39,42 @@ grammar Gisele::Language::Syntax::Grammar
 
   rule explicit_statement
       if_st
+    | case_st
     | while_st
     | seq_st
     | par_st
     | task_call_st
   end
 
+  rule case_st
+    ('case' spaces (var_ref spaces)?
+      (when_clause spaces)+
+      (else_clause spaces)?
+    'end')
+    <Gisele::Language::Syntax::CaseSt>
+  end
+
+  rule when_clause
+    ('when' spaces bool_expr spaces process_statement)
+    <Gisele::Language::Syntax::WhenClause>
+  end
+
   rule if_st
-    ('if' spaces bool_expr spaces process_statement spaces elsif_clause* else_clause? 'end')
+    ('if' spaces bool_expr spaces 
+      process_statement spaces 
+      (elsif_clause spaces)* 
+      (else_clause spaces)? 
+    'end')
     <Gisele::Language::Syntax::IfSt>
   end
 
   rule elsif_clause
-    ('elsif' spaces bool_expr spaces process_statement spaces)
+    ('elsif' spaces bool_expr spaces process_statement)
     <Gisele::Language::Syntax::ElsifClause>
   end
 
   rule else_clause
-    ('else' spaces process_statement spaces)
+    ('else' spaces process_statement)
     <Gisele::Language::Syntax::ElseClause>
   end
 
@@ -113,7 +124,7 @@ grammar Gisele::Language::Syntax::Grammar
   end
 
   rule bool_term
-    bool_paren | bool_lit | bool_varref
+    bool_paren | bool_lit | var_ref
   end
 
   rule bool_paren
@@ -126,11 +137,6 @@ grammar Gisele::Language::Syntax::Grammar
     <Gisele::Language::Syntax::BoolLit>
   end
 
-  rule bool_varref
-    (variable_name)
-    <Gisele::Language::Syntax::VarRef>
-  end
-
   ### Variables
 
   rule variable_def
@@ -151,6 +157,11 @@ grammar Gisele::Language::Syntax::Grammar
     (spaces 'initially' spaces lit:boolean_literal){ lit.value }
   end
 
+  rule var_ref
+    (variable_name)
+    <Gisele::Language::Syntax::VarRef>
+  end
+
   ### Events
 
   rule event_set
@@ -173,11 +184,11 @@ grammar Gisele::Language::Syntax::Grammar
   end
 
   rule variable_name
-    [a-z] [A-Za-z0-9_]*
+    !(reserved_word spaces) [a-z] [A-Za-z0-9_]*
   end
 
   rule event_name
-    [a-z] [a-z0-9_]*
+    !(reserved_word spaces) [a-z] [a-z0-9_]*
   end
 
   ### Literals
@@ -200,4 +211,26 @@ grammar Gisele::Language::Syntax::Grammar
     (comment | [ \t\n])*
   end
 
-end
+  ### Reserved Words
+  rule reserved_word
+      "if"
+    | "else"
+    | "elsif"
+    | "when"
+    | "while"
+    | "seq"
+    | "par"
+    | "task"
+    | "refinement"
+    | "fluent"
+    | "trackvar"
+    | "initially"
+    | "end"
+    | "not"
+    | "or"
+    | "and"
+    | "true"
+    | "false"
+  end
+
+end

data/lib/gisele/language/syntax/node.rb

@@ -30,7 +30,7 @@ require_relative 'while_st'
 require_relative 'if_st'
 require_relative 'else_clause'
 require_relative 'elsif_clause'
-require_relative 'task_refinement'
-require_relative 'task_signature'
+require_relative 'case_st'
+require_relative 'when_clause'
 require_relative 'task_def'
-require_relative 'unit'
+require_relative 'unit_def'

data/lib/gisele/language/syntax/task_def.rb

@@ -5,10 +5,11 @@ module Gisele
         include Node
 
         def _to_ast
-          name = captures[:task_name].first.strip
-          sig  = captures[:task_signature].map{|x| x.to_ast}.first || [:task_signature]
-          ref  = captures[:task_refinement].map{|x| x.to_ast}.first || [:task_refinement]
-          [:task_def, name, sig, ref]
+          name  = captures[:task_name].first.strip
+          defs  = captures[:some_def].map{|x| x.to_ast}
+          ref   = captures[:explicit_statement].map{|x| x.to_ast}.first
+          ref   = [:nop] unless ref
+          [:task_def, name] + defs + [ref]
         end
 
       end # module TaskDef

data/lib/gisele/language/syntax/{unit.rb → unit_def.rb}

@@ -1,14 +1,14 @@
 module Gisele
   module Language
     module Syntax
-      module Unit
+      module UnitDef
         include Node
 
         def _to_ast
-          [:unit] + captures[:task_def].map{|x| x.to_ast}
+          [:unit_def] + captures[:task_def].map{|x| x.to_ast}
         end
 
-      end # module Unit
+      end # module UnitDef
     end # module Syntax
   end # module Language
 end # module Gisele

data/lib/gisele/language/syntax/when_clause.rb

@@ -0,0 +1,16 @@
+module Gisele
+  module Language
+    module Syntax
+      module WhenClause
+        include Node
+
+        def _to_ast
+          cond = captures[:bool_expr].first.to_ast
+          dost = captures[:process_statement].first.to_ast
+          [:when_clause, cond, dost]
+        end
+
+      end # module WhenClause
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/to_graph.rb

@@ -1,31 +1,33 @@
 module Gisele
   module Language
-    class ToGraph < Transformer
+    class ToGraph < Rewriter
       module Connector; end
 
-      def recurse_on_last(node)
-        call(node.last)
+      def on_unit_def(node)
+        node.
+          children.
+          select{|n| n.first == :task_def}.
+          map{|taskdef| call(taskdef) }
       end
-      alias :on_unit :recurse_on_last
 
       def on_task_def(node)
         @graph = Yargi::Digraph.new
-        call(SugarRemoval.new.call(node.last))
+
+        entry, exit = add_vertex(node), add_vertex(node)
+
+        # flatten all elsif
+        c_entry, c_exit = call(ElsifFlattener.new.call(node.last))
+        connect(entry, c_entry)
+        connect(c_exit, exit)
+
         @graph.vertices(Connector).each do |vertex|
           next unless vertex.out_edges.size == 1
           target = vertex.out_edges.first.target
           @graph.reconnect(vertex.in_edges, nil, target)
           @graph.remove_vertex(vertex)
         end
-        @graph
-      end
 
-      def on_task_refinement(node)
-        entry, exit = add_vertex(node), add_vertex(node)
-        c_entry, c_exit = call(node.last)
-        connect(entry, c_entry)
-        connect(c_exit, exit)
-        [entry, exit]
+        @graph
       end
 
       def on_seq_st(node)
@@ -50,15 +52,40 @@ module Gisele
         [entry, exit]
       end
 
+      def on_if_st(node)
+        cond, then_clause, else_clause, = node.children
+
+        entry, exit = entry_and_exit(node)
+
+        diamond = add_vertex(node)
+        connect(entry, diamond)
+
+        c_entry, c_exit = call(then_clause)
+        connect(diamond, c_entry, true_ast_node)
+        connect(c_exit, exit)
+
+        if else_clause
+          c_entry, c_exit = call(else_clause.last)
+          connect(diamond, c_entry, false_ast_node)
+          connect(c_exit, exit)
+        else
+          connect(diamond, exit, false_ast_node)
+        end
+
+        [entry, exit]
+      end
+
       def on_case_st(node)
+        cond, *clauses = node.children
+
         entry, exit = entry_and_exit(node)
 
         diamond = add_vertex(node)
         connect(entry, diamond)
 
-        node.children.each do |when_clause|
-          c_entry, c_exit = call(when_clause.last)
-          connect(diamond, c_entry, when_clause)
+        clauses.each do |clause|
+          c_entry, c_exit = call(clause.last)
+          connect(diamond, c_entry, clause)
           connect(c_exit, exit)
         end
 

data/lib/gisele/language.rb

@@ -1,8 +1,30 @@
 module Gisele
   module Language
 
+    require 'yaml'
     DOT_ATTRIBUTES = YAML.load_file(Path.dir/"language/dot.yml")
 
+    RESERVED_WORDS = [
+      "if",
+      "else",
+      "elsif",
+      "when",
+      "while",
+      "seq",
+      "par",
+      "task",
+      "refinement",
+      "fluent",
+      "trackvar",
+      "initially",
+      "end",
+      "not",
+      "or",
+      "and",
+      "true",
+      "false"
+    ]
+
     def rule2mod(rule)
       rule.to_s.gsub(/(^|_)([a-z])/){|x| $2.capitalize}.to_sym
     end
@@ -18,6 +40,8 @@ module Gisele
 end # module Gisele
 require_relative 'language/syntax'
 require_relative 'language/ast'
-require_relative 'language/transformer'
+require_relative 'language/rewriter'
+require_relative 'language/elsif_flattener'
+require_relative 'language/if_to_case'
 require_relative 'language/sugar_removal'
 require_relative 'language/to_graph'

data/lib/gisele/version.rb

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

data/spec/command/main/gisele_ast_ruby.stdout

@@ -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/command/main/gisele_graph.stdout

@@ -3,28 +3,38 @@ digraph G {
   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=""]
+  V3 [shape="diamond" label="everyoneHappy"]
   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"]
+  V8 [shape="diamond" label="someoneHappy"]
+  V9 [shape="box" label="DrinkBeer"]
+  V10 [shape="box" label="DoNothingSpecial"]
+  V11 [shape="diamond" label="not(endOfTheDay)"]
+  V12 [shape="diamond" label="curState"]
+  V13 [shape="box" label="DoSomething"]
+  V14 [shape="box" label="DoNothing"]
+  V15 [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"]
+  V3 -> V4 [label="true"]
+  V5 -> V11 []
+  V9 -> V11 []
+  V8 -> V9 [label="true"]
+  V10 -> V11 []
+  V8 -> V10 [label="false"]
+  V3 -> V8 [label="false"]
+  V13 -> V11 []
+  V12 -> V13 [label="somethingToDo"]
+  V14 -> V11 []
+  V12 -> V14 [label="nothingToDo"]
+  V15 -> V11 []
+  V12 -> V15 [label="[else]"]
+  V11 -> V1 [label="false"]
+  V11 -> V12 [label="true"]
   V0 -> V2 []
 }

data/spec/command/main/gisele_help.stdout

@@ -26,7 +26,7 @@ DESCRIPTION
   array for automatic processing.
 
   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 
+  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.cmd

@@ -1 +1 @@
-gisele --no-sugar --ast=ruby tasks/simple.gis
+gisele --no-sugar --ast=ruby tasks/complete.gis