gisele-language 0.5.0

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe BoolExpr, "to_ast" do
+
+    it 'is correctly extended by Sexpr' do
+      ast("true", :bool_expr).should be_a(Gisele::Language::AST::BoolExpr)
+    end
+
+    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
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe CaseSt, "to_ast" do
+
+    it 'arranges when clauses as expected' do
+      expr = <<-CASE_ST.strip
+        case
+        when good
+          Task1
+        when bad
+          Task2
+        end
+      CASE_ST
+      when_clause1 = ast("when good Task1", :when_clause)
+      when_clause2 = ast("when bad Task2", :when_clause)
+      expected = [:case_st, nil, when_clause1, when_clause2]
+      ast(expr, :case_st).should eq(expected)
+    end
+
+    it 'puts the else clause at the end' do
+      expr = <<-CASE_ST.strip
+        case
+        when good
+          Task1
+        else
+          Task2
+        end
+      CASE_ST
+      when_clause = ast("when good Task1", :when_clause)
+      else_clause = ast("else Task2", :else_clause)
+      expected = [:case_st, nil, when_clause, else_clause]
+      ast(expr, :case_st).should eq(expected)
+    end
+
+    it 'supports an optional variable name' do
+      expr = <<-CASE_ST.strip
+        case someVariable
+        when good
+          Task1
+        end
+      CASE_ST
+      expected = [:var_ref, "someVariable"]
+      ast(expr, :case_st)[1].should eq(expected)
+    end
+
+  end
+end

data/spec/language/syntax/to_ast/test_else_clause.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe ElseClause, "to_ast" 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
+end

data/spec/language/syntax/to_ast/test_elsif_clause.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe ElsifClause, "to_ast" 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
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe EventSet, "to_ast" do
+
+    it 'converts empty lists as expected' do
+      expr     = '{ }'
+      expected = [:event_set]
+      ast(expr, :event_set).should eq(expected)
+    end
+
+    it 'converts singleton lists as expected' do
+      expr     = '{Diagnosis:start}'
+      expected = [:event_set, "Diagnosis:start"]
+      ast(expr, :event_set).should eq(expected)
+    end
+
+    it 'converts 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
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe FluentDef, "to_ast" do
+
+    it 'converts fluent definitions as expected' do
+      defn     = "fluent diagKnown {Diagnosis:start, diagnosis}, {Treatment:end} initially false"
+      expected = [:fluent_def,
+                   "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_def,
+                   "diagKnown",
+                   [:event_set, "Diagnosis:start", "diagnosis"],
+                   [:event_set, "Treatment:end"],
+                   nil]
+      ast(defn, :fluent_def).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe IfSt, "to_ast" 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
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe ParSt, "to_ast" 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
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe SeqSt, "to_ast" 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
+end

data/spec/language/syntax/to_ast/test_task_call_st.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe TaskCallSt, "to_ast" do
+
+    it 'converts a call as expected' do
+      ast("Diagnosis", :task_call_st).should eq([:task_call_st, "Diagnosis"])
+    end
+
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe TaskDef, "to_ast" do
+
+    it 'parses an explicit definition as expected' do
+      expr = <<-EXPR.strip
+        task Task1
+          fluent diagKnown {}, {}
+          Task2
+        end
+      EXPR
+      expected = \
+        [:task_def, "Task1",
+          [:fluent_def, "diagKnown", [:event_set], [:event_set], nil],
+          [:task_call_st, "Task2"]]
+      ast(expr, :task_def).should eq(expected)
+    end
+
+    it 'uses :nop_st if no statement' do
+      expr = <<-EXPR.strip
+        task Task1
+          fluent diagKnown {}, {}
+        end
+      EXPR
+      expected = \
+        [:task_def, "Task1",
+          [:fluent_def, "diagKnown", [:event_set], [:event_set], nil],
+          [:nop_st]]
+      ast(expr, :task_def).should eq(expected)
+    end
+
+    it 'uses :nop_st when empty' do
+      expr = <<-EXPR.strip
+        task Task1
+        end
+      EXPR
+      expected = \
+        [:task_def, "Task1",
+          [:nop_st]]
+      ast(expr, :task_def).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe TrackvarDef, "to_ast" do
+
+    it 'converts tracking variable definitions as expected' do
+      defn     = "trackvar mplus {Diagnosis:start}"
+      expected = [:trackvar_def,
+                   "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_def,
+                   "mplus",
+                   [:event_set, "Diagnosis:start"],
+                   [:event_set, "Treatment:end"],
+                   true]
+      ast(defn, :trackvar_def).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe UnitDef, 'to_ast' do
+
+    it 'converts a single task definition as expected' do
+      expr = <<-UNIT.strip
+        task Task1 end
+      UNIT
+      expected = \
+        [:unit_def,
+          [:task_def, "Task1", [:nop_st]]]
+      ast(expr, :unit_def).should eq(expected)
+    end
+
+    it 'accepts multiple task definitions' do
+      expr = <<-UNIT.strip
+        task Task1 end
+        task Task2 end
+      UNIT
+      expected = \
+        [:unit_def,
+          [:task_def, "Task1", [:nop_st]],
+          [:task_def, "Task2", [:nop_st]] ]
+      ast(expr, :unit_def).should eq(expected)
+    end
+
+  end
+end

