gisele 0.0.1 → 0.1.0

data/spec/unit/language/test_ast.rb

@@ -1,264 +1,38 @@
 require 'spec_helper'
 module Gisele::Language
-  describe Grammar, "ast" do
+  describe AST do
 
-    let(:grammar){ Gisele::Language::Grammar }
+    describe 'ast' do
 
-    def ast(text, rule, consume = true)
-      grammar.parse(text, :root => rule, :consume => consume).value
-    end
-
-    describe "the bool_expr rule" do
-
-      it 'returns expected ast on simple expressions' do
-        expected = [:and, [:varref, "diagKnown"], [:varref, "platLow"]]
-        ast("diagKnown and platLow", :bool_expr).should eq(expected)
-      end
-
-      it 'respects priorities' do
-        expected = [:or, [:and, [:varref, "diagKnown"], [:varref, "platLow"]], [:varref, "platHigh"]]
-        ast("diagKnown and platLow or platHigh", :bool_expr).should eq(expected)
-      end
-
-      it 'supports double negations' do
-        expected = [:not, [:not, [:varref, "diagKnown"]]]
-        ast("not not(diagKnown)", :bool_expr).should eq(expected)
-      end
-
-    end # bool_expr
-
-    describe 'the event_commalist rule' do
-
-      it 'parses singleton lists as expected' do
-        expr     = 'Diagnosis:start'
-        expected = ["Diagnosis:start"]
-        ast(expr, :event_commalist).should eq(expected)
-      end
-
-      it 'parses non empty lists as expected' do
-        expr     = 'Diagnosis:start, an_event'
-        expected = ["Diagnosis:start", "an_event"]
-        ast(expr, :event_commalist).should eq(expected)
-      end
-
-    end # event_commalist
-
-    describe 'the event_set rule' do
-
-      it 'parses non empty lists as expected' do
-        expr     = '{Diagnosis:start, an_event}'
-        expected = [:event_set, "Diagnosis:start", "an_event"]
-        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_statement rule" do
-
-      it 'parses as expected' do
-        ast("Diagnosis", :task_call_statement).should eq([:task_call, "Diagnosis"])
-      end
-
-    end # task_call_statement
-
-    describe "the statement_list rule" do
-
-      it 'parses a list of 2 elements' do
-        expr     = "Task1 Task2"
-        expected = [[:task_call, "Task1"], [:task_call, "Task2"]]
-        ast(expr, :statement_list).should eq(expected)
+      it 'returns a node' do
+        node = [:unit].extend(AST::Node)
+        AST.node(node).object_id.should eq(node.object_id)
       end
 
-      it 'parses a list of 3 elements' do
-        expr     = "Task1 Task2 Task3"
-        expected = [[:task_call, "Task1"], [:task_call, "Task2"], [:task_call, "Task3"]]
-        ast(expr, :statement_list).should eq(expected)
+      it 'coerces an array' do
+        AST.node([:unit]).should eq([:unit])
+        AST.node([:unit]).should be_a(AST::Unit)
       end
 
