gisele 0.0.1

data/lib/gisele/language/grammar.citrus

@@ -0,0 +1,246 @@
+grammar Gisele::Language::Grammar
+
+  ### Units
+
+  rule task_unit
+    (spacing defn:task_def spacing){
+      defn.value
+    }
+  end
+
+  ### Task definitions
+
+  rule task_def
+    ('task' spaces tname:task_name spaces
+      signature:(task_signature spaces)?
+      refinement:(task_refinement spaces)?
+    'end'){
+      sigvalue = [:signature]  + (signature.empty?  ? [] : signature.first.first.value)
+      refvalue = [:refinement, (refinement.empty? ? [] : refinement.first.first.value)]
+      [:task, tname.value, sigvalue, refvalue]
+    }
+  end
+
+  rule task_signature
+    (front:task_signature_element tail:(spaces task_signature)?){
+      [front.value] + (tail.empty? ? [] : tail.first.matches.last.value)
+    }
+  end
+
+  rule task_signature_element
+    fluent_def | trackvar_def
+  end
+
+  rule task_refinement
+    ('refinement' spaces main:process_statement spaces 'end'){
+      main.value
+    }
+  end
+
+  ### Process statements
+
+  rule process_statement
+    implicit_seq_statement | explicit_statement
+  end
+
+  rule implicit_seq_statement
+    (front:explicit_statement spaces tail:statement_list){
+      [:seq, front.value] + tail.value
+    }
+  end
+
+  rule statement_list
+    (f:explicit_statement t:(spaces statement_list)?){
+      [f.value] + (t.empty? ? [] : t.first.matches.last.value)
+    }
+  end
+
+  rule explicit_statement
+      if_statement
+    | while_statement
+    | seq_statement
+    | par_statement
+    | task_call_statement
+  end
+
+  rule if_statement
+    ('if' spaces cond:bool_expr spaces
+      dost:process_statement spaces
+      elsifclauses:elsif_clause*
+      elseclause:else_clause?
+    'end'){
+      elsifs = elsifclauses.matches.map{|c| c.value}
+      elsec  = elseclause.empty? ? [] : [elseclause.first.value]
+      [:if, cond.value, dost.value] + elsifs + elsec
+    }
+  end
+
+  rule elsif_clause
+    ('elsif' spaces cond:bool_expr spaces dost:process_statement spaces){
+      [:elsif, cond.value, dost.value]
+    }
+  end
+
+  rule else_clause
+    ('else' spaces dost:process_statement spaces){
+      [:else, dost.value]
+    }
+  end
+
+  rule while_statement
+    ('while' spaces cond:bool_expr spaces
+      dost:process_statement spaces
+    'end'){
+      [:while, cond.value, dost.value]
+    }
+  end
+
+  rule seq_statement
+    ('seq' spaces list:statement_list spaces 'end'){
+      [:seq] + list.value
+    }
+  end
+
+  rule par_statement
+    ('par' spaces list:statement_list spaces 'end'){
+      [:par] + list.value
+    }
+  end
+
+  rule task_call_statement
+    (task_name){
+      [:task_call, strip]
+    }
+  end
+
+  ### Boolean expressions
+
+  rule bool_expr
+    bool_or
+  end
+
+  rule bool_or
+      (left:bool_and spaces 'or' spaces right:bool_or){
+        [:or, left.value, right.value]
+      }
+    | bool_and
+  end
+
+  rule bool_and
+      (left:bool_not spaces 'and' spaces right:bool_and){
+        [:and, left.value, right.value]
+      }
+    | bool_not
+  end
+
+  rule bool_not
+      ('not' &([ \t\n] | '(') spacing term:bool_not){
+        [:not, term.value]
+      }
+    | bool_term
+  end
+
+  rule bool_term
+    bool_parenthesed | boolean_literal | bool_varref
+  end
+
+  rule bool_parenthesed
+    ('(' spacing expr:bool_expr spacing ')'){
+      expr.value
+    }
+  end
+
+  rule bool_varref
+    (variable_name){
+      [:varref, strip]
+    }
+  end
+
+  ### Variables
+
+  rule variable_def
+    trackvar_def | fluent_def
+  end
+
+  rule trackvar_def
+    ('trackvar' spaces name:variable_name spacing
+      init:event_set term:(spacing ',' spacing event_set)?
+      initially:initially_def?){
+        termval = term.empty?      ? [:event_set] : term.first.matches.last.value
+        initval = initially.empty? ? nil          : initially.first.value
+        [:trackvar, name.value, init.value, termval, initval]
+      }
+  end
+
+  rule fluent_def
+      ('fluent' spaces name:variable_name spacing
+          init:event_set spacing ',' spacing term:event_set initially:initially_def?){
+        initval = initially.empty? ? nil : initially.first.value
+        [:fluent, name.value, init.value, term.value, initval]
+      }
+  end
+  
+  rule initially_def
+    (spaces 'initially' spaces lit:boolean_literal){
+      lit.value
+    }
+  end
+
+  ### Events
+
+  rule event_set
+    ('{' spacing list:event_commalist? spacing '}'){
+      [:event_set] + (list.empty? ? [] : list.first.value)
+    }
+  end
+
+  rule event_commalist
+    (front:event tail:(spacing ',' spacing event_commalist)?){
+      tailval = tail.empty? ? [] : tail.first.matches.last.value
+      [ front.value ] + tailval
+    }
+  end
+
+  rule event
+    task_start_or_end | event_name
+  end
+
+  rule task_start_or_end
+    task_name ':' ('start' | 'end')
+  end
+
+  ### Names
+  
+  rule task_name
+    [A-Z] [A-Za-z0-9_]*
+  end
+
+  rule variable_name
+    [a-z] [A-Za-z0-9_]*
+  end
+
+  rule event_name
+    [a-z] [a-z0-9_]*
+  end
+
+  ### Literals
+
+  rule boolean_literal
+    ('true' | 'false'){ strip == "true" ? true : false }
+  end
+
+  ### Spacing
+
+  rule comment
+    "#" (![\n] .)*
+  end
+
+  rule spaces
+    (comment | [ \t\n])+
+  end
+
+  rule spacing
+    (comment | [ \t\n])*
+  end
+
+end