data/spec/language/syntax/to_ast/test_var_ref.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe VarRef, "to_ast" do
+
+    it 'converts a reference as expected' do
+      defn     = "goodCond"
+      expected = [:var_ref, "goodCond"]
+      ast(defn, :var_ref).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe WhenClause, 'to_ast' do
+
+    it 'converts a when clause as expected' do
+      expr = 'when goodCond Task'
+      expected = \
+        [:when_clause,
+          [:bool_expr, [:var_ref, "goodCond"] ],
+          [:task_call_st, "Task"]]
+      ast(expr, :when_clause).should eq(expected)
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Gisele::Language::Syntax
+  describe WhileSt, "to_ast" 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
+end

data/spec/language/test_syntax.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+describe Gisele do
+  include Gisele
+
+  describe "parse" do
+
+    it 'works with a file' do
+      parsed = parse(fixtures_dir/:tasks/"simple.gis")
+      parsed.should be_a(Citrus::Match)
+    end
+
+    it 'works on a String' do
+      parsed = parse("task Hello end")
+      parsed.should be_a(Citrus::Match)
+    end
+
+    it 'accepts parse options' do
+      parsed = parse("if goodCond Task1 end", :root => :if_st)
+      parsed.should be_a(Citrus::Match)
+    end
+
+  end
+
+  describe "ast" do
+
+    it 'accepts parse options' do
+      ast = ast(parse("if goodCond Task1 end", :root => :if_st))
+      ast.should be_a(Sexpr)
+      ast.first.should eq(:if_st)
+    end
+
+    it 'sets traceability marks correctly' do
+      ast = ast(parse("if goodCond Task1 end", :root => :if_st))
+      ast.tracking_markers[:citrus_match].should_not be_nil
+    end
+
+    fixture_files('tasks/**/*.gis').each do |file|
+      it "works on #{file}" do
+        parsed = ast(parse(file))
+        parsed.should be_a(Array)
+        parsed.should be_a(Sexpr)
+        parsed.first.should eq(:unit_def)
+        if (astfile = file.sub_ext(".ast")).exist?
+          parsed.should eq(Kernel::eval(astfile.read, TOPLEVEL_BINDING, astfile.to_s))
+        end
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'gisele-language'
+
+module SpecHelpers
+
+  def parse(text, rule, consume = true)
+    grammar = Gisele::Language::Grammar
+    grammar.parse(text, :root => rule, :consume => consume)
+  end
+
+  def ast(text, rule, consume = true)
+    ast = parse(text, rule, consume).to_ast
+    unless sexp_grammar[rule] === ast
+      raise "expected #{ast} to match #{rule} (#{text})"
+    end
+    ast
+  end
+
+  def fixtures_dir
+    (Path.dir/:fixtures)
+  end
+
+  def fixture_files(glob)
+    fixtures_dir.glob(glob)
+  end
+
+  def sexp_grammar
+    Gisele::Language
+  end
+
+  def simple_ast
+    Gisele::ast(fixtures_dir/:tasks/"simple.gis")
+  end
+
+  def complete_ast
+    Gisele::ast(fixtures_dir/:tasks/"complete.gis")
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include SpecHelpers
+  c.extend  SpecHelpers
+end

data/spec/test_gisele-language.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+describe Gisele::Language do
+
+  it "should have a version number" do
+    Gisele::Language.const_defined?(:VERSION).should be_true
+  end
+
+end

data/tasks/gem.rake

