gisele 0.5.0 → 0.5.1

data/lib/gisele/language/syntax/implicit_seq_st.rb

@@ -1,16 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module ImplicitSeqSt
-        include Node
-
-        def _to_ast
-          front = captures[:explicit_statement].first.to_ast
-          tail  = captures[:st_list].first.value
-          [:seq_st, front] + tail
-        end
-
-      end # module ImplicitSeqSt
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/node.rb

@@ -1,40 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module Node
-
-        def to_ast
-          Language::sexpr(value, {:citrus_match => self})
-        end
-
-        def value
-          _to_ast
-        end
-
-      end # module Node
-    end # module Syntax
-  end # module Language
-end # module Gisele
-require_relative 'event_set'
-require_relative 'fluent_def'
-require_relative 'trackvar_def'
-require_relative 'var_ref'
-require_relative 'bool_lit'
-require_relative 'bool_paren'
-require_relative 'bool_not'
-require_relative 'bool_and'
-require_relative 'bool_or'
-require_relative 'bool_expr'
-require_relative 'st_list'
-require_relative 'implicit_seq_st'
-require_relative 'task_call_st'
-require_relative 'seq_st'
-require_relative 'par_st'
-require_relative 'while_st'
-require_relative 'if_st'
-require_relative 'else_clause'
-require_relative 'elsif_clause'
-require_relative 'case_st'
-require_relative 'when_clause'
-require_relative 'task_def'
-require_relative 'unit_def'

data/lib/gisele/language/syntax/par_st.rb

@@ -1,14 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module ParSt
-        include Node
-
-        def _to_ast
-          [:par_st] + captures[:st_list].first.value
-        end
-
-      end # module ParSt
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/seq_st.rb

@@ -1,14 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module SeqSt
-        include Node
-
-        def _to_ast
-          [:seq_st] + captures[:st_list].first.value
-        end
-
-      end # module SeqSt
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/st_list.rb

@@ -1,14 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module StList
-        include Node
-
-        def value
-          captures[:explicit_statement].map{|x| x.to_ast}
-        end
-
-      end # module StList
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/task_call_st.rb

@@ -1,14 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module TaskCallSt
-        include Node
-
-        def _to_ast
-          [:task_call_st, strip]
-        end
-
-      end # module TaskCallSt
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/task_def.rb

@@ -1,18 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module TaskDef
-        include Node
-
-        def _to_ast
-          name  = captures[:task_name].first.strip
-          defs  = captures[:some_def].map{|x| x.to_ast}
-          ref   = captures[:explicit_statement].map{|x| x.to_ast}.first
-          ref   = [:nop_st] unless ref
-          [:task_def, name] + defs + [ref]
-        end
-
-      end # module TaskDef
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/trackvar_def.rb

@@ -1,19 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module TrackvarDef
-        include Node
-
-        def _to_ast
-          name       = captures[:variable_name].first.strip
-          init, term = captures[:event_set].map{|x| x.to_ast}
-          term       = [:event_set] unless term
-          initval    = captures[:initially_def].first
-          initval    = (initval && !initval.empty?) ? initval.value : nil
-          [:trackvar_def, name, init, term, initval]
-        end
-
-      end # module TrackvarDef
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/unit_def.rb

@@ -1,14 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module UnitDef
-        include Node
-
-        def _to_ast
-          [:unit_def] + captures[:task_def].map{|x| x.to_ast}
-        end
-
-      end # module UnitDef
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/var_ref.rb

@@ -1,14 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module VarRef
-        include Node
-
-        def _to_ast
-          [:var_ref, strip]
-        end
-
-      end # module VarRef
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/when_clause.rb

@@ -1,16 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module WhenClause
-        include Node
-
-        def _to_ast
-          cond = captures[:bool_expr].first.to_ast
-          dost = captures[:process_statement].first.to_ast
-          [:when_clause, cond, dost]
-        end
-
-      end # module WhenClause
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax/while_st.rb

@@ -1,16 +0,0 @@
-module Gisele
-  module Language
-    module Syntax
-      module WhileSt
-        include Node
-
-        def _to_ast
-          cond = captures[:bool_expr].first.to_ast
-          dost = captures[:process_statement].first.to_ast
-          [:while_st, cond, dost]
-        end
-
-      end # module WhileSt
-    end # module Syntax
-  end # module Language
-end # module Gisele

data/spec/unit/language/ast/test_bool_expr.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::AST
-  describe BoolExpr, "negate" do
-
-    def sexpr(expr, options = {})
-      Gisele.sexpr(Gisele.parse(expr, options))
-    end
-
-    subject{ sexpr(expr, :root => :bool_expr).negate }
-
-    shared_examples_for 'A negated bool_expr' do
-
-      it 'is consistently rewrited' do
-        (Gisele::Language[:bool_expr] === subject).should be_true
-      end
-
-      it 'is correctly tagged' do
-        subject.should be_a(Sexpr)
-        subject.should be_a(BoolExpr)
-      end
-
-      it 'has no immediate traceability marker' do
-        subject.citrus_match.should be_nil
-      end
-    end
-
-    describe "on a normal expression" do
-      let(:expr){ "x and y" }
-
-      it_behaves_like 'A negated bool_expr'
-
-      it "negates as expected" do
-        expected = sexpr("not(x and y)", :root => :bool_expr)
-        subject.should eq(expected)
-      end
-    end
-
-    describe "on a negated expression" do
-      let(:expr){ "not(x and y)" }
-
-      it_behaves_like 'A negated bool_expr'
-
-      it "removes the negation" do
-        expected = sexpr("x and y", :root => :bool_expr)
-        subject.should eq(expected)
-      end
-    end
-
-  end
-end