data/lib/gisele/language/parser.rb

@@ -0,0 +1,30 @@
+module Gisele
+  module Language
+    Citrus.load(File.expand_path('../grammar', __FILE__))
+    class Parser
+
+      def self.parse(input)
+        new.parse(input)
+      end
+
+      def call(input)
+        return input if input.is_a?(Array)
+        grammar.parse(parsing_source(input)).value
+      end
+      alias :parse :call
+
+      private
+
+      def grammar
+        Gisele::Language::Grammar
+      end
+
+      def parsing_source(input)
+        input = File.read(input.to_path) if input.respond_to?(:to_path)
+        input = input.to_str if input.respond_to?(:to_str)
+        input
+      end
+
+    end # class Parser
+  end # module Language
+end # module Gisele

data/lib/gisele/language.rb

@@ -0,0 +1,6 @@
+module Gisele
+  module Language
+
+  end # module Language
+end # module Gisele
+require_relative 'language/parser'

data/lib/gisele/loader.rb

@@ -0,0 +1,4 @@
+require "citrus"
+require "epath"
+require "quickl"
+require "awesome_print"

data/lib/gisele/version.rb

@@ -0,0 +1,14 @@
+module Gisele
+  module Version
+
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    def self.to_s
+      [ MAJOR, MINOR, TINY ].join('.')
+    end
+
+  end
+  VERSION = Version.to_s
+end

data/lib/gisele.rb

@@ -0,0 +1,14 @@
+require_relative "gisele/version"
+require_relative "gisele/loader"
+#
+# Gisele is a Process Analyzer Toolset
+#
+module Gisele
+
+  def parse(input)
+    Language::Parser::parse(input)
+  end
+  module_function :parse
+
+end # module Gisele
+require_relative 'gisele/language'

data/spec/command/main/gisele_ast_ruby.cmd

