gisele 0.4.0 → 0.5.0

data/spec/unit/language/processors/test_to_graph.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe ToGraph do
-
-    it 'returns an array of Digraphs when called on a unit_def' do
-      got = ToGraph.new.call(complete_ast)
-      got.should be_a(Array)
-      got.all?{|x| x.is_a? Yargi::Digraph}.should be_true
-    end
-
-    it 'returns a Digraph when called on a task_def' do
-      got = ToGraph.new.call(complete_ast.last)
-      got.should be_a(Yargi::Digraph)
-    end
-
-  end
-end

data/spec/unit/language/rewriter/test_helper.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  class Rewriter
-    describe Helper do
-
-      class FooHelper < Helper
-        module Methods end
-
-        def on_hello(rw, node)
-          raise unless rw.is_a?(FooRewriter)
-          [:foo_hello, yield(rw, node)]
-        end
-
-      end
-
-      class FooRewriter < Rewriter
-        FooHelper.install_on(self)
-      end
-
-      describe "install_on" do
-
-        it 'installs the methods module on the rewriter' do
-          modules = FooRewriter.included_modules
-          modules.include?(FooHelper::Methods).should be_true
-        end
-
-        it 'adds an instance of the helper to the helpers list' do
-          helper = FooRewriter.helpers.last
-          helper.should be_a(FooHelper)
-        end
-
-        it 'does not polute the Rewriter class' do
-          Rewriter.helpers.size.should eq(1)
-        end
-
-      end # install_on
-
-      describe 'call' do
-
-        let(:helper)   { FooHelper.new   }
-        let(:rewriter) { FooRewriter.new }
-        let(:toplevel) {
-          Proc.new do |rw,node|
-            rw.should eq(rewriter)
-            [:toplevel, node]
-          end
-        }
-
-        it 'dispatches to the method when it exists' do
-          expected = \
-            [:foo_hello,
-              [:toplevel,
-                [:hello, "world"] ]]
-          got = helper.call(rewriter, [:hello, "world"], &toplevel)
-          got.should eq(expected)
-        end
-
-        it 'falls back to yielding when no method' do
-          expected = \
-            [:toplevel,
-              [:nosuchone] ]
-          got = helper.call(rewriter, [:nosuchone], &toplevel)
-          got.should eq(expected)
-        end
-
-        it 'calls next_in_chain when set' do
-          helper.next_in_chain = Class.new do
-            def call(rw, node)
-              raise unless rw.is_a?(FooRewriter)
-              yield rw, [:next, node]
-            end
-          end.new
-
-          expected = \
-            [:foo_hello,
-              [:toplevel,
-                [:next,
-                  [:hello, "world"] ]]]
-          got = helper.call(rewriter, [:hello, "world"], &toplevel)
-          got.should eq(expected)
-        end
-
-      end # call
-
-    end
-  end
-end

data/spec/unit/language/rewriter/test_scoping.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  class Rewriter
-    describe Scoping do
-
-      let(:rw_class) do
-        Class.new(Rewriter) do
-
-          def on_hello(node)
-            scope_stack.dup
-          end
-
-          def on_missing(node)
-            call(node.children.last)
-          end
-
-          Scoping.install_on self
-        end
-      end
-      let(:rw){ rw_class.new }
-
-      it 'installs the methods on the rewriter' do
-        rw.respond_to?(:scope_stack).should be_true
-      end
-
-      it 'does nothing special on non _def nodes' do
-        node = [:hello, "world"]
-        rw.call(node).should eq([])
-      end
-
-      it 'keeps _def nodes as successive scopes' do
-        second = [:task_def, [:hello]]
-        first  = [:task_def, second]
-        rw.call(first).should eq([first, second])
-      end
-
-      it 'pops scopes when returning along the stack' do
-        second = [:task_def, [:hello]]
-        first  = [:task_def, second]
-        rw.call(first)
-        rw.scope_stack.should eq([])
-      end
-
-    end
-  end
-end

data/spec/unit/language/rewriter/test_work_on_nodes.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  class Rewriter
-    describe WorkOnNodes do
-
-      let(:won){ WorkOnNodes.new }
-
-      it 'extends input nodes' do
-        node = [:hello, "world"]
-        seen = won.call(:rw, node) do |_,n|
-          n.should be_a(AST::Node)
-          n
-        end
-        seen.should eq(node)
-      end
-
-      it 'extends output nodes' do
-        node = [:hello, "world"]
-        seen = won.call(:rw, node) do |_,n|
-          n.should be_a(AST::Node)
-          [:result]
-        end
-        seen.should eq([:result])
-        seen.should be_a(AST::Node)
-      end
-
-      it 'does not require the output to be a node' do
-        node = [:hello, "world"]
-        seen = won.call(:rw, node) do |_,n|
-          n.should be_a(AST::Node)
-          "blah"
-        end
-        seen.should eq("blah")
-        seen.should_not be_a(AST::Node)
-      end
-
-      it 'fails unless the input looks a node' do
-        lambda{
-          won.call(:rw, "blah") do |_,n| end
-        }.should raise_error(ArgumentError, /blah/)
-      end
-
-    end
-  end
-end

data/spec/unit/language/test_ast.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe AST do
-
-    describe 'ast' do
-
-      it 'returns a node' do
-        node = [:unit_def].extend(AST::Node)
-        AST.node(node).object_id.should eq(node.object_id)
-      end
-
-      it 'coerces an array' do
-        AST.node([:unit_def]).should eq([:unit_def])
-        AST.node([:unit_def]).should be_a(AST::UnitDef)
-      end
-
-      it 'falls back to Node' do
-        AST.node([:nosuchnode]).should eq([:nosuchnode])
-        AST.node([:nosuchnode]).should be_a(AST::Node)
-      end
-
-      it 'applies coercions recursively' do
-        source = [:unit_def, [:hello, "world"]]
-        AST.node(source).should eq(source)
-        AST.node(source).last.should be_a(AST::Node)
-      end
-
-      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 # .ast
-
-  end
-end

data/spec/unit/language/test_rewriter.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Rewriter do
-
-    let(:rewriter_class){
-      Class.new(Rewriter) 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(:rewriter){ rewriter_class.new }
-
-    describe 'mainflow' do
-
-      it 'defaults to self' do
-        rewriter.mainflow.should eq(rewriter)
-      end
-
-      it 'may be passed through options' do
-        rw = rewriter_class.new(:mainflow => :hello)
-        rw.mainflow.should eq(:hello)
-      end
-
-    end # mainflow
-
-    describe 'call' do
-
-      it 'dispatches to existing methods' do
-        ast = [:hello, "world"]
-        rewriter.call(ast).should eq([:seen_hello, [:hello, "world"]])
-      end
-
-      it 'calls on_missing when not found' do
-        ast = [:nosuchone, "world"]
-        rewriter.call(ast).should eq([:seen_missing, [:nosuchone, "world"]])
-      end
-
-      it 'raises unexpected by default in on_missing' do
-        ast = [:nonono, "world"]
-        lambda{ rewriter.call(ast) }.should raise_error(Gisele::UnexpectedNodeError, /nonono/)
-      end
-
-      it 'performs post node transformation if required' do
-        ast = [:hello, "world"]
-        rewriter.call(ast).should be_a(AST::Node)
-      end
-
-      it 'raises an ArgumentError unless called on a non terminal' do
-        lambda{
-          rewriter.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'], "!"]
-        rewriter.call(ast).should eq([:copy, [:seen_hello, [:hello, "world"]], "!"])
-      end
-
-    end
-
-  end
-end

data/spec/unit/test_language.rb

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