gisele 0.2.0 → 0.3.0

data/spec/unit/language/syntax/test_grammar.rb

@@ -1,317 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe Grammar do
-
-    let(:grammar){ Gisele::Language::Syntax::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_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 '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 # 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_st rule' do
-
-      it 'parses a single parallel statement' do
-        expr = 'par Task1 Task2 end'
-        parse(expr, :par_st).should eq(expr)
-      end
-
-    end # par_st
-
-    describe 'the seq_st rule' do
-
-      it 'parses a single sequence statement' do
-        expr = 'seq Task1 Task2 end'
-        parse(expr, :seq_st).should eq(expr)
-      end
-
-    end # seq_st
-
-    describe 'the while_statement rule' do
-
-      it 'parses a single while statement' do
-        expr = 'while badCond Task end'
-        parse(expr, :while_st).should eq(expr)
-      end
-
-    end # while_statement
-
-    describe 'the if_st rule' 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 # if_st
-
-    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/syntax/test_to_ast.rb

@@ -1,257 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe Grammar, "to_ast" do
-
-    def ast(text, rule, consume = true)
-      @parsed = Grammar.parse(text, :root => rule, :consume => consume).to_ast
-    end
-
-    after{ @parsed.should be_a(Gisele::Language::AST::Node) }
-
-    describe "the bool_expr rule" do
-
-      it 'returns expected ast on simple expressions' do
-        expected = \
-          [:bool_expr, [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]]]
-        ast("diagKnown and platLow", :bool_expr).should eq(expected)
-      end
-
-      it 'respects priorities' do
-        expected = [:bool_expr,
-          [:bool_or, [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]], [:var_ref, "platHigh"]]]
-        ast("diagKnown and platLow or platHigh", :bool_expr).should eq(expected)
-      end
-
-      it 'supports double negations' do
-        expected = [:bool_expr, [:bool_not, [:bool_not, [:var_ref, "diagKnown"]]]]
-        ast("not not(diagKnown)", :bool_expr).should eq(expected)
-      end
-
-      it 'makes boolean literals explicit' do
-        ast("true",  :bool_expr).should eq([:bool_expr, [:bool_lit, true]])
-        ast("false", :bool_expr).should eq([:bool_expr, [:bool_lit, false]])
-      end
-
-    end # bool_expr
-
-    describe 'the event_set rule' do
-
-      it 'parses empty lists as expected' do
-        expr     = '{ }'
-        expected = [:event_set]
-        ast(expr, :event_set).should eq(expected)
-      end
-
-      it 'parses singleton lists as expected' do
-        expr     = '{Diagnosis:start}'
-        expected = [:event_set, "Diagnosis:start"]
-        ast(expr, :event_set).should eq(expected)
-      end
-
-      it 'parses non empty lists as expected' do
-        expr     = '{Diagnosis:start, an_event, another_one}'
-        expected = [:event_set, "Diagnosis:start", "an_event", "another_one"]
-        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_st rule" do
-
-      it 'parses as expected' do
-        ast("Diagnosis", :task_call_st).should eq([:task_call_st, "Diagnosis"])
-      end
-
-    end # task_call_statement
-
-    describe "the par_st rule" do
-
-      it 'parses as expected' do
-        expr     = "par Task1 Task2 end"
-        expected = [:par_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]
-        ast(expr, :par_st).should eq(expected)
-      end
-
-    end # par_st
-
-    describe "the seq_st rule" do
-
-      it 'parses as expected' do
-        expr     = "seq Task1 Task2 end"
-        expected = [:seq_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]
-        ast(expr, :seq_st).should eq(expected)
-      end
-
-    end # seq_st
-
-    describe "the while_statement rule" do
-
-      it 'parses as expected' do
-        expr     = "while goodCond Task1 end"
-        expected = \
-          [:while_st,
-            [:bool_expr, [:var_ref, "goodCond"]],
-            [:task_call_st, "Task1"]]
-        ast(expr, :while_st).should eq(expected)
-      end
-
-      it 'recognizes implicit sequences' do
-        expr     = "while goodCond Task1 Task2 end"
-        expected = \
-          [:while_st,
-            [:bool_expr, [:var_ref, "goodCond"]],
-            [:seq_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]]
-        ast(expr, :while_st).should eq(expected)
-      end
-
-    end # while_statement
-
-    describe "the else_clause rule" do
-
-      it 'parses as expected' do
-        expr     = "else Task1 "
-        expected = \
-          [:else_clause, [:task_call_st, "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_clause,
-            [:bool_expr, [:var_ref, "goodCond"]],
-            [:task_call_st, "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_st,
-            [:bool_expr, [:var_ref, "goodCond"]],
-            [:task_call_st, "Task1"]]
-        ast(expr, :if_st).should eq(expected)
-      end
-
-      it 'supports a else clause' do
-        expr     = "if goodCond Task1 else Task2 end"
-        expected = \
-          [:if_st,
-            [:bool_expr, [:var_ref, "goodCond"]],
-            [:task_call_st, "Task1"],
-            [:else_clause, [:task_call_st, "Task2"]] ]
-        ast(expr, :if_st).should eq(expected)
-      end
-
-      it 'supports elsif clauses' do
-        expr     = "if goodCond Task1 elsif otherCond Task2 elsif stillAnother Task3 else Task4 end"
-        expected = \
-          [:if_st,
-            [:bool_expr, [:var_ref, "goodCond"]], [:task_call_st, "Task1"],
-            [:elsif_clause,
-              [:bool_expr, [:var_ref, "otherCond"]], [:task_call_st, "Task2"]],
-            [:elsif_clause,
-              [:bool_expr, [:var_ref, "stillAnother"]], [:task_call_st, "Task3"]],
-            [:else_clause,
-              [:task_call_st, "Task4"]] ]
-        ast(expr, :if_st).should eq(expected)
-      end
-
-    end # if_statement
-
-    describe 'the task_refinement rule' do
-
-      it 'parses as expected' do
-        expr     = "refinement Task1 end"
-        expected = [:task_refinement, [:task_call_st, "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 = \
-          [ :task_signature,
-            [: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_def, "Task1",
-            [:task_signature,
-              [:fluent, "diagKnown", [:event_set], [:event_set], nil]],
-            [:task_refinement,
-              [:task_call_st, "Task2"]]]
-        ast(expr, :task_def).should eq(expected)
-      end
-
-    end # task_def
-
-  end
-end