gisele 0.0.1

data/spec/unit/language/test_ast.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, "ast" do
+
+    let(:grammar){ Gisele::Language::Grammar }
+
+    def ast(text, rule, consume = true)
+      grammar.parse(text, :root => rule, :consume => consume).value
+    end
+
+    describe "the bool_expr rule" do
+
+      it 'returns expected ast on simple expressions' do
+        expected = [:and, [:varref, "diagKnown"], [:varref, "platLow"]]
+        ast("diagKnown and platLow", :bool_expr).should eq(expected)
+      end
+
+      it 'respects priorities' do
+        expected = [:or, [:and, [:varref, "diagKnown"], [:varref, "platLow"]], [:varref, "platHigh"]]
+        ast("diagKnown and platLow or platHigh", :bool_expr).should eq(expected)
+      end
+
+      it 'supports double negations' do
+        expected = [:not, [:not, [:varref, "diagKnown"]]]
+        ast("not not(diagKnown)", :bool_expr).should eq(expected)
+      end
+
+    end # bool_expr
+
+    describe 'the event_commalist rule' do
+
+      it 'parses singleton lists as expected' do
+        expr     = 'Diagnosis:start'
+        expected = ["Diagnosis:start"]
+        ast(expr, :event_commalist).should eq(expected)
+      end
+
+      it 'parses non empty lists as expected' do
+        expr     = 'Diagnosis:start, an_event'
+        expected = ["Diagnosis:start", "an_event"]
+        ast(expr, :event_commalist).should eq(expected)
+      end
+
+    end # event_commalist
+
+    describe 'the event_set rule' do
+
+      it 'parses non empty lists as expected' do
+        expr     = '{Diagnosis:start, an_event}'
+        expected = [:event_set, "Diagnosis:start", "an_event"]
+        ast(expr, :event_set).should eq(expected)
+      end
+
+    end # event_set
+
+    describe "the fluent_def rule" do
+
+      it 'parses fluent definitions as expected' do
+        defn     = "fluent diagKnown {Diagnosis:start, diagnosis}, {Treatment:end} initially false"
+        expected = [:fluent,
+                     "diagKnown",
+                     [:event_set, "Diagnosis:start", "diagnosis"],
+                     [:event_set, "Treatment:end"],
+                     false]
+        ast(defn, :fluent_def).should eq(expected)
+      end
+
+      it 'does not require the initial value' do
+        defn     = "fluent diagKnown {Diagnosis:start, diagnosis}, {Treatment:end}"
+        expected = [:fluent,
+                     "diagKnown",
+                     [:event_set, "Diagnosis:start", "diagnosis"],
+                     [:event_set, "Treatment:end"],
+                     nil]
+        ast(defn, :fluent_def).should eq(expected)
+      end
+
+    end # fluent_def rule
+
+    describe "the trackvar_def rule" do
+
+      it 'parses tracking variable definitions as expected' do
+        defn     = "trackvar mplus {Diagnosis:start}"
+        expected = [:trackvar,
+                     "mplus",
+                     [:event_set, "Diagnosis:start"],
+                     [:event_set],
+                     nil]
+        ast(defn, :trackvar_def).should eq(expected)
+      end
+
+      it 'supports obsolete events and initial value' do
+        defn     = "trackvar mplus {Diagnosis:start}, {Treatment:end} initially true"
+        expected = [:trackvar,
+                     "mplus",
+                     [:event_set, "Diagnosis:start"],
+                     [:event_set, "Treatment:end"],
+                     true]
+        ast(defn, :trackvar_def).should eq(expected)
+      end
+
+    end # trackvar_def rule
+
+    describe "the task_call_statement rule" do
+
+      it 'parses as expected' do
+        ast("Diagnosis", :task_call_statement).should eq([:task_call, "Diagnosis"])
+      end
+
+    end # task_call_statement
+
+    describe "the statement_list rule" do
+
+      it 'parses a list of 2 elements' do
+        expr     = "Task1 Task2"
+        expected = [[:task_call, "Task1"], [:task_call, "Task2"]]
+        ast(expr, :statement_list).should eq(expected)
+      end
+
+      it 'parses a list of 3 elements' do
+        expr     = "Task1 Task2 Task3"
+        expected = [[:task_call, "Task1"], [:task_call, "Task2"], [:task_call, "Task3"]]
+        ast(expr, :statement_list).should eq(expected)
+      end
+
+    end # statement_list
+
+    describe "the par_statement rule" do
+
+      it 'parses as expected' do
+        expr     = "par Task1 Task2 end"
+        expected = [:par, [:task_call, "Task1"], [:task_call, "Task2"]]
+        ast(expr, :par_statement).should eq(expected)
+      end
+
+    end # par_statement
+
+    describe "the seq_statement rule" do
+
+      it 'parses as expected' do
+        expr     = "seq Task1 Task2 end"
+        expected = [:seq, [:task_call, "Task1"], [:task_call, "Task2"]]
+        ast(expr, :seq_statement).should eq(expected)
+      end
+
+    end # seq_statement
+
+    describe "the while_statement rule" do
+
+      it 'parses as expected' do
+        expr     = "while goodCond Task1 end"
+        expected = \
+          [:while,
+            [:varref, "goodCond"],
+            [:task_call, "Task1"]]
+        ast(expr, :while_statement).should eq(expected)
+      end
+
+      it 'recognizes implicit sequences' do
+        expr     = "while goodCond Task1 Task2 end"
+        expected = \
+          [:while,
+            [:varref, "goodCond"],
+            [:seq, [:task_call, "Task1"], [:task_call, "Task2"]]]
+        ast(expr, :while_statement).should eq(expected)
+      end
+
+    end # while_statement
+
+    describe "the else_clause rule" do
+
+      it 'parses as expected' do
+        expr     = "else Task1 "
+        expected = \
+          [:else, [:task_call, "Task1"]]
+        ast(expr, :else_clause).should eq(expected)
+      end
+
+    end # else_clause
+
+    describe "the elsif_clause rule" do
+
+      it 'parses as expected' do
+        expr     = "elsif goodCond Task1 "
+        expected = \
+          [:elsif, [:varref, "goodCond"], [:task_call, "Task1"]]
+        ast(expr, :elsif_clause).should eq(expected)
+      end
+
+    end # elsif_clause
+
+    describe "the if_statement rule" do
+
+      it 'parses as expected' do
+        expr     = "if goodCond Task1 end"
+        expected = \
+          [:if, [:varref, "goodCond"], [:task_call, "Task1"]]
+        ast(expr, :if_statement).should eq(expected)
+      end
+
+      it 'supports a else clause' do
+        expr     = "if goodCond Task1 else Task2 end"
+        expected = \
+          [:if,
+            [:varref, "goodCond"], [:task_call, "Task1"],
+            [:else, [:task_call, "Task2"]] ]
+        ast(expr, :if_statement).should eq(expected)
+      end
+
+      it 'supports elsif clauses' do
+        expr     = "if goodCond Task1 elsif otherCond Task2 elsif stillAnother Task3 else Task4 end"
+        expected = \
+          [:if,
+            [:varref, "goodCond"], [:task_call, "Task1"],
+            [:elsif,
+              [:varref, "otherCond"], [:task_call, "Task2"]],
+            [:elsif,
+              [:varref, "stillAnother"], [:task_call, "Task3"]],
+            [:else,
+              [:task_call, "Task4"]] ]
+        ast(expr, :if_statement).should eq(expected)
+      end
+
+    end # if_statement
+
+    describe 'the task_refinement rule' do
+
+      it 'parses as expected' do
+        expr     = "refinement Task1 end"
+        expected = [:task_call, "Task1"]
+        ast(expr, :task_refinement).should eq(expected)
+      end
+
+    end # task_refinement
+
+    describe 'the task_signature rule' do
+
+      it 'parses as expected' do
+        expr     = "fluent diagKnown {}, {}\ntrackvar mplus {}"
+        expected = \
+          [ [:fluent, "diagKnown", [:event_set], [:event_set], nil],
+            [:trackvar, "mplus", [:event_set], [:event_set], nil]]
+        ast(expr, :task_signature).should eq(expected)
+      end
+
+    end # task_signature
+
+    describe 'the task_def rule' do
+
+      it 'parses as expected' do
+        expr     = "task Task1 fluent diagKnown {}, {} refinement Task2 end end"
+        expected = \
+          [:task, "Task1",
+            [:signature,
+              [:fluent, "diagKnown", [:event_set], [:event_set], nil]],
+            [:refinement,
+              [:task_call, "Task2"]]]
+        ast(expr, :task_def).should eq(expected)
+      end
+
+    end # task_def
+
+  end
+end

