gisele 0.4.0 → 0.5.0

data/lib/gisele/language/ast.rb

@@ -1,14 +0,0 @@
-module Gisele
-  module Language
-    module AST
-
-      def node(arg, markers = {})
-        AST::Helpers.node(arg, markers)
-      end
-      module_function :node
-
-    end # module AST
-  end # module Language
-end # module Gisele
-require_relative 'ast/helpers'
-require_relative 'ast/node'

data/lib/gisele/language/ast/helpers.rb

@@ -1,43 +0,0 @@
-module Gisele
-  module Language
-    module AST
-      module Helpers
-
-        def ast(arg, markers = {})
-          return node(arg, markers) if looks_a_node?(arg)
-          ast(Syntax.ast(arg), markers)
-        end
-
-        def node(arg, markers = {})
-          return arg if arg.is_a?(Node)
-          unless looks_a_node?(arg)
-            raise ArgumentError, "Array expected, #{arg.inspect} found."
-          end
-          extend_node(arg, markers).tap do |node|
-            node.children.each{|c| node(c) if looks_a_node?(c)}
-          end
-        end
-
-        private
-
-        def looks_a_node?(arg)
-          arg.is_a?(Node) or (arg.is_a?(Array) and arg.first.is_a?(Symbol))
-        end
-
-        def extend_node(arg, markers)
-          mod = ast_module(arg)
-          arg.extend(mod).tap do |node|
-            node.markers = markers
-          end
-        end
-
-        def ast_module(node)
-          modname = Language.rule2mod(node.first)
-          AST.const_get(modname) rescue Node
-        end
-
-        extend(self)
-      end # module Helpers
-    end # module AST
-  end # module Language
-end # module Gisele

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

@@ -1,10 +0,0 @@
-module Gisele
-  module Language
-    module AST
-      module UnitDef
-        include Node
-
-      end # module UnitDef
-    end # module AST
-  end # module Language
-end # module Gisele

data/lib/gisele/language/grammar.dot.yml

@@ -1,19 +0,0 @@
-task_def:
-  shape: circle
-  style: filled
-  fillcolor: black
-  fixed: true
-  width: 0.1
-task_call_st:
-  shape: box
-while_st:
-  shape: diamond
-if_st:
-  shape: diamond
-case_st:
-  shape: diamond
-par_st:
-  shape: box
-  height: 0.1
-  style: filled
-  fillcolor: black

data/lib/gisele/language/processors/to_graph.rb

