gisele 0.0.1 → 0.1.0

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

@@ -0,0 +1,35 @@
+module Gisele
+  module Language
+    module Syntax
+      module Node
+
+        def to_ast
+          Language::AST.node(_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 '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 'task_refinement'
+require_relative 'task_signature'
+require_relative 'task_def'
+require_relative 'unit'

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,17 @@
+module Gisele
+  module Language
+    module Syntax
+      module TaskDef
+        include Node
+
+        def _to_ast
+          name = captures[:task_name].first.strip
+          sig  = captures[:task_signature].map{|x| x.to_ast}.first || [:task_signature]
+          ref  = captures[:task_refinement].map{|x| x.to_ast}.first || [:task_refinement]
+          [:task_def, name, sig, ref]
+        end
+
+      end # module TaskDef
+    end # module Syntax
+  end # module Language
+end # module Gisele

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

@@ -0,0 +1,15 @@
+module Gisele
+  module Language
+    module Syntax
+      module TaskRefinement
+        include Node
+
+        def _to_ast
+          main = captures[:process_statement].first.to_ast
+          [:task_refinement, main]
+        end
+
+      end # module TaskRefinement
+    end # module Syntax
+  end # module Language
+end # module Gisele

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

@@ -0,0 +1,15 @@
+module Gisele
+  module Language
+    module Syntax
+      module TaskSignature
+        include Node
+
+        def _to_ast
+          list = captures[:task_signature_element].map{|x| x.to_ast}
+          [:task_signature] + list
+        end
+
+      end # module TaskSignature
+    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, name, init, term, initval]
+        end
+
+      end # module TrackvarDef
+    end # module Syntax
+  end # module Language
+end # module Gisele

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

@@ -0,0 +1,14 @@
+module Gisele
+  module Language
+    module Syntax
+      module Unit
+        include Node
+
+        def _to_ast
+          [:unit] + captures[:task_def].map{|x| x.to_ast}
+        end
+
+      end # module Unit
+    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/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/syntax.rb

@@ -0,0 +1,29 @@
+require_relative 'syntax/node'
+module Gisele
+  module Language
+    module Syntax
+      Citrus.load(File.expand_path('../syntax/grammar', __FILE__))
+
+      def parse(input, options = {})
+        source = parsing_source(input)
+        Grammar.parse(source, options)
+      end
+      module_function :parse
+
+      def ast(input, parse_options = {})
+        parse(input, parse_options).to_ast
+      end
+      module_function :ast
+
+      private
+
+      def parsing_source(input)
+        input = File.read(input.to_path) if input.respond_to?(:to_path)
+        input = input.to_str if input.respond_to?(:to_str)
+        input
+      end
+      module_function :parsing_source
+
+    end # module Syntax
+  end # module Language
+end # module Gisele

data/lib/gisele/language/transformer.rb

@@ -0,0 +1,38 @@
+module Gisele
+  module Language
+    class Transformer
+      include AST::Helpers
+
+      def call(node)
+        node = pre_call(node)
+        meth = :"on_#{node.rule_name}"
+        meth = :"on_missing" unless respond_to?(meth)
+        post_call send(meth, node)
+      end
+
+      def on_missing(node)
+        raise UnexpectedNodeError, "Unexpected node: #{node.rule_name}"
+      end
+
+      protected
+
+      def pre_call(node)
+        unless looks_a_node?(node)
+          raise ArgumentError, "AST node expected, got #{node.inspect}", caller
+        end
+        node(node)
+      end
+
+      def post_call(transformed)
+        looks_a_node?(transformed) ? node(transformed) : transformed
+      end
+
+      def copy_and_applyall(node)
+        node.copy do |memo,child|
+          memo << (child.is_a?(AST::Node) ? call(child) : child)
+        end
+      end
+
+    end # class Transformer
+  end # module Language
+end # module Gisele

data/lib/gisele/language.rb

@@ -1,6 +1,20 @@
 module Gisele
   module Language
 