@@ -0,0 +1 @@
+gisele --ast=ruby tasks/simple.gis

data/spec/command/main/gisele_ast_ruby.stdout

@@ -0,0 +1,44 @@
+[
+    :task,
+    "Simple",
+    [
+        :signature,
+        [
+            :fluent,
+            "diagKnown",
+            [
+                :event_set,
+                "Diagnosis:start"
+            ],
+            [
+                :event_set,
+                "Treatment:end"
+            ],
+            nil
+        ]
+    ],
+    [
+        :refinement,
+        [
+            :seq,
+            [
+                :if,
+                [
+                    :not,
+                    [
+                        :varref,
+                        "diagKnown"
+                    ]
+                ],
+                [
+                    :task_call,
+                    "Diagnosis"
+                ]
+            ],
+            [
+                :task_call,
+                "Treatment"
+            ]
+        ]
+    ]
+]

data/spec/command/main/gisele_help.cmd

@@ -0,0 +1 @@
+gisele --help

data/spec/command/main/gisele_help.stdout

@@ -0,0 +1,22 @@
+
+Gisele - A Process Analyzer Toolset
+
+SYNOPSIS
+  gisele [--version] [--help]
+  gisele [--ast] PROCESS_FILE
+
+OPTIONS
+      --ast=[MODE]                 Prints the process abstract syntax tree (debug,ruby)
+      --help                       Show this help message
+      --version                    Show version and exit
+
+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
+  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.
+
+SystemExit

data/spec/command/main/gisele_version.cmd

@@ -0,0 +1 @@
+gisele --version

data/spec/command/main/gisele_version.stdout

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

data/spec/command/test_command.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'gisele/command'
+module Gisele
+  describe 'the `gisele` commandline tool' do
+
+    Path.dir.glob("**/*.cmd").each do |cmdfile|
+
+      it "executes `#{cmdfile}` as expected" do
+        command = cmdfile.read.strip
+        argv    = Quickl.parse_commandline_args(command)[1..-1]
+        stdout  = cmdfile.sub_ext('.stdout').read
+
+        out, err = capture_io do
+          begin
+            Dir.chdir(fixtures_dir){ Command.run(argv) }
+          rescue SystemExit
+            puts "SystemExit"
+          end
+        end
+
+        out.should eq stdout
+      end
+
+    end
+
+  end
+end

data/spec/fixtures/tasks/simple.ast

@@ -0,0 +1,15 @@
+[:task, "Simple",
+  [:signature,
+    [:fluent, "diagKnown",
+      [:event_set, "Diagnosis:start"],
+      [:event_set, "Treatment:end"],
+      nil ]
+    ],
+  [:refinement, 
+    [:seq, 
+      [:if, 
+        [:not, [:varref, "diagKnown"]], 
+        [:task_call, "Diagnosis"] ],
+      [:task_call, "Treatment"]]
+    ]
+]

data/spec/fixtures/tasks/simple.gis

@@ -0,0 +1,9 @@
+task Simple
+  fluent diagKnown {Diagnosis:start}, {Treatment:end}
+  refinement
+    if not(diagKnown)
+      Diagnosis
+    end
+    Treatment
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'gisele'
+require 'epath'
+
+def capture_io
+  stdout, stderr = $stdout, $stderr
+  $stdout, $stderr = StringIO.new, StringIO.new
+  yield
+  [$stdout.string, $stderr.string]
+ensure
+  $stdout, $stderr = stdout, stderr
+end
+
+module Helpers
+
+  def fixtures_dir
+    (Path.dir/:fixtures)
+  end
+
+  def fixture_files(glob)
+    fixtures_dir.glob(glob)
+  end
+
+end
+
+RSpec.configure do |c|
+  c.extend  Helpers
+  c.include Helpers
+end

data/spec/test_examples.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe "The examples" do
+  
+  (Path.backfind(".[examples]")/:examples).glob("**/*.gis").each do |file|
+
+    describe file do
+      it 'parses without any error' do
+        Gisele::parse(file).should be_a(Array)
+      end
+    end
+
+  end
+  
+end