gisele 0.5.0 → 0.5.1

data/spec/unit/language/processors/test_if_to_case.rb

@@ -1,105 +0,0 @@
-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/unit/language/processors/test_scoping_helper.rb

@@ -1,45 +0,0 @@
-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/unit/language/syntax/grammar/test_bool_expr.rb

@@ -1,34 +0,0 @@
-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/unit/language/syntax/grammar/test_boolean_literal.rb

@@ -1,17 +0,0 @@
-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/unit/language/syntax/grammar/test_case_st.rb

@@ -1,60 +0,0 @@
-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/unit/language/syntax/grammar/test_event.rb

@@ -1,18 +0,0 @@
-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/unit/language/syntax/grammar/test_event_name.rb

@@ -1,21 +0,0 @@
-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/unit/language/syntax/grammar/test_event_set.rb

@@ -1,26 +0,0 @@
-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/unit/language/syntax/grammar/test_fluent_def.rb

@@ -1,21 +0,0 @@
-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/unit/language/syntax/grammar/test_if_st.rb

@@ -1,21 +0,0 @@
-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/unit/language/syntax/grammar/test_par_st.rb

@@ -1,11 +0,0 @@
-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/unit/language/syntax/grammar/test_process_statement.rb

@@ -1,19 +0,0 @@
-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/unit/language/syntax/grammar/test_seq_st.rb

@@ -1,11 +0,0 @@
-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/unit/language/syntax/grammar/test_spaces.rb

@@ -1,19 +0,0 @@
-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