+    def rule2mod(rule)
+      rule.to_s.gsub(/(^|_)([a-z])/){|x| $2.capitalize}.to_sym
+    end
+    module_function :rule2mod
+
+    def mod2rule(mod)
+      mod = mod.name.to_s.split('::').last.to_sym if mod.is_a?(Module)
+      mod.to_s.gsub(/[A-Z]/){|x| "_#{x.downcase}"}[1..-1].to_sym
+    end
+    module_function :mod2rule
+
   end # module Language
 end # module Gisele
-require_relative 'language/parser'
+require_relative 'language/syntax'
+require_relative 'language/ast'
+require_relative 'language/transformer'
+require_relative 'language/sugar_removal'

data/lib/gisele/version.rb

@@ -2,8 +2,8 @@ module Gisele
   module Version
 
     MAJOR = 0
-    MINOR = 0
-    TINY  = 1
+    MINOR = 1
+    TINY  = 0
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

data/lib/gisele.rb

@@ -1,14 +1,20 @@
 require_relative "gisele/version"
 require_relative "gisele/loader"
+require_relative 'gisele/errors'
 #
 # Gisele is a Process Analyzer Toolset
 #
 module Gisele
 
   def parse(input)
-    Language::Parser::parse(input)
+    Language::Syntax::parse(input)
   end
   module_function :parse
 
+  def ast(input)
+    Language::Syntax::ast(input)
+  end
+  module_function :ast
+
 end # module Gisele
 require_relative 'gisele/language'

data/spec/command/main/gisele_ast_ruby.stdout

@@ -1,43 +1,53 @@
 [
-    :task,
-    "Simple",
+    :unit,
     [
-        :signature,
+        :task_def,
+        "Simple",
         [
-            :fluent,
-            "diagKnown",
+            :task_signature,
             [
-                :event_set,
-                "Diagnosis:start"
-            ],
-            [
-                :event_set,
-                "Treatment:end"
-            ],
-            nil
-        ]
-    ],
-    [
-        :refinement,
+                :fluent,
+                "diagKnown",
+                [
+                    :event_set,
+                    "Diagnosis:start"
+                ],
+                [
+                    :event_set,
+                    "Treatment:end"
+                ],
+                nil
+            ]
+        ],
         [
-            :seq,
+            :task_refinement,
             [
-                :if,
+                :seq_st,
                 [
-                    :not,
+                    :if_st,
+                    [
+                        :bool_not,
+                        [
+                            :var_ref,
+                            "diagKnown"
+                        ]
+                    ],
                     [
-                        :varref,
-                        "diagKnown"
+                        :task_call_st,
+                        "Diagnosis"
+                    ],
+                    [
+                        :else_clause,
+                        [
+                            :task_call_st,
+                            "NoDiag"
+                        ]
                     ]
                 ],
                 [
-                    :task_call,
-                    "Diagnosis"
+                    :task_call_st,
+                    "Treatment"
                 ]
-            ],
-            [
-                :task_call,
-                "Treatment"
             ]
         ]
     ]

data/spec/command/main/gisele_help.stdout

@@ -7,6 +7,7 @@ SYNOPSIS
 
 OPTIONS
       --ast=[MODE]                 Prints the process abstract syntax tree (debug,ruby)
+      --no-sugar                   Apply syntactic sugar removal
       --help                       Show this help message
       --version                    Show version and exit
 
@@ -19,4 +20,8 @@ DESCRIPTION
   debugging, that is with colors and extra information. Use --ast=ruby to get a ruby
   array for automatic processing.
 
+  When --no-sugar is specified, syntactic sugar is first removed before making any other
+  transformation. For now, this rewrites all `if` statements as explicit `case` guarded
+  commands.
+
 SystemExit

data/spec/command/main/gisele_no_sugar.cmd

@@ -0,0 +1 @@
+gisele --no-sugar --ast=ruby tasks/simple.gis

data/spec/command/main/gisele_no_sugar.stdout

