gisele 0.4.0 → 0.5.0

data/CHANGELOG.md

@@ -1,6 +1,26 @@
+# 0.5.0 / 2012-02-26
+
+* Major enhancements
+
+  * All s-expression tools have been moved to a separated project called `Sexpr` (see
+    https://github.com/blambeau/sexpr). This implies a lot of changes here, but mostly
+    to private APIs. In particular, the commandline tool and the language grammar have not
+    changed.
+  * A --glts option has been added to the gisele commandline tool, that outputs a guarded
+    labeled transition system. The option follows the g-hMSC -> g-LTS semantics defined
+    in [Dam09, Lam11].
+
+* Breaking changes
+
+  * `ToGraph` has been moved under `Gisele::Compiling` instead of `Gisele::Language`.
+  * `Language::AST::Node#dot_attributes` has been removed as it is very specific to the
+    ToGraph compiler and not a language construction.
+  * In the same vein, language/grammar.dot.yml -> compiling/to_graph.yml
+  * Also, `Language::DOT_ATTRIBUTES` -> `Compiling::ToGraph::DOT_ATTRIBUTES`
+
 # 0.4.0 / 2012-02-20
 
-* Major enhancement
+* Major enhancements
 
   * The grammar is going to be stable very soon now (expect backward compatible additions,
     maybe). As an helper to work with the grammar, a YAML file describing the structure of
@@ -9,9 +29,9 @@
 * Breaking changes
 
   * The :nop statement has been renamed :nop_st.
-  * The kind of the AST nodes for fluent and tracking variable definitions have been renamed
-    :fluent_def and :trackvar_def. This is actually a bugfix but that might break other code
-    relying on 0.3.0.
+  * The kind of the AST nodes for fluent and tracking variable definitions have been
+    renamed :fluent_def and :trackvar_def. This is actually a bugfix but that might break
+    other code relying on 0.3.0.
 
 # 0.3.0 / 2012-02-20
 
@@ -24,8 +44,8 @@
 
 * Minor enhancements
 
-  * The --graph option now outputs one graph for each task_def in the unit. Previously only
-    the graph of the last task definition was printed.
+  * The --graph option now outputs one graph for each task_def in the unit. Previously
+    only the graph of the last task definition was printed.
 
 * Bugfixes
 
@@ -34,10 +54,10 @@
 
 * Breaking changes
 
-  * The syntax and AST of a task definition has changed. The "refinement ... end" construct
-    has been removed and replaced by an explicit process statement. Accordingly, the nodes
-    task_refinement and task_signature have been removed as well. The AST signature of a task
-    definition is now as follows:
+  * The syntax and AST of a task definition has changed. The "refinement ... end"
+    construct has been removed and replaced by an explicit process statement. Accordingly,
+    the nodes task_refinement and task_signature have been removed as well. The AST
+    signature of a task definition is now as follows:
 
             [:task_def, "TaskName", (fluent_def, trackvar_def, task_def)*, explicit_statement]
 
@@ -52,9 +72,9 @@
 
   * Boolean literals (true, false) are now explicitly represented in boolean expressions,
     under a :bool_lit AST node.
-  * All statements and clauses relying on boolean conditions (if_st, while_st, elsif_clause,
-    when_clause) have now an explicit :bool_expr node as first child. Previously, a subnode
-    of the boolean grammar was used.
+  * All statements and clauses relying on boolean conditions (if_st, while_st,
+    elsif_clause, when_clause) have now an explicit :bool_expr node as first child.
+    Previously, a subnode of the boolean grammar was used.
 
 # 0.1.0 / 2012-02-17
 

data/Gemfile

@@ -6,12 +6,13 @@ group :runtime do
   gem "quickl", "~> 0.4.3"
   gem "awesome_print", "~> 1.0"
   gem "yargi", "~> 0.2.0"
-  gem "sexp_grammar", "~> 0.1.0"
+  gem "sexpr", "~> 0.5.0"
+  gem "stamina-core", "~> 0.5.3"
 end
 
 group :development do
   gem "rake", "~> 0.9.2"
   gem "bundler", "~> 1.0"
-  gem "rspec", "~> 2.8.0"
+  gem "rspec", "~> 2.8"
   gem "wlang", "~> 0.10.2"
 end

data/Gemfile.lock

@@ -15,7 +15,9 @@ GEM
     rspec-expectations (2.8.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.8.0)
-    sexp_grammar (0.1.0)
+    sexpr (0.5.0)
+    stamina-core (0.5.3)
+      quickl (~> 0.4.3)
     wlang (0.10.2)
     yargi (0.2.0)
 
@@ -30,7 +32,8 @@ DEPENDENCIES
   epath (~> 0.0.1)
   quickl (~> 0.4.3)
   rake (~> 0.9.2)
-  rspec (~> 2.8.0)
-  sexp_grammar (~> 0.1.0)
+  rspec (~> 2.8)
+  sexpr (~> 0.5.0)
+  stamina-core (~> 0.5.3)
   wlang (~> 0.10.2)
   yargi (~> 0.2.0)

data/LICENCE.md

@@ -19,4 +19,4 @@
     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
     LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
     OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,5 +1,8 @@
 # Gisele
 
+[![Build Status](https://secure.travis-ci.org/blambeau/gisele.png)](http://travis-ci.org/blambeau/gisele)
+[![Dependency Status](https://gemnasium.com/blambeau/gisele.png)](https://gemnasium.com/blambeau/gisele)
+
 Gisele is a Process Analyzer Toolset
 
 ## Description
@@ -14,7 +17,7 @@ This project requires an installation of ruby >= 1.9.2. Then,
     gem install gisele
     gisele --help
 
-For contributors (UCLouvain students, in particular), please consider the following 
+For contributors (UCLouvain students, in particular), please consider the following
 scenario:
 
     gem install bundler --pre
@@ -26,5 +29,5 @@ scenario:
 
 ## Contributing
 
-Gisele is distributed under a MIT license. The common github workflow (fork/pull request) 
+Gisele is distributed under a MIT license. The common github workflow (fork/pull request)
 applies. Please take contact with Bernard Lambeau with any question.

data/Rakefile

@@ -1,11 +1,3 @@
-begin
-  gem "bundler", "~> 1.0"
-  require "bundler/setup"
-rescue LoadError => ex
-  puts ex.message
-  abort "Bundler failed to load, (did you run 'gem install bundler' ?)"
-end
-
 # Dynamically load the gem spec
 $gemspec_file = File.expand_path('../gisele.gemspec', __FILE__)
 $gemspec      = Kernel.eval(File.read($gemspec_file))

data/examples/rectal-cancer-pathway/RectalCancerPathway.gis

@@ -61,4 +61,4 @@ task RectalCancerPathway
     end
   end
 
-end
+end

data/gisele.gemspec

@@ -125,14 +125,15 @@ Gem::Specification.new do |s|
   #
   s.add_development_dependency("rake", "~> 0.9.2")
   s.add_development_dependency("bundler", "~> 1.0")
-  s.add_development_dependency("rspec", "~> 2.8.0")
+  s.add_development_dependency("rspec", "~> 2.8")
   s.add_development_dependency("wlang", "~> 0.10.2")
   s.add_dependency("citrus", "~> 2.4")
   s.add_dependency("epath", "~> 0.0.1")
   s.add_dependency("quickl", "~> 0.4.3")
   s.add_dependency("awesome_print", "~> 1.0")
   s.add_dependency("yargi", "~> 0.2.0")
-  s.add_dependency("sexp_grammar", "~> 0.1.0")
+  s.add_dependency("sexpr", "~> 0.5.0")
+  s.add_dependency("stamina-core", "~> 0.5.3")
 
   # The version of ruby required by this gem
   #

data/gisele.noespec

@@ -12,7 +12,7 @@ variables:
   upper:
     Gisele
   version:
-    0.4.0
+    0.5.0
   summary: |-
     Gisele is a Process Analyzer Toolset
   description: |-
@@ -30,9 +30,10 @@ variables:
     - {name: quickl,        version: "~> 0.4.3",  groups: [runtime]}
     - {name: awesome_print, version: "~> 1.0",    groups: [runtime]}
     - {name: yargi,         version: "~> 0.2.0",  groups: [runtime]}
-    - {name: sexp_grammar,  version: "~> 0.1.0",  groups: [runtime]}
+    - {name: sexpr,         version: "~> 0.5.0",  groups: [runtime]}
+    - {name: stamina-core,  version: "~> 0.5.3",  groups: [runtime]}
     #
     - {name: rake,      version: "~> 0.9.2",  groups: [development]}
     - {name: bundler,   version: "~> 1.0",    groups: [development]}
-    - {name: rspec,     version: "~> 2.8.0",  groups: [development]}
+    - {name: rspec,     version: "~> 2.8",    groups: [development]}
     - {name: wlang,     version: "~> 0.10.2", groups: [development]}

data/lib/gisele.rb

@@ -6,15 +6,19 @@ require_relative 'gisele/errors'
 #
 module Gisele
 
-  def parse(input)
-    Language::Syntax::parse(input)
+  def parse(*args)
+    Language::parse(*args)
   end
-  module_function :parse
 
-  def ast(input)
-    Language::Syntax::ast(input)
+  def ast(*args)
+    Language::sexpr(*args)
   end
-  module_function :ast
 
+  def sexpr(*args)
+    Language::sexpr(*args)
+  end
+
+  extend(self)
 end # module Gisele
-require_relative 'gisele/language'
+require_relative 'gisele/language'
+require_relative 'gisele/compiling'

data/lib/gisele/command.rb

@@ -31,18 +31,25 @@ module Gisele
 
     # Install options
     options do |opt|
-      @print_ast = nil
-      opt.on('--ast=[MODE]', 'Prints the process abstract syntax tree (debug,ruby)') do |value|
-        @print_ast = (value || "debug").to_sym
-      end
       @sugar = true
       opt.on('--no-sugar', 'Apply syntactic sugar removal') do
         @sugar = false
       end
-      @print_graph = nil
-      opt.on('--graph=[MODE]', 'Converts and print a graph (dot)') do |value|
-        @print_graph = (value || "dot").to_sym
+
+      @compile_mode = [:ast, "debug"]
+      opt.on('--ast=[MODE]',
+             'Compile as an abstract syntax tree (debug,ruby)') do |value|
+        @compile_mode = [:ast, (value || "debug").to_sym]
+      end
+      opt.on('--graph=[MODE]',
+             'Compile as a workflow graph (dot)') do |value|
+        @compile_mode = [:graph, (value || "dot").to_sym]
+      end
+      opt.on('--glts=[MODE]',
+             'Compile as guarded labeled transition system (dot)') do |value|
+        @compile_mode = [:glts, (value || "dot").to_sym]
       end
+
       opt.on_tail('--help', "Show this help message") do
         raise Quickl::Help
       end
@@ -59,31 +66,33 @@ module Gisele
       end
 
       ast = Gisele.ast(file)
-      ast = Language::SugarRemoval.new.call(ast) unless @sugar
+      ast = Language::SugarRemoval.call(ast) unless @sugar
 
-      print_ast(ast, @print_ast) if @print_ast
-      print_graph(ast, @print_graph) if @print_graph
+      send :"compile_#{@compile_mode.first}", ast, *@compile_mode[1..-1]
     end
 
     private
 
-    def print_ast(ast, option)
+    def compile_ast(ast, option)
       require 'awesome_print'
-      options = case option
-                when :ruby
-                  {index: false, plain: true}
-                else
-                  {}
-                end
+      options = {}
+      options = {index: false, plain: true} if option == :ruby
       ap ast, options
     end
 
-    def print_graph(ast, option)
-      graphs = Gisele::Language::ToGraph.new.call(ast)
+    def compile_graph(ast, option)
+      graphs = Gisele::Compiling::ToGraph.call(ast)
       graphs.each do |graph|
         puts graph.to_dot
       end
     end
 
+    def compile_glts(ast, option)
+      glts = Gisele::Compiling::ToGlts.call(ast)
+      glts.each do |g|
+        puts g.to_dot(&Gisele::Compiling::ToGlts::DOT_REWRITER)
+      end
+    end
+
 end # class Command
 end # module Gisele

data/lib/gisele/compiling.rb

@@ -0,0 +1,2 @@
+require_relative 'compiling/to_graph'
+require_relative 'compiling/to_glts'

data/lib/gisele/compiling/to_glts.rb

@@ -0,0 +1,125 @@
+module Gisele
+  module Compiling
+    class ToGlts < Sexpr::Rewriter
+      grammar Language
+
+      DOT_REWRITER = lambda{|elm,kind|
+        case kind
+          when :automaton
+            {:rankdir => "LR"}
+          when :state
+            {:shape => "circle",
+             :style => "filled",
+             :color => "black",
+             :fillcolor => (elm.initial? ? "green" : "white")}
+          when :edge
+            label = elm[:guard] ? "[#{elm[:guard].label}]" : elm[:symbol]
+            {:label => label || ''}
+        end
+      }
+
+      # if/elsif/else -> guarded commands
+      use Language::IfToCase
+
+      def on_unit_def(sexpr)
+        sexpr.
+          sexpr_body.
+          select{|n| n.first == :task_def}.
+          map{|taskdef| apply(taskdef) }
+      end
+
+      def on_task_def(sexpr)
+        @glts = Stamina::Automaton.new
+
+        entry = add_state(sexpr, :initial => true)
+        exit  = add_state(sexpr)
+        c_entry, c_exit = apply(sexpr.last)
+        connect(entry, c_entry)
+        connect(c_exit, exit)
+
+        @glts
+      end
+
+      def on_seq_st(sexpr)
+        mine    = entry_and_exit(sexpr)
+        current = mine.first
+        sexpr.sexpr_body.each do |child|
+          c_entry, c_exit = apply(child)
+          connect(current, c_entry)
+          current = c_exit
+        end
+        connect(current, mine.last)
+        mine
+      end
+      alias :on_par_st :on_seq_st
+
+      def on_case_st(sexpr)
+        cond, *clauses = sexpr.sexpr_body
+
+        entry, exit = entry_and_exit(sexpr)
+
+        diamond = add_state(sexpr)
+        connect(entry, diamond)
+
+        clauses.each do |clause|
+          c_entry, c_exit = apply(clause.last)
+          connect(diamond, c_entry, clause[1])
+          connect(c_exit, exit)
+        end
+
+        [entry, exit]
+      end
+
+      def on_while_st(sexpr)
+        cond, dost, = sexpr.sexpr_body
+
+        entry, exit = entry_and_exit(sexpr)
+
+        diamond = add_state(sexpr)
+        connect(entry, diamond)
+
+        c_entry, c_exit = apply(sexpr.last)
+
+        connect(diamond, exit, cond.negate)
+        connect(diamond, c_entry, cond)
+        connect(c_exit, diamond)
+
+        [entry, exit]
+      end
+
+      def on_task_call_st(sexpr)
+        entry, exit = entry_and_exit(sexpr)
+        middle = add_state(sexpr)
+        connect(entry, middle, transition(sexpr, "start"))
+        connect(middle, exit, transition(sexpr, "end"))
+        [entry, exit]
+      end
+
+      private
+
+      def entry_and_exit(sexpr)
+        @glts.add_n_states(2)
+      end
+
+      def add_state(sexpr, attrs = nil)
+        @glts.add_state(attrs || {})
+      end
+
+      def connect(source, target, attrs = {:symbol => nil})
+        attrs = transition(attrs) unless Hash===attrs
+        @glts.connect(source, target, attrs)
+      end
+
+      def transition(sexpr, kind = nil)
+        raise UnexpectedNodeError, "Node expected, got #{sexpr}" unless Sexpr===sexpr
+        case sexpr.first
+        when :task_call_st then {:symbol => "#{sexpr.label}:#{kind}"}
+        when :bool_expr    then {:symbol => "[guard]", :guard => sexpr}
+        else
+          raise UnexpectedNodeError, "Unexpected event kind #{sexpr.inspect}"
+        end
+      end
+
+    end # class ToGlts
+  end # module Compiling
+end # module Gisele

data/lib/gisele/compiling/to_graph.rb

@@ -0,0 +1,160 @@
+module Gisele
+  module Compiling
+    class ToGraph < Sexpr::Rewriter
+      grammar Language
+
+      # We do not support the elsif syntactic sugar here; rewrite it as 'else if'.
+      use Language::ElsifFlattener
+
+      # This is a marker for the graph nodes we can remove later.
+      module Connector; end
+
+      def on_unit_def(sexpr)
+        sexpr.
+          sexpr_body.
+          select{|n| n.first == :task_def}.
+          map{|taskdef| apply(taskdef) }
+      end
+
+      def on_task_def(sexpr)
+        @graph = Yargi::Digraph.new
+
+        entry, exit = add_vertex(sexpr), add_vertex(sexpr)
+        c_entry, c_exit = apply(sexpr.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_seq_st(sexpr)
+        mine    = entry_and_exit(sexpr)
+        current = mine.first
+        sexpr.sexpr_body.each do |child|
+          c_entry, c_exit = apply(child)
+          connect(current, c_entry)
+          current = c_exit
+        end
+        connect(current, mine.last)
+        mine
+      end
+
+      def on_par_st(sexpr)
+        entry, exit = add_vertex(sexpr), add_vertex(sexpr)
+        sexpr.sexpr_body.each do |child|
+          c_entry, c_exit = apply(child)
+          connect(entry, c_entry)
+          connect(c_exit, exit)
+        end
+        [entry, exit]
+      end
+
+      def on_if_st(sexpr)
+        cond, then_clause, else_clause, = sexpr.sexpr_body
+
+        entry, exit = entry_and_exit(sexpr)
+
+        diamond = add_vertex(sexpr)
+        connect(entry, diamond)
+
+        c_entry, c_exit = apply(then_clause)
+        connect(diamond, c_entry, true_ast_sexpr)
+        connect(c_exit, exit)
+
+        if else_clause
+          c_entry, c_exit = apply(else_clause.last)
+          connect(diamond, c_entry, false_ast_sexpr)
+          connect(c_exit, exit)
+        else
+          connect(diamond, exit, false_ast_sexpr)
+        end
+
+        [entry, exit]
+      end
+
+      def on_case_st(sexpr)
+        cond, *clauses = sexpr.sexpr_body
+
+        entry, exit = entry_and_exit(sexpr)
+
+        diamond = add_vertex(sexpr)
+        connect(entry, diamond)
+
+        clauses.each do |clause|
+          c_entry, c_exit = apply(clause.last)
+          connect(diamond, c_entry, clause)
+          connect(c_exit, exit)
+        end
+
+        [entry, exit]
+      end
+
+
+      def on_while_st(sexpr)
+        cond, dost, = sexpr.sexpr_body
+
+        entry, exit = entry_and_exit(sexpr)
+
+        diamond = add_vertex(sexpr)
+        connect(entry, diamond)
+
+        c_entry, c_exit = apply(sexpr.last)
+
+        connect(diamond, exit,    false_ast_sexpr)
+        connect(diamond, c_entry, true_ast_sexpr)
+        connect(c_exit, diamond)
+
+        [entry, exit]
+      end
+
+      def on_task_call_st(sexpr)
+        entry, exit = entry_and_exit(sexpr)
+        task = add_vertex(sexpr)
+        connect(entry, task)
+        connect(task, exit)
+        [entry, exit]
+      end
+
+      private
+
+      def add_vertex(sexpr)
+        @graph.add_vertex(dot_attributes(sexpr))
+      end
+
+      def entry_and_exit(sexpr, tag = Connector)
+        @graph.add_n_vertices(2, tag)
+      end
+
+      def connect(source, target, sexpr = nil)
+        @graph.connect(source, target, dot_attributes(sexpr))
+      end
+
+      def false_ast_sexpr
+        sexpr(parse("false", :root => :bool_expr))
+      end
+
+      def true_ast_sexpr
+        sexpr(parse("true", :root => :bool_expr))
+      end
+
+      DOT_ATTRIBUTES = YAML.load_file(Path.dir/"to_graph.yml")
+      def dot_attributes(sexpr)
+        if Sexpr===sexpr
+          attrs = DOT_ATTRIBUTES["graphviz"][sexpr.first.to_s] || {}
+          attrs = attrs.merge(:label => sexpr.label) if sexpr.respond_to?(:label)
+          attrs
+        else
+          {} # sometimes, sexpr is simply nil
+        end
+      end
+
+    end # class ToGraph
+  end # module Compiling
+end # module Gisele