gisele-language 0.5.0

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+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/lib/gisele/language.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+module Gisele
+
+  # Load the Language through Sexpr
+  Language = Sexpr.load Path.dir/"language/grammar.sexp.yml"
+
+  # Load syntax nodes, abstract syntax nodes, and processors
+  require_relative 'language/syntax/node'
+  require_relative 'language/ast/node'
+  require_relative 'language/processors'
+
+  # Force loading the Citrus parser now
+  Language.parser.parser
+
+  module Language
+
+    # By default, Sexpr will find for abstract nodes under Language itself. We
+    # override that behavior here and let it know that the AST module is the
+    # parent of all ast nodes.
+    def tagging_reference
+      AST
+    end
+
+    # The tagging function (from s-expr kind to AST module) is not complete so far.
+    # This allows us to at least include the AST:Node module in all s-expressions.
+    def default_tagging_module
+      AST::Node
+    end
+
+  end # module Language
+end # module Gisele

data/lib/gisele-language/loader.rb

@@ -0,0 +1,3 @@
+require "citrus"
+require "path"
+require "sexpr"

data/lib/gisele-language/version.rb

@@ -0,0 +1,16 @@
+module Gisele
+  module Language
+    module Version
+
+      MAJOR = 0
+      MINOR = 5
+      TINY  = 0
+
+      def self.to_s
+        [ MAJOR, MINOR, TINY ].join('.')
+      end
+
+    end
+    VERSION = Version.to_s
+  end
+end

data/lib/gisele-language.rb

@@ -0,0 +1,19 @@
+require "gisele-language/loader"
+require_relative "gisele/language"
+require "gisele-language/version"
+module Gisele
+
+  def parse(*args)
+    Language::parse(*args)
+  end
+
+  def ast(*args)
+    Language::sexpr(*args)
+  end
+
+  def sexpr(*args)
+    Language::sexpr(*args)
+  end
+
+  extend(self)
+end

data/spec/fixtures/tasks/complete.gis

@@ -0,0 +1,40 @@
+task Complete
+
+  trackvar everyOneHappy
+    {FirstTask:start}
+
+  fluent someoneHappy
+    {DrinkBeer:start, DrinkBeers:start},
+    {DoNothingSpecial:end}
+  initially false
+
+  task DrinkBeers
+    while not(drunk)
+      DrinkBeer
+    end
+  end
+
+  seq
+    FirstTask
+    if everyoneHappy
+      par
+        MakeJoy
+        DrinkBeers
+      end
+    elsif someoneHappy
+      DrinkBeer
+    else
+      DoNothingSpecial
+    end
+    while not(endOfTheDay)
+      case curState
+      when somethingToDo
+        DoSomething
+      when nothingToDo
+        DoNothing
+      else
+        WaitAndSee
+      end
+    end
+  end
+end

data/spec/fixtures/tasks/simple.ast

@@ -0,0 +1,51 @@
+[
+    :unit_def,
+    [
+        :task_def,
+        "Simple",
+        [
+            :fluent_def,
+            "diagKnown",
+            [
+                :event_set,
+                "Diagnosis:start"
+            ],
+            [
+                :event_set,
+                "Treatment:end"
+            ],
+            nil
+        ],
+        [
+            :seq_st,
+            [
+                :if_st,
+                [
+                    :bool_expr,
+                    [
+                        :bool_not,
+                        [
+                            :var_ref,
+                            "diagKnown"
+                        ]
+                    ]
+                ],
+                [
+                    :task_call_st,
+                    "Diagnosis"
+                ],
+                [
+                    :else_clause,
+                    [
+                        :task_call_st,
+                        "NoDiag"
+                    ]
+                ]
+            ],
+            [
+                :task_call_st,
+                "Treatment"
+            ]
+        ]
+    ]
+]

data/spec/fixtures/tasks/simple.gis

@@ -0,0 +1,16 @@
+task Simple
+
+  fluent diagKnown
+    {Diagnosis:start},
+    {Treatment:end}
+
+  seq
+    if not(diagKnown)
+      Diagnosis
+    else
+      NoDiag
+    end
+    Treatment
+  end
+
+end

data/spec/language/ast/test_bool_expr.rb

@@ -0,0 +1,50 @@
+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/language/grammar_sexp/test_case_st.rb

@@ -0,0 +1,20 @@
+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/language/grammar_sexp/test_event_set.rb

@@ -0,0 +1,14 @@
+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/language/grammar_sexp/test_fluent_def.rb

@@ -0,0 +1,18 @@
+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/language/grammar_sexp/test_initially.rb

@@ -0,0 +1,18 @@
+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/language/grammar_sexp/test_nop_st.rb

@@ -0,0 +1,10 @@
+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/language/grammar_sexp/test_when_clause.rb

@@ -0,0 +1,12 @@
+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/language/processors/test_elsif_flattener.rb

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