@@ -0,0 +1,61 @@
+[
+    :unit,
+    [
+        :task_def,
+        "Simple",
+        [
+            :task_signature,
+            [
+                :fluent,
+                "diagKnown",
+                [
+                    :event_set,
+                    "Diagnosis:start"
+                ],
+                [
+                    :event_set,
+                    "Treatment:end"
+                ],
+                nil
+            ]
+        ],
+        [
+            :task_refinement,
+            [
+                :seq_st,
+                [
+                    :case_st,
+                    [
+                        :when_clause,
+                        [
+                            :bool_not,
+                            [
+                                :var_ref,
+                                "diagKnown"
+                            ]
+                        ],
+                        [
+                            :task_call_st,
+                            "Diagnosis"
+                        ]
+                    ],
+                    [
+                        :when_clause,
+                        [
+                            :var_ref,
+                            "diagKnown"
+                        ],
+                        [
+                            :task_call_st,
+                            "NoDiag"
+                        ]
+                    ]
+                ],
+                [
+                    :task_call_st,
+                    "Treatment"
+                ]
+            ]
+        ]
+    ]
+]

data/spec/fixtures/tasks/simple.ast

@@ -1,15 +1,19 @@
-[:task, "Simple",
-  [:signature,
-    [:fluent, "diagKnown",
-      [:event_set, "Diagnosis:start"],
-      [:event_set, "Treatment:end"],
-      nil ]
-    ],
-  [:refinement, 
-    [:seq, 
-      [:if, 
-        [:not, [:varref, "diagKnown"]], 
-        [:task_call, "Diagnosis"] ],
-      [:task_call, "Treatment"]]
-    ]
+[:unit,
+  [:task_def, "Simple",
+    [:task_signature,
+      [:fluent, "diagKnown",
+        [:event_set, "Diagnosis:start"],
+        [:event_set, "Treatment:end"],
+        nil ]
+      ],
+    [:task_refinement, 
+      [:seq_st, 
+        [:if_st, 
+          [: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

@@ -3,6 +3,8 @@ task Simple
   refinement
     if not(diagKnown)
       Diagnosis
+    else
+      NoDiag
     end
     Treatment
   end

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ ensure
   $stdout, $stderr = stdout, stderr
 end
 
-module Helpers
+module SpecHelpers
 
   def fixtures_dir
     (Path.dir/:fixtures)
@@ -24,6 +24,6 @@ module Helpers
 end
 
 RSpec.configure do |c|
-  c.extend  Helpers
-  c.include Helpers
+  c.extend  SpecHelpers
+  c.include SpecHelpers
 end

data/spec/test_examples.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 describe "The examples" do
-  
+
   (Path.backfind(".[examples]")/:examples).glob("**/*.gis").each do |file|
 
     describe file do
       it 'parses without any error' do
-        Gisele::parse(file).should be_a(Array)
+        Gisele::ast(file).should be_a(Array)
       end
     end
 
   end
-  
+
 end

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module Gisele::Language::AST
+  describe Node do
+    include Helpers
+
+    describe 'rule_name' do
+      it 'returns the first array element' do
+        node([:hello]).rule_name.should eq(:hello)
+      end
+    end
+
+    describe 'children' do
+
+      it 'returns all but the rule name' do
+        node([:hello, "world", "!"]).children.should eq(["world", "!"])
+      end
+
+      it 'returns an empty array when no children' do
+        node([:hello]).children.should eq([])
+      end
+
+    end # children
+
+    describe 'copy' do
+
+      it 'collects block results ala `inject`' do
+        source = node([:unit, "world", "gisele"])
+        target = source.copy do |memo,child|
+          memo << child.upcase
+        end
+        target.should be_a(Unit)
+        target.should eq([:unit, "WORLD", "GISELE"])
+      end
+
+      it 'returns a real equal copy when no children' do
+        source = node([:unit])
+        target = source.copy do |memo,child| end
+        target.should eq(source)
+        target.object_id.should_not eq(source.object_id)
+        target.should be_a(Unit)
+      end
+
+    end
+
+    describe 'dup' do
+
+      it 'duplicates the underlying array' do
+        arr = [:unit, "etc."]
+        node(arr).dup.should eq(arr)
+      end
+
+      it 'ensures duplicated array is still a node' do
+        arr = [:unit, "etc."]
+        node(arr).dup.should be_a(Unit)
+        node(arr).dup.should be_a(Node)
+      end
+
+    end # dup
+
+  end
+end