@@ -1,146 +0,0 @@
-module Gisele
-  module Language
-    class ToGraph < Rewriter
-      module Connector; end
-
-      def on_unit_def(node)
-        node.
-          children.
-          select{|n| n.first == :task_def}.
-          map{|taskdef| call(taskdef) }
-      end
-
-      def on_task_def(node)
-        @graph = Yargi::Digraph.new
-
-        entry, exit = add_vertex(node), add_vertex(node)
-
-        # flatten all elsif
-        c_entry, c_exit = call(ElsifFlattener.new.call(node.last))
-        connect(entry, c_entry)
-        connect(c_exit, exit)
-
-        @graph.vertices(Connector).each do |vertex|
-          next unless vertex.out_edges.size == 1
-          target = vertex.out_edges.first.target
-          @graph.reconnect(vertex.in_edges, nil, target)
-          @graph.remove_vertex(vertex)
-        end
-
-        @graph
-      end
-
-      def on_seq_st(node)
-        mine    = entry_and_exit(node)
-        current = mine.first
-        node.children.each do |child|
-          c_entry, c_exit = call(child)
-          connect(current, c_entry)
-          current = c_exit
-        end
-        connect(current, mine.last)
-        mine
-      end
-
-      def on_par_st(node)
-        entry, exit = add_vertex(node), add_vertex(node)
-        node.children.each do |child|
-          c_entry, c_exit = call(child)
-          connect(entry, c_entry)
-          connect(c_exit, exit)
-        end
-        [entry, exit]
-      end
-
-      def on_if_st(node)
-        cond, then_clause, else_clause, = node.children
-
-        entry, exit = entry_and_exit(node)
-
-        diamond = add_vertex(node)
-        connect(entry, diamond)
-
-        c_entry, c_exit = call(then_clause)
-        connect(diamond, c_entry, true_ast_node)
-        connect(c_exit, exit)
-
-        if else_clause
-          c_entry, c_exit = call(else_clause.last)
-          connect(diamond, c_entry, false_ast_node)
-          connect(c_exit, exit)
-        else
-          connect(diamond, exit, false_ast_node)
-        end
-
-        [entry, exit]
-      end
-
-      def on_case_st(node)
-        cond, *clauses = node.children
-
-        entry, exit = entry_and_exit(node)
-
-        diamond = add_vertex(node)
-        connect(entry, diamond)
-
-        clauses.each do |clause|
-          c_entry, c_exit = call(clause.last)
-          connect(diamond, c_entry, clause)
-          connect(c_exit, exit)
-        end
-
-        [entry, exit]
-      end
-
-
-      def on_while_st(node)
-        cond, dost, = node.children
-
-        entry, exit = entry_and_exit(node)
-
-        diamond = add_vertex(node)
-        connect(entry, diamond)
-
-        c_entry, c_exit = call(node.last)
-
-        connect(diamond, exit,    false_ast_node)
-        connect(diamond, c_entry, true_ast_node)
-        connect(c_exit, diamond)
-
-        [entry, exit]
-      end
-
-      def on_task_call_st(node)
-        entry, exit = entry_and_exit(node)
-        task = add_vertex(node)
-        connect(entry, task)
-        connect(task, exit)
-        [entry, exit]
-      end
-
-      private
-
-      def add_vertex(node)
-        @graph.add_vertex(node.dot_attributes)
-      end
-
-      def entry_and_exit(node, tag = Connector)
-        @graph.add_n_vertices(2, tag)
-      end
-
-      def connect(source, target, node = nil)
-        marks = node.nil? ? {} : node.dot_attributes
-        @graph.connect(source, target, marks)
-      end
-
-      def false_ast_node
-        Syntax.ast("false", :root => :bool_expr)
-      end
-
-      def true_ast_node
-        Syntax.ast("true", :root => :bool_expr)
-      end
-
-    end # class SugarRemoval
-  end # module Language
-end # module Gisele

data/lib/gisele/language/rewriter.rb

@@ -1,60 +0,0 @@
-module Gisele
-  module Language
-    class Rewriter
-      include AST::Helpers
-
-      ### class methods
-
-      def self.helpers
-        @helpers ||= [ WorkOnNodes.new ]
-      end
-
-      def self.add_helper(helper)
-        unless helpers.empty?
-          helpers.last.next_in_chain = helper
-        end
-        helpers << helper
-      end
-
-      ### instance methods
-
-      attr_reader :mainflow
-
-      def initialize(options = {})
-        @options  = options
-        @mainflow = options[:mainflow] || self
-      end
-
-      def call(node)
-        help(node) do |n|
-          meth = :"on_#{node.first}"
-          meth = :"on_missing" unless respond_to?(meth)
-          send(meth, node)
-        end
-      end
-
-      def on_missing(node)
-        raise UnexpectedNodeError, "Unexpected node: #{node.inspect}"
-      end
-
-      def copy_and_applyall(node)
-        node.copy do |memo,child|
-          memo << (child.is_a?(AST::Node) ? call(child) : child)
-        end
-      end
-
-      private
-
-      def help(node)
-        @first_helper ||= self.class.helpers.first
-        @first_helper.call(self, node) do |_,n|
-          yield(n)
-        end
-      end
-
-    end # class Rewriter
-  end # module Language
-end # module Gisele
-require_relative 'rewriter/helper'
-require_relative 'rewriter/work_on_nodes'
-require_relative 'rewriter/scoping'

data/lib/gisele/language/rewriter/helper.rb