data/spec/unit/language/test_grammar.rb

@@ -0,0 +1,329 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar do
+
+    let(:grammar){ Gisele::Language::Grammar }
+
+    def parse(text, rule, consume = true)
+      grammar.parse(text, :root => rule, :consume => consume)
+    end
+
+    ### Spacing
+
+    describe 'the spaces rule' do
+
+      it 'parses all kind of spaces' do
+        parse(' ', :spaces).should eq(' ')
+        parse("\t", :spaces).should eq("\t")
+        parse("\n", :spaces).should eq("\n")
+        parse(" \t\n", :spaces).should eq(" \t\n")
+      end
+
+      it 'enforces mandatory spacing' do
+        lambda{ parse('', :spaces) }.should raise_error(Citrus::ParseError)
+      end
+
+    end
+
+    describe 'the spacing rule' do
+
+      it 'parses all kind of spaces' do
+        parse(' ', :spacing).should eq(' ')
+        parse("\t", :spacing).should eq("\t")
+        parse("\n", :spacing).should eq("\n")
+        parse(" \t\n", :spacing).should eq(" \t\n")
+      end
+
+      it 'does not enforces mandatory spacing' do
+        parse('', :spacing).should eq('')
+      end
+
+    end
+
+    ### Literals
+
+    describe 'the boolean_literal rule' 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
+
+    ### Names
+
+    describe 'the task_name rule' do
+
+      it 'parses correct task names' do
+        parse('A',          :task_name).should eq('A')
+        parse('Diagnosis',  :task_name).should eq('Diagnosis')
+        parse('TaskName',   :task_name).should eq('TaskName')
+        parse('Task_Name',  :task_name).should eq('Task_Name')
+      end
+
+      it 'raises on invalid task names' do
+        lambda{ parse('not_a_task_name',  :task_name) }.should raise_error(Citrus::ParseError)
+      end
+
+    end # task_name
+
+    describe 'the variable_name rule' do
+
+      it 'parses correct variable names' do
+        parse('a',         :variable_name).should eq('a')
+        parse('diagnosis', :variable_name).should eq('diagnosis')
+        parse('varName',   :variable_name).should eq('varName')
+      end
+
+      it 'raises on invalid variable names' do
+        lambda{ parse('NotAVarName',  :variable_name) }.should raise_error(Citrus::ParseError)
+      end
+
+    end # variable_name
+
+    describe 'the event_name rule' do
+
+      it 'parses correct event names' do
+        parse('a',          :event_name).should eq('a')
+        parse('event',      :event_name).should eq('event')
+        parse('event_name', :event_name).should eq('event_name')
+      end
+
+      it 'raises on invalid variable names' do
+        lambda{ parse('NotAnEventName',  :event_name) }.should raise_error(Citrus::ParseError)
+        lambda{ parse('notAnEventName',  :event_name) }.should raise_error(Citrus::ParseError)
+      end
+
+    end # event_name
+
+    ### Events
+
+    describe 'the task_start_or_end rule' do
+
+      it 'parses correct event names' do
+        parse('Task:start', :task_start_or_end).should eq('Task:start')
+        parse('Task:end',   :task_start_or_end).should eq('Task:end')
+      end
+
+      it 'raises on simple task names' do
+        lambda{ parse('Task', :task_start_or_end) }.should raise_error(Citrus::ParseError)
+      end
+
+    end # task_start_or_end
+
+    describe 'the event rule' do
+
+      it 'parses correct events' do
+        parse('Task:start', :event).should eq('Task:start')
+        parse('Task:end',   :event).should eq('Task:end')
+        parse('an_event',   :event).should eq('an_event')
+      end
+
+      it 'raises on invalid event names' do
+        lambda{ parse('Task', :event) }.should raise_error(Citrus::ParseError)
+      end
+
+    end # event
+
+    describe 'the event_commalist rule' do
+
+      it 'parses a singleton list' do
+        parse('Task:start', :event_commalist).should eq('Task:start')
+      end
+
+      it 'parses multiple events' do
+        parse('Task:start, an_event', :event_commalist).should eq('Task:start, an_event')
+      end
+
+      it 'recognizes invalid events' do
+        lambda{ parse('Task:start, NotAnEvent', :event_commalist) }.should raise_error(Citrus::ParseError)
+      end
+
+    end # event_commalist
+
+    describe 'the event_set rule' do
+
+      it 'parses empty sets' do
+        parse('{}', :event_set).should eq('{}')
+        parse('{   }', :event_set).should eq('{   }')
+      end
+
+      it 'parses event singletons' do
+        parse('{Task:start}', :event_set).should eq('{Task:start}')
+        parse('{  Task:start  }', :event_set).should eq('{  Task:start  }')
+      end
+
+      it 'recognizes invalid events in the set' do
+        lambda{ parse('{Task:start, NotAnEvent}', :event_set) }.should raise_error(Citrus::ParseError)
+      end
+
+    end # event_set
+
+    ### Variables
+
+    describe 'the fluent_def rule' do
+
+      it 'parses valid fluent definitions' do
+        defn = 'fluent diagKnown {Diagnosis:start}, {Treatment:end} initially false'
+        parse(defn, :fluent_def).should eq(defn)
+      end
+
+      it 'supports a missing initial value' do
+        defn = 'fluent diagKnown {Diagnosis:start}, {Treatment:end}'
+        parse(defn, :fluent_def).should eq(defn)
+      end
+
+      it 'supports empty sets for events' do
+        defn = 'fluent diagKnown {}, {} initially true'
+        parse(defn, :fluent_def).should eq(defn)
+      end
+
+    end # fluent_def
+
+    describe 'the trackvar_def rule' do
+
+      it 'parses valid tracking variable definitions' do
+        defn = 'trackvar plateletLow {BloodTest:end}'
+        parse(defn, :trackvar_def).should eq(defn)
+      end
+
+      it 'supports an optional initial value' do
+        defn = 'trackvar plateletLow {BloodTest:end} initially false'
+        parse(defn, :trackvar_def).should eq(defn)
+      end
+
+      it 'supports optional obsolete events' do
+        defn = 'trackvar plateletLow {BloodTest:end}, {Chemotherapy:end}'
+        parse(defn, :trackvar_def).should eq(defn)
+      end
+
+    end # trackvar_def
+
+    describe 'the bool_expr rule' 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 # bool_expr
+
+    ### Process statements
+
+    describe 'the par_statement rule' do
+
+      it 'parses a single parallel statement' do
+        expr = 'par Task1 Task2 end'
+        parse(expr, :par_statement).should eq(expr)
+      end
+
+    end # par_statement
+
+    describe 'the seq_statement rule' do
+
+      it 'parses a single sequence statement' do
+        expr = 'seq Task1 Task2 end'
+        parse(expr, :seq_statement).should eq(expr)
+      end
+
+    end # seq_statement
+
+    describe 'the while_statement rule' do
+
+      it 'parses a single while statement' do
+        expr = 'while badCond Task end'
+        parse(expr, :while_statement).should eq(expr)
+      end
+
+    end # while_statement
+
+    describe 'the if_statement rule' do
+
+      it 'parses a single if statement' do
+        expr = 'if goodCond Task end'
+        parse(expr, :if_statement).should eq(expr)
+      end
+
+      it 'supports an optional else' do
+        expr = 'if goodCond GoodTask else BadTask end'
+        parse(expr, :if_statement).should eq(expr)
+      end
+
+      it 'supports an optional elsif clauses' do
+        expr = 'if goodCond GoodTask elsif otherCond OtherTask elsif yetAnother BadTask end'
+        parse(expr, :if_statement).should eq(expr)
+      end
+
+    end # if_statement
+
+    describe 'the process_statement rule' do
+
+      it 'parses a simple process statement' do
+        expr = <<-PROCESS.strip
+          DoSomething
+          if goodCond
+            DoForGood
+          else
+            DoForBad
+          end
+          CleanDesk
+        PROCESS
+        parse(expr, :process_statement).should eq(expr)
+      end
+
+    end # process_statement
+
+    describe 'the task_def rule' do
+
+      it 'parses a simple task definition' do
+        taskdef = <<-TASKDEF.strip
+          task Process
+            refinement Diagnosis end
+          end
+        TASKDEF
+        parse(taskdef, :task_def).should eq(taskdef)
+      end
+
+      it 'supports optional variable definitions in the signature' do
+        taskdef = <<-TASKDEF.strip
+          task Process
+            fluent   diagKnown {Diagnosis:start}, {} initially false
+            trackvar mplus     {Diagnosis:end}
+            refinement Diagnosis end
+          end
+        TASKDEF
+        parse(taskdef, :task_def).should eq(taskdef)
+      end
+
+    end
+
+  end
+end