-    end # statement_list
-
-    describe "the par_statement rule" do
-
-      it 'parses as expected' do
-        expr     = "par Task1 Task2 end"
-        expected = [:par, [:task_call, "Task1"], [:task_call, "Task2"]]
-        ast(expr, :par_statement).should eq(expected)
-      end
-
-    end # par_statement
-
-    describe "the seq_statement rule" do
-
-      it 'parses as expected' do
-        expr     = "seq Task1 Task2 end"
-        expected = [:seq, [:task_call, "Task1"], [:task_call, "Task2"]]
-        ast(expr, :seq_statement).should eq(expected)
-      end
-
-    end # seq_statement
-
-    describe "the while_statement rule" do
-
-      it 'parses as expected' do
-        expr     = "while goodCond Task1 end"
-        expected = \
-          [:while,
-            [:varref, "goodCond"],
-            [:task_call, "Task1"]]
-        ast(expr, :while_statement).should eq(expected)
-      end
-
-      it 'recognizes implicit sequences' do
-        expr     = "while goodCond Task1 Task2 end"
-        expected = \
-          [:while,
-            [:varref, "goodCond"],
-            [:seq, [:task_call, "Task1"], [:task_call, "Task2"]]]
-        ast(expr, :while_statement).should eq(expected)
-      end
-
-    end # while_statement
-
-    describe "the else_clause rule" do
-
-      it 'parses as expected' do
-        expr     = "else Task1 "
-        expected = \
-          [:else, [:task_call, "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, [:varref, "goodCond"], [:task_call, "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, [:varref, "goodCond"], [:task_call, "Task1"]]
-        ast(expr, :if_statement).should eq(expected)
-      end
-
-      it 'supports a else clause' do
-        expr     = "if goodCond Task1 else Task2 end"
-        expected = \
-          [:if,
-            [:varref, "goodCond"], [:task_call, "Task1"],
-            [:else, [:task_call, "Task2"]] ]
-        ast(expr, :if_statement).should eq(expected)
-      end
-
-      it 'supports elsif clauses' do
-        expr     = "if goodCond Task1 elsif otherCond Task2 elsif stillAnother Task3 else Task4 end"
-        expected = \
-          [:if,
-            [:varref, "goodCond"], [:task_call, "Task1"],
-            [:elsif,
-              [:varref, "otherCond"], [:task_call, "Task2"]],
-            [:elsif,
-              [:varref, "stillAnother"], [:task_call, "Task3"]],
-            [:else,
-              [:task_call, "Task4"]] ]
-        ast(expr, :if_statement).should eq(expected)
+      it 'falls back to Node' do
+        AST.node([:nosuchnode]).should eq([:nosuchnode])
+        AST.node([:nosuchnode]).should be_a(AST::Node)
       end
 
-    end # if_statement
-
-    describe 'the task_refinement rule' do
-
-      it 'parses as expected' do
-        expr     = "refinement Task1 end"
-        expected = [:task_call, "Task1"]
-        ast(expr, :task_refinement).should eq(expected)
+      it 'applies coercions recursively' do
+        source = [:unit, [:hello, "world"]]
+        AST.node(source).should eq(source)
+        AST.node(source).last.should be_a(AST::Node)
       end
 
-    end # task_refinement
-
-    describe 'the task_signature rule' do
-
-      it 'parses as expected' do
-        expr     = "fluent diagKnown {}, {}\ntrackvar mplus {}"
-        expected = \
-          [ [: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, "Task1",
-            [:signature,
-              [:fluent, "diagKnown", [:event_set], [:event_set], nil]],
-            [:refinement,
-              [:task_call, "Task2"]]]
-        ast(expr, :task_def).should eq(expected)
+      it 'raises unless a ast node array' do
+        lambda{ AST.node("foo") }.should raise_error(ArgumentError, /foo/)
+        lambda{ AST.node(nil) }.should raise_error(ArgumentError, /nil/)
+        lambda{ AST.node([]) }.should raise_error(ArgumentError, /\[\]/)
+        lambda{ AST.node(["foo"]) }.should raise_error(ArgumentError, /foo/)
       end
 
-    end # task_def
+    end # .ast
 
   end
 end

data/spec/unit/language/test_syntax.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Syntax do
+    include Syntax
+
+    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("if goodCond Task1 end", :root => :if_st)
+        ast.should be_a(AST::Node)
+        ast.first.should eq(:if_st)
+      end
+
+      fixture_files('tasks/**/*.gis').each do |file|
+        it "works on #{file}" do
+          parsed = Syntax.ast(file)
+          parsed.should be_a(Array)
+          parsed.should be_a(AST::Node)
+          parsed.first.should eq(:unit)
+          if (astfile = file.sub_ext(".ast")).exist?
+            parsed.should eq(Kernel::eval(astfile.read, TOPLEVEL_BINDING, astfile.to_s))
+          end
+        end
+      end
+
+    end # ast
+
+  end
+end

data/spec/unit/language/test_transformer.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+module Gisele::Language
+  describe Transformer do
+
+    let(:transformer_class){
+      Class.new(Transformer) do
+
+        def on_hello(node)
+          [:seen_hello, node]
+        end
+
+        def on_copy(node)
+          copy_and_applyall(node)
+        end
+
+        def on_missing(node)
+          if node.rule_name == :nosuchone
+            [:seen_missing, node]
+          else
+            super
+          end
+        end
+
+      end
+    }
+    let(:transformer){ transformer_class.new }
+
+    describe 'call' do
+
+      it 'dispatches to existing methods' do
+        ast = [:hello, "world"]
+        transformer.call(ast).should eq([:seen_hello, [:hello, "world"]])
+      end
+
+      it 'calls on_missing when not found' do
+        ast = [:nosuchone, "world"]
+        transformer.call(ast).should eq([:seen_missing, [:nosuchone, "world"]])
+      end
+
+      it 'raises unexpected by default in on_missing' do
+        ast = [:nonono, "world"]
+        lambda{ transformer.call(ast) }.should raise_error(Gisele::UnexpectedNodeError, /nonono/)
+      end
+
+      it 'performs post node transformation if required' do
+        ast = [:hello, "world"]
+        transformer.call(ast).should be_a(AST::Node)
+      end
+
+      it 'raises an ArgumentError unless called on a non terminal' do
+        lambda{
+          transformer.call("world").should raise_error(ArgumentError, /world/)
+        }
+      end
+
+    end
+
+    describe "copy_and_applyall" do
+
+      it 'provides a friendly way of applying copy/recurse' do
+        ast = [:copy, [:hello, 'world'], "!"]
+        transformer.call(ast).should eq([:copy, [:seen_hello, [:hello, "world"]], "!"])
+      end
+
+    end
+
+  end
+end

data/spec/unit/test_language.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Gisele
+  describe Language do
+    include Language
+
+    describe "rule2mod" do
+
+      it 'work on simple rule name' do
+        rule2mod(:test).should eq(:Test)
+      end
+
+      it 'works when underscores are present' do
+        rule2mod(:a_rule_name).should eq(:ARuleName)
+      end
+
+    end # rule2mod
+
+    describe "mod2rule" do
+
+      it 'work on simple module name' do
+        mod2rule(:Test).should eq(:test)
+      end
+
+      it 'work on complex module name' do
+        mod2rule(:ThisIsATest).should eq(:this_is_a_test)
+      end
+
+      it 'works with a module' do
+        mod2rule(::Gisele::Language::Syntax::WhileSt).should eq(:while_st)
+      end
+
+    end # rule2mod
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gisele
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-16 00:00:00.000000000Z
+date: 2012-02-17 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70127446593920 !ruby/object:Gem::Requirement
+  requirement: &70134950121580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70127446593920
+  version_requirements: *70134950121580
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70127446592980 !ruby/object:Gem::Requirement
+  requirement: &70134950028240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70127446592980
+  version_requirements: *70134950028240
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70127446592060 !ruby/object:Gem::Requirement
+  requirement: &70134950027180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *70127446592060
+  version_requirements: *70134950027180
 - !ruby/object:Gem::Dependency
   name: wlang
-  requirement: &70127446581420 !ruby/object:Gem::Requirement
+  requirement: &70134950026340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.10.2
   type: :development
   prerelease: false
-  version_requirements: *70127446581420
+  version_requirements: *70134950026340
 - !ruby/object:Gem::Dependency
   name: citrus
-  requirement: &70127446580260 !ruby/object:Gem::Requirement
+  requirement: &70134950025360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: '2.4'
   type: :runtime
   prerelease: false
-  version_requirements: *70127446580260
+  version_requirements: *70134950025360
 - !ruby/object:Gem::Dependency
   name: epath
-  requirement: &70127446579180 !ruby/object:Gem::Requirement
+  requirement: &70134950024560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,10 +76,10 @@ dependencies:
         version: 0.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *70127446579180
+  version_requirements: *70134950024560
 - !ruby/object:Gem::Dependency
   name: quickl
-  requirement: &70127446578340 !ruby/object:Gem::Requirement
+  requirement: &70134950023760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,10 +87,10 @@ dependencies:
         version: 0.4.3
   type: :runtime
   prerelease: false
-  version_requirements: *70127446578340
+  version_requirements: *70134950023760
 - !ruby/object:Gem::Dependency
   name: awesome_print
-  requirement: &70127446577380 !ruby/object:Gem::Requirement
+  requirement: &70134950022720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -98,7 +98,7 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70127446577380
+  version_requirements: *70134950022720
 description: ! 'This is a fresh-new implementation of the process analysis techniques
 
   developed in the Gisele and PIPAS research projects at UCLouvain'
@@ -120,8 +120,38 @@ files:
 - bin/gisele
 - examples/meeting-scheduler/MeetingScheduling.gis
 - lib/gisele/command.rb
-- lib/gisele/language/grammar.citrus
-- lib/gisele/language/parser.rb
+- lib/gisele/errors.rb
+- lib/gisele/language/ast/helpers.rb
+- lib/gisele/language/ast/node.rb
+- lib/gisele/language/ast/unit.rb
+- lib/gisele/language/ast.rb
+- lib/gisele/language/sugar_removal.rb
+- lib/gisele/language/syntax/bool_and.rb
+- lib/gisele/language/syntax/bool_lit.rb
+- lib/gisele/language/syntax/bool_not.rb
+- lib/gisele/language/syntax/bool_or.rb
+- lib/gisele/language/syntax/bool_paren.rb
+- lib/gisele/language/syntax/else_clause.rb
+- lib/gisele/language/syntax/elsif_clause.rb
+- lib/gisele/language/syntax/event_set.rb
+- lib/gisele/language/syntax/fluent_def.rb
+- lib/gisele/language/syntax/grammar.citrus
+- lib/gisele/language/syntax/if_st.rb
+- lib/gisele/language/syntax/implicit_seq_st.rb
+- lib/gisele/language/syntax/node.rb
+- lib/gisele/language/syntax/par_st.rb
+- lib/gisele/language/syntax/seq_st.rb
+- lib/gisele/language/syntax/st_list.rb
+- lib/gisele/language/syntax/task_call_st.rb
+- lib/gisele/language/syntax/task_def.rb
+- lib/gisele/language/syntax/task_refinement.rb
+- lib/gisele/language/syntax/task_signature.rb
+- lib/gisele/language/syntax/trackvar_def.rb
+- lib/gisele/language/syntax/unit.rb
+- lib/gisele/language/syntax/var_ref.rb
+- lib/gisele/language/syntax/while_st.rb
+- lib/gisele/language/syntax.rb
+- lib/gisele/language/transformer.rb
 - lib/gisele/language.rb
 - lib/gisele/loader.rb
 - lib/gisele/version.rb
@@ -134,6 +164,8 @@ files:
 - spec/command/main/gisele_ast_ruby.stdout
 - spec/command/main/gisele_help.cmd
 - spec/command/main/gisele_help.stdout
+- spec/command/main/gisele_no_sugar.cmd
+- spec/command/main/gisele_no_sugar.stdout
 - spec/command/main/gisele_version.cmd
 - spec/command/main/gisele_version.stdout
 - spec/command/test_command.rb
@@ -141,10 +173,15 @@ files:
 - spec/fixtures/tasks/simple.gis
 - spec/spec_helper.rb
 - spec/test_examples.rb
+- spec/unit/language/ast/test_node.rb
+- spec/unit/language/sugar_removal/test_if_to_guarded_commands.rb
+- spec/unit/language/syntax/test_grammar.rb
+- spec/unit/language/syntax/test_to_ast.rb
 - spec/unit/language/test_ast.rb
-- spec/unit/language/test_grammar.rb
-- spec/unit/language/test_parser.rb
+- spec/unit/language/test_syntax.rb
+- spec/unit/language/test_transformer.rb
 - spec/unit/test_gisele.rb
+- spec/unit/test_language.rb
 - tasks/debug_mail.rake
 - tasks/debug_mail.txt
 - tasks/gem.rake
@@ -165,7 +202,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4101248943580422503
+      hash: -2777835670012084504
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -183,6 +220,8 @@ test_files:
 - spec/command/main/gisele_ast_ruby.stdout
 - spec/command/main/gisele_help.cmd
 - spec/command/main/gisele_help.stdout
+- spec/command/main/gisele_no_sugar.cmd
+- spec/command/main/gisele_no_sugar.stdout
 - spec/command/main/gisele_version.cmd
 - spec/command/main/gisele_version.stdout
 - spec/command/test_command.rb
@@ -190,7 +229,12 @@ test_files:
 - spec/fixtures/tasks/simple.gis
 - spec/spec_helper.rb
 - spec/test_examples.rb
+- spec/unit/language/ast/test_node.rb
+- spec/unit/language/sugar_removal/test_if_to_guarded_commands.rb
+- spec/unit/language/syntax/test_grammar.rb
+- spec/unit/language/syntax/test_to_ast.rb
 - spec/unit/language/test_ast.rb
-- spec/unit/language/test_grammar.rb
-- spec/unit/language/test_parser.rb
+- spec/unit/language/test_syntax.rb
+- spec/unit/language/test_transformer.rb
 - spec/unit/test_gisele.rb
+- spec/unit/test_language.rb