@@ -1,41 +0,0 @@
-module Gisele
-  module Language
-    class Rewriter
-      class Helper
-
-        attr_accessor :next_in_chain
-
-        def self.install_on(rewriter)
-          methods = const_get(:Methods)
-          rewriter.module_eval do
-            include methods
-          end
-          rewriter.add_helper(new)
-        end
-
-        def call(rw, node, &bl)
-          meth = :"on_#{node.first}"
-          meth = :"on_missing" unless respond_to?(meth)
-          send(meth, rw, node) do |r,n|
-            next_call(r, n, bl)
-          end
-        end
-
-        def on_missing(rw, node)
-          yield(rw, node)
-        end
-
-        private
-
-        def next_call(rw, node, toplevel)
-          if nic = next_in_chain
-            nic.call(rw, node, &toplevel)
-          else
-            toplevel.call(rw, node)
-          end
-        end
-
-      end # class Helper
-    end # class Rewriter
-  end # module Language
-end # module Gisele

data/lib/gisele/language/rewriter/scoping.rb

@@ -1,34 +0,0 @@
-module Gisele
-  module Language
-    class Rewriter
-      class Scoping < Helper
-
-        module Methods
-
-          def scope_stack
-            @scope_stack ||= []
-          end
-
-          def with_scope(scope)
-            scope_stack.push(scope)
-            result = yield
-            scope_stack.pop
-            result
-          end
-
-        end # module Methods
-
-        def on_missing(rw, node)
-          if node.rule_name.to_s =~ /_def/
-            rw.with_scope(node) do
-              yield(rw, node)
-            end
-          else
-            yield(rw, node)
-          end
-        end
-
-      end # module Scoping
-    end # class Rewriter
-  end # module Language
-end # module Gisele

data/lib/gisele/language/rewriter/work_on_nodes.rb

@@ -1,30 +0,0 @@
-module Gisele
-  module Language
-    class Rewriter
-      class WorkOnNodes < Helper
-        include AST::Helpers
-
-        def call(rw, node, &bl)
-          node = pre_call(node)
-          tran = next_call(rw, node, bl)
-          post_call(tran)
-        end
-
-        protected
-
-        def pre_call(node)
-          unless looks_a_node?(node)
-            msg = "AST node expected, got #{node.inspect}"
-            raise ArgumentError, msg, caller
-          end
-          node(node)
-        end
-
-        def post_call(t)
-          looks_a_node?(t) ? node(t) : t
-        end
-
-      end # module WorkOnNodes
-    end # class Rewriter
-  end # module Language
-end # module Gisele

data/lib/gisele/language/syntax.rb

@@ -1,29 +0,0 @@
-require_relative 'syntax/node'
-module Gisele
-  module Language
-    module Syntax
-      Citrus.load(File.expand_path('../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/spec/unit/language/ast/test_node.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::AST
-  describe Node do
-
-    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 'markers' do
-
-      it 'defaults to an empty hash' do
-        node([:hello]).markers.should eq({})
-      end
-
-    end # markers
-
-    describe 'copy' do
-
-      it 'collects block results ala `inject`' do
-        source = node([:unit_def, "world", "gisele"])
-        target = source.copy do |memo,child|
-          memo << child.upcase
-        end
-        target.should be_a(UnitDef)
-        target.should eq([:unit_def, "WORLD", "GISELE"])
-      end
-
-      it 'returns a real equal copy when no children' do
-        source = node([:unit_def])
-        target = source.copy do |memo,child| end
-        target.should eq(source)
-        target.object_id.should_not eq(source.object_id)
-        target.should be_a(UnitDef)
-      end
-
-      it 'keeps the markers unchanged' do
-        node = node([:unit_def], {:hello => "World"})
-        copy = node.copy do |memo,child| end
-        copy.markers.should eq({:hello => "World"})
-        copy.markers.object_id.should_not eq(node.markers.object_id)
-      end
-
-    end
-
-    describe 'dup' do
-
-      it 'duplicates the underlying array' do
-        arr = [:unit_def, "etc."]
-        node(arr).dup.should eq(arr)
-      end
-
-      it 'ensures duplicated array is still a node' do
-        arr = [:unit_def, "etc."]
-        node(arr).dup.should be_a(UnitDef)
-        node(arr).dup.should be_a(Node)
-      end
-
-      it 'keeps the markers unchanged' do
-        node = node([:unit_def, "etc."], {:hello => "World"})
-        copy = node.dup
-        copy.markers.should eq({:hello => "World"})
-        copy.markers.object_id.should_not eq(node.markers.object_id)
-      end
-
-    end # dup
-
-  end
-end