data/spec/unit/language/grammar_sexp/test_case_st.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe "the Sexp grammar", "case_st" do
-
-    it 'matches when no variable is specified' do
-      case_st = \
-        [:case_st, nil,
-          [:when_clause, [:bool_expr, [:bool_lit, true]], [:nop_st]] ]
-      (sexp_grammar[:case_st] === case_st).should be_true
-    end
-
-    it 'matches when a variable is specified' do
-      case_st = \
-        [:case_st, [:var_ref, "varName"],
-          [:when_clause, [:bool_expr, [:bool_lit, true]], [:nop_st]] ]
-      (sexp_grammar[:case_st] === case_st).should be_true
-    end
-
-  end
-end

data/spec/unit/language/grammar_sexp/test_event_set.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe "the Sexp grammar", "event_set" do
-
-    it 'matches an empty set' do
-      (sexp_grammar[:event_set] === [:event_set]).should be_true
-    end
-
-    it 'matches a non empty set' do
-      (sexp_grammar[:event_set] === [:event_set, "event", "Task:start"]).should be_true
-    end
-
-  end
-end

data/spec/unit/language/grammar_sexp/test_fluent_def.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe "the Sexp grammar", "fluent_def" do
-
-    let(:g){ Gisele::Language }
-
-    it 'matches an fluent with initial value' do
-      fluent = [:fluent_def, "name", [:event_set, "start"], [:event_set, "stop"], true]
-      (sexp_grammar[:fluent_def] === fluent).should be_true
-    end
-
-    it 'matches an fluent without initial value' do
-      fluent = [:fluent_def, "name", [:event_set, "start"], [:event_set, "stop"], nil]
-      (sexp_grammar[:fluent_def] === fluent).should be_true
-    end
-
-  end
-end

data/spec/unit/language/grammar_sexp/test_initially.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe "the Sexp grammar", "initially" do
-
-    it 'matches true' do
-      (sexp_grammar[:initially] === true).should be_true
-    end
-
-    it 'matches false' do
-      (sexp_grammar[:initially] === false).should be_true
-    end
-
-    it 'matches nil' do
-      (sexp_grammar[:initially] === nil).should be_true
-    end
-
-  end
-end

data/spec/unit/language/grammar_sexp/test_nop_st.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe "the Sexp grammar", "nop_st" do
-
-    it 'matches [:nop_st]' do
-      (sexp_grammar[:nop_st] === [:nop_st]).should be_true
-    end
-
-  end
-end

data/spec/unit/language/grammar_sexp/test_when_clause.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe "the Sexp grammar", "when_clause" do
-
-    it 'matches a valid when clause' do
-      when_clause = \
-        [:when_clause, [:bool_expr, [:bool_lit, true]], [:nop_st]]
-      (sexp_grammar[:when_clause] === when_clause).should be_true
-    end
-
-  end
-end

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

@@ -1,94 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe ElsifFlattener do
-
-    def ast(source)
-      Gisele.ast(Gisele.parse(source.strip, :root => :if_st))
-    end
-
-    def rewrite(ast)
-      @rewrited = ElsifFlattener.call(ast)
-    end
-
-    after{
-      (sexp_grammar[:if_st] === @rewrited).should be_true
-    }
-
-    it 'rewrites a single if correctly' do
-      source = ast("if goodCond Task1 end")
-      rewrite(source).should eq(source)
-    end
-
-    it 'rewrites a if/else correctly' do
-      source = ast("if goodCond Task1 else Task2 end")
-      rewrite(source).should eq(source)
-    end
-
-    it 'rewrites a if/elsif correctly' do
-      source   = ast("if good Task1 elsif bad Task2 end")
-      expected = ast("if good Task1 else if bad Task2 end end")
-      rewrite(source).should eq(expected)
-    end
-
-    it 'rewrites a if/elsif/else correctly' do
-      source   = ast("if good Task1 elsif bad Task2 else Task3 end")
-      expected = ast("if good Task1 else if bad Task2 else Task3 end end")
-      rewrite(source).should eq(expected)
-    end
-
-    it 'rewrites a if/elsif/elsif/else correctly' do
-      source = ast(<<-EOF.strip)
-        if good Task1
-        elsif bad Task2
-        elsif none Task3
-        else Task4
-        end
-      EOF
-      expected = ast(<<-EOF.strip)
-        if good
-          Task1
-        else
-          if bad
-            Task2
-          else
-            if none
-              Task3
-            else
-              Task4
-            end
-          end
-        end
-      EOF
-      rewrite(source).should eq(expected)
-    end
-
-    it 'recurses by default' do
-      source = ast(<<-EOF.strip)
-        if goodCond
-          Task1
-        else
-          if bad
-            Task2
-          elsif middle
-            Task3
-          end
-        end
-      EOF
-      expected = ast(<<-EOF.strip)
-        if goodCond
-          Task1
-        else
-          if bad
-            Task2
-          else
-            if middle
-              Task3
-            end
-          end
-        end
-      EOF
-      rewrite(source).should eq(expected)
-    end
-
-  end
-end