data/spec/unit/language/test_parser.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Parser do
+
+    fixture_files('tasks/**/*.gis').each do |file|
+      if file.sub_ext(".ast").exist?
+
+        it "returns the expected ast on #{file}" do
+          parsed   = Parser.parse(file)
+          expected = Kernel::eval(file.sub_ext(".ast").read, TOPLEVEL_BINDING, file.sub_ext(".ast").to_s)
+          parsed.should eq(expected)
+        end
+
+      else
+
+        it "parses #{file} without error" do
+          parsed = Parser.parse(file)
+          parsed.should be_a(Array)
+          parsed.first.should eq(:task)
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/unit/test_gisele.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+describe Gisele do
+
+  it "has a version number" do
+    Gisele.const_defined?(:VERSION).should be_true
+  end
+
+end

data/tasks/debug_mail.rake

@@ -0,0 +1,75 @@
+# Installs a rake task for debuging the announcement mail.
+#
+# This file installs the 'rake debug_mail' that flushes an announcement mail
+# for your library on the standard output. It is automatically generated
+# by Noe from your .noespec file, and should therefore be configured there,
+# under the variables/rake_tasks/debug_mail entry, as illustrated below:
+#
+# variables:
+#   rake_tasks:
+#     debug_mail:
+#       rx_changelog_sections: /^#/
+#       nb_changelog_sections: 1
+#       ...
+#
+# If you have specific needs requiring manual intervention on this file,
+# don't forget to set safe-override to false in your noe specification:
+#
+# template-info:
+#   manifest:
+#     tasks/debug_mail.rake:
+#       safe-override: false
+#
+# The mail template used can be found in debug_mail.txt. That file may be
+# changed to tune the mail you want to send. If you do so, don't forget to
+# add a manifest entry in your .noespec file to avoid overriding you
+# changes. The mail template uses wlang, with parentheses for block
+# delimiters.
+#
+# template-info:
+#   manifest:
+#     tasks/debug_mail.txt:
+#       safe-override: false
+#
+desc "Debug the release announcement mail"
+task :debug_mail do
+  begin
+    require 'wlang'
+  rescue LoadError
+    abort "wlang is not available. Try 'gem install wlang'"
+  end
+  require 'yaml'
+
+  # Check that a .noespec file exists
+  noespec_file = File.expand_path('../../gisele.noespec', __FILE__)
+  unless File.exists?(noespec_file)
+    raise "Unable to find .noespec project file, sorry."
+  end
+
+  # Load it as well as variables and options
+  noespec = YAML::load(File.read(noespec_file))
+  vars = noespec['variables'] || {}
+
+  # Changes are taken from CHANGELOG
+  logs = Dir[File.expand_path("../../CHANGELOG.*", __FILE__)]
+  unless logs.size == 1
+    abort "Unable to find a changelog file"
+  end
+
+  # Load interesting changesets
+  changes, end_found = [], 0
+  File.readlines(logs.first).select{|line|
+    if line =~ /^# /
+      break if end_found >= 1
+      end_found += 1
+    end
+    changes << line
+  }
+  vars['changes'] = changes.join
+
+  # WLang template
+  template = File.expand_path('../debug_mail.txt', __FILE__)
+
+  # Let's go!
+  $stdout << WLang::file_instantiate(template, vars, "wlang/active-text")
+end