@@ -0,0 +1,73 @@
+# Installs rake tasks for gemming and packaging
+#
+# This file installs the 'rake package', 'rake gem' tasks and associates
+# (clobber_package, repackage, ...). It is automatically generated by Noe
+# from your .noespec file, and should therefore be configured there, under
+# the variables/rake_tasks/gem entry, as illustrated below:
+#
+# variables:
+#   rake_tasks:
+#     gem:
+#       package_dir: pkg
+#       need_tar: false
+#       need_tar_gz: false
+#       need_tar_bz2: false
+#       need_zip: false
+#       ...
+#
+# If you have specific needs requiring manual intervention on this file,
+# don't forget to set safe-override to false in your noe specification:
+#
+# template-info:
+#   manifest:
+#     tasks/gem.rake:
+#       safe-override: false
+#
+begin
+  require 'rubygems/package_task'
+
+  # Dynamically load the gem spec
+  gemspec_file = File.expand_path('../../gisele-language.gemspec', __FILE__)
+  gemspec      = Kernel.eval(File.read(gemspec_file))
+
+  Gem::PackageTask.new(gemspec) do |t|
+
+    # Name of the package
+    t.name = gemspec.name
+
+    # Version of the package
+    t.version = gemspec.version
+
+    # Directory used to store the package files
+    t.package_dir = "pkg"
+
+    # True if a gzipped tar file (tgz) should be produced
+    t.need_tar = false
+
+    # True if a gzipped tar file (tar.gz) should be produced
+    t.need_tar_gz = false
+
+    # True if a bzip2'd tar file (tar.bz2) should be produced
+    t.need_tar_bz2 = false
+
+    # True if a zip file should be produced (default is false)
+    t.need_zip = false
+
+    # List of files to be included in the package.
+    t.package_files = gemspec.files
+
+    # Tar command for gzipped or bzip2ed archives.
+    t.tar_command = "tar"
+
+    # Zip command for zipped archives.
+    t.zip_command = "zip"
+
+  end
+rescue LoadError
+  task :gem do
+    abort 'rubygems/package_task is not available. You should verify your rubygems installation'
+  end
+  task :package do
+    abort 'rubygems/package_task is not available. You should verify your rubygems installation'
+  end
+end

data/tasks/spec_test.rake

@@ -0,0 +1,71 @@
+# Installs a rake task for for running examples written using rspec.
+#
+# This file installs the 'rake spec_test' (aliased as 'rake spec') as well as
+# extends 'rake test' to run spec tests, if any. It is automatically generated
+# by Noe from your .noespec file, and should therefore be configured there,
+# under the variables/rake_tasks/spec_test entry, as illustrated below:
+#
+# variables:
+#   rake_tasks:
+#     spec_test:
+#       pattern: spec/**/*_spec.rb
+#       verbose: true
+#       rspec_opts: [--color, --backtrace]
+#       ...
+#
+# If you have specific needs requiring manual intervention on this file,
+# don't forget to set safe-override to false in your noe specification:
+#
+# template-info:
+#   manifest:
+#     tasks/spec_test.rake:
+#       safe-override: false
+#
+# This file has been written to conform to RSpec v2.4.0. More information about
+# rspec and options of the rake task defined below can be found on
+# http://relishapp.com/rspec
+#
+begin
+  require "rspec/core/rake_task"
+  desc "Run RSpec code examples"
+  RSpec::Core::RakeTask.new(:spec_test) do |t|
+    # Glob pattern to match files.
+    t.pattern = "spec/**/test_*.rb"
+
+    # Whether or not to fail Rake when an error occurs (typically when
+    # examples fail).
+    t.fail_on_error = true
+
+    # A message to print to stderr when there are failures.
+    t.failure_message = nil
+
+    # Use verbose output. If this is set to true, the task will print the
+    # executed spec command to stdout.
+    t.verbose = true
+
+    # Use rcov for code coverage?
+    t.rcov = false
+
+    # Path to rcov.
+    t.rcov_path = "rcov"
+
+    # Command line options to pass to rcov. See 'rcov --help' about this
+    t.rcov_opts = []
+
+    # Command line options to pass to ruby. See 'ruby --help' about this
+    t.ruby_opts = []
+
+    # Path to rspec
+    t.rspec_path = "rspec"
+
+    # Command line options to pass to rspec. See 'rspec --help' about this
+    t.rspec_opts = ["--color", "--backtrace"]
+  end
+rescue LoadError => ex
+  task :spec_test do
+    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
+  end
+ensure
+  task :spec => [:spec_test]
+  task :test => [:spec_test]
+end