gisele-language 0.5.0

data/spec/language/processors/test_if_to_case.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+module Gisele::Language
+  describe IfToCase do
+
+    def ast(source)
+      Gisele.ast(Gisele.parse(source.strip, :root => :if_st))
+    end
+
+    def rewrite(ast)
+      @rewrited = IfToCase.call(ast)
+    end
+
+    after{
+      (sexp_grammar[:case_st] === @rewrited).should be_true
+    }
+
+    it 'rewrites single if correctly' do
+      source   = ast("if goodCond Task1 end")
+      expected = \
+        [:case_st, nil,
+          [:when_clause,
+            [:bool_expr, [:var_ref, "goodCond"]],
+            [:task_call_st, "Task1"] ]]
+      rewrite(source).should eq(expected)
+    end
+
+    it 'negates the else clause' do
+      source   = ast("if goodCond Task1 else Task2 end")
+      expected = \
+        [:case_st, nil,
+          [: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
+
+    it 'handles elsif clauses correctly' do
+      source = ast(<<-IF)
+        if    c1 Task1
+        elsif c2 Task2
+        elsif c3 Task3
+        else  Task4
+        end
+      IF
+      expected = \
+        [:case_st, nil,
+          [:when_clause,
+            [:bool_expr, [:var_ref, "c1"]],
+            [:task_call_st, "Task1"] ],
+          [:when_clause,
+            [:bool_expr, [:bool_and,
+              [:var_ref, "c2"],
+              [:bool_not, [:var_ref, "c1"]] ]],
+            [:task_call_st, "Task2"] ],
+          [:when_clause,
+            [:bool_expr, [:bool_and,
+              [:var_ref, "c3"],
+              [:bool_and,
+                [:bool_not, [:var_ref, "c2"]],
+                [:bool_not, [:var_ref, "c1"]] ]]],
+            [:task_call_st, "Task3"] ],
+          [:when_clause,
+            [:bool_expr, [:bool_and,
+              [:bool_not, [:var_ref, "c3"]],
+              [:bool_and,
+                [:bool_not, [:var_ref, "c2"]],
+                [:bool_not, [:var_ref, "c1"]]]]],
+            [:task_call_st, "Task4"] ],
+        ]
+      rewrite(source).should eq(expected)
+    end
+
+    it 'avoids double negations' do
+      source   = ast("if not(goodCond) Task1 else Task2 end")
+      expected = \
+        [:case_st, nil,
+          [:when_clause,
+            [:bool_expr, [:bool_not, [:var_ref, "goodCond"]]],
+            [:task_call_st, "Task1"] ],
+          [:when_clause,
+            [:bool_expr, [:var_ref, "goodCond"]],
+            [:task_call_st, "Task2"] ] ]
+      rewrite(source).should eq(expected)
+    end
+
+    it 'keeps traceability markers on a single if' do
+      if_st = ast("if goodCond Task1 end")
+      rw_st = rewrite(if_st)
+      rw_st.tracking_markers.should eq(if_st.tracking_markers)
+      rw_st.last.tracking_markers.should eq(if_st.tracking_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.tracking_markers.should eq(if_st.tracking_markers)
+      rw_st.last.tracking_markers.should eq(if_st.last.tracking_markers)
+    end
+
+  end
+end

data/spec/language/processors/test_scoping_helper.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Gisele::Language
+  describe ScopingHelper do
+
+    let(:rw_class) do
+      Class.new(Sexpr::Rewriter) do
+        grammar Gisele::Language
+        helper ScopingHelper
+
+        def on_hello(node)
+          scope_stack.dup
+        end
+
+        def on_missing(node)
+          call(node.sexpr_body.last)
+        end
+
+      end
+    end
+    let(:rw){ rw_class.new }
+
+    it 'installs the methods on the rewriter' do
+      rw.respond_to?(:scope_stack).should be_true
+    end
+
+    it 'does nothing special on non _def nodes' do
+      node = [:hello, "world"]
+      rw.call(node).should eq([])
+    end
+
+    it 'keeps _def nodes as successive scopes' do
+      second = [:task_def, [:hello]]
+      first  = [:task_def, second]
+      rw.call(first).should eq([first, second])
+    end
+
+    it 'pops scopes when returning along the stack' do
+      second = [:task_def, [:hello]]
+      first  = [:task_def, second]
+      rw.call(first)
+      rw.scope_stack.should eq([])
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_bool_expr.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'bool_expr' 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
+end

data/spec/language/syntax/grammar/test_boolean_literal.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'boolean_literal' 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
+end

data/spec/language/syntax/grammar/test_case_st.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'case_st' do
+
+    it 'supports a single when clause' do
+      expr = <<-CASE_ST.strip
+        case
+        when goodCond
+          Task1
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports boolean expressions in when clauses' do
+      expr = <<-CASE_ST.strip
+        case
+        when not(goodCond) or badCond
+          Task1
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports a multiple when clauses' do
+      expr = <<-CASE_ST.strip
+        case
+        when goodCond
+          Task1
+        when badCond
+          Task2
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports an else clause' do
+      expr = <<-CASE_ST.strip
+        case
+        when goodCond
+          Task1
+        else
+          Task2
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+    it 'supports an optional variable name' do
+      expr = <<-CASE_ST.strip
+        case someVariable
+        when goodCond
+          Task1
+        end
+      CASE_ST
+      parse(expr, :case_st).should eq(expr)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_event.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'event' 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
+end

data/spec/language/syntax/grammar/test_event_name.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'event_name' 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
+end

data/spec/language/syntax/grammar/test_event_set.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'event_set' 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 'parses event sets' do
+      parse('{Task:start, Task:end}', :event_set).should eq('{Task:start, Task:end}')
+    end
+
+    it 'recognizes invalid events in the set' do
+      lambda{
+        parse('{Task:start, NotAnEvent}', :event_set)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_fluent_def.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'fluent_def' 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
+end

data/spec/language/syntax/grammar/test_if_st.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'if_st' do
+
+    it 'parses a single if statement' do
+      expr = 'if goodCond Task end'
+      parse(expr, :if_st).should eq(expr)
+    end
+
+    it 'supports an optional else' do
+      expr = 'if goodCond GoodTask else BadTask end'
+      parse(expr, :if_st).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_st).should eq(expr)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_par_st.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'par_st' do
+
+    it 'parses a single parallel statement' do
+      expr = 'par Task1 Task2 end'
+      parse(expr, :par_st).should eq(expr)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_process_statement.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'process_statement' 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
+end

data/spec/language/syntax/grammar/test_seq_st.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'seq_st' do
+
+    it 'parses a single sequence statement' do
+      expr = 'seq Task1 Task2 end'
+      parse(expr, :seq_st).should eq(expr)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_spaces.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'spaces' 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
+end

data/spec/language/syntax/grammar/test_spacing.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'spacing' 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
+end

data/spec/language/syntax/grammar/test_task_def.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'task_def' do
+
+    it 'parses a simple implicit task definition' do
+      taskdef = <<-TASKDEF.strip
+        task Process
+          Diagnosis
+        end
+      TASKDEF
+      parse(taskdef, :task_def).should eq(taskdef)
+    end
+
+    it 'allows any statement' do
+      taskdef = <<-TASKDEF.strip
+        task Process
+          while true 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}
+          Diagnosis
+        end
+      TASKDEF
+      parse(taskdef, :task_def).should eq(taskdef)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_task_name.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar,'task_name' 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
+end

data/spec/language/syntax/grammar/test_task_start_or_end.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'task_start_or_end' 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
+end

data/spec/language/syntax/grammar/test_trackvar_def.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'trackvar_def' 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
+end

data/spec/language/syntax/grammar/test_unit_def.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'unit' do
+
+    it 'parses a single task definition' do
+      expr = <<-UNIT.strip
+        task Task1 end
+      UNIT
+      parse(expr, :unit_def).should eq(expr)
+    end
+
+    it 'accepts multiple task definitions' do
+      expr = <<-UNIT.strip
+        task Task1 end
+        task Task2 end
+      UNIT
+      parse(expr, :unit_def).should eq(expr)
+    end
+
+    it 'allows trailing spaces' do
+      expr = <<-UNIT
+        task Task1 end
+        task Task2 end
+      UNIT
+      parse(expr, :unit_def).should eq(expr)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_variable_name.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'variable_name' do
+
+    RESERVED_WORDS = [
+      "if",
+      "else",
+      "elsif",
+      "when",
+      "while",
+      "seq",
+      "par",
+      "task",
+      "refinement",
+      "fluent",
+      "trackvar",
+      "initially",
+      "end",
+      "not",
+      "or",
+      "and",
+      "true",
+      "false"
+    ]
+
+    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 'does not allow reserved words' do
+      RESERVED_WORDS.each do |word|
+        lambda{
+          parse(word.to_s + " ", :variable_name)
+        }.should raise_error(Citrus::ParseError)
+      end
+    end
+
+    it 'allows a reserved word as prefix' do
+      parse('ifSomething', :variable_name).should eq('ifSomething')
+    end
+
+    it 'raises on invalid variable names' do
+      lambda{
+        parse('NotAVarName', :variable_name)
+      }.should raise_error(Citrus::ParseError)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_when_clause.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'when_clause' do
+
+    it 'parses a single when clause statement' do
+      expr = 'when goodCond Task'
+      parse(expr, :when_clause).should eq(expr)
+    end
+
+    it 'supports a boolean expression' do
+      expr = 'when not(goodCond and badCond) Task'
+      parse(expr, :when_clause).should eq(expr)
+    end
+
+    it 'supports an complex process statement' do
+      expr = 'when goodCond Task1 par Task2 Task3 end'
+      parse(expr, :when_clause).should eq(expr)
+    end
+
+  end
+end

data/spec/language/syntax/grammar/test_while_st.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Grammar, 'while_st' do
+
+    it 'parses a single while statement' do
+      expr = 'while badCond Task end'
+      parse(expr, :while_st).should eq(expr)
+    end
+
+  end
+end