sbyc 0.1.0 → 0.1.1

data/test/spec/unit/sbyc/codetree/ast_node/code_inject.spec

@@ -0,0 +1,57 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#code_inject!" do
+  
+  module CodeTreeAstNodeCodeInject 
+    module Hello;       end 
+    module Capitalize;  end
+    module Varref;      end
+  end
+
+  let(:parsed) { CodeTree.parse{ (hello (capitalize name)) }.rename!(CodeTree::OPERATOR_NAMES) }
+
+  context "When called with a map" do
+    let(:map_arg) { {:varref     => CodeTreeAstNodeCodeInject::Varref, 
+                     :hello      => CodeTreeAstNodeCodeInject::Hello, 
+                     :capitalize => CodeTreeAstNodeCodeInject::Capitalize} }
+    subject{ parsed.code_inject!(map_arg) }
+    it { should == parsed }
+    it { should be_kind_of(CodeTreeAstNodeCodeInject::Hello) }
+    specify { 
+      subject.children[0].should be_kind_of(CodeTreeAstNodeCodeInject::Capitalize)
+      subject.children[0].children[0].should be_kind_of(CodeTreeAstNodeCodeInject::Varref)
+    }
+  end
+
+  context "When called with a proc" do
+    subject{ parsed.code_inject!{|name|
+      case name
+        when :varref
+          CodeTreeAstNodeCodeInject::Varref
+        when :hello
+          CodeTreeAstNodeCodeInject::Hello
+        when :capitalize
+          CodeTreeAstNodeCodeInject::Capitalize
+      end
+    } }
+    it { should == parsed }
+    it { should be_kind_of(CodeTreeAstNodeCodeInject::Hello) }
+    specify { 
+      subject.children[0].should be_kind_of(CodeTreeAstNodeCodeInject::Capitalize)
+      subject.children[0].children[0].should be_kind_of(CodeTreeAstNodeCodeInject::Varref)
+    }
+  end
+  
+  context "When called with a module" do
+    let(:map_arg){ CodeTreeAstNodeCodeInject }
+    subject{ parsed.code_inject!(map_arg) }
+    it { should == parsed }
+    it { should be_kind_of(CodeTreeAstNodeCodeInject::Hello) }
+    specify { 
+      subject.children[0].should be_kind_of(CodeTreeAstNodeCodeInject::Capitalize)
+      subject.children[0].children[0].should be_kind_of(CodeTreeAstNodeCodeInject::Varref)
+    }
+  end
+
+end
+  

data/test/spec/unit/sbyc/codetree/ast_node/digest.spec

@@ -0,0 +1,83 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#digest" do
+
+  module CodeTreeAstNodeDigestTest
+    class Dyadic 
+      attr_reader :left, :right
+      def initialize(left, right)
+        @left, @right = left, right
+      end
+    end
+    class And < Dyadic; end 
+    class Or < Dyadic; end 
+    class Complement 
+      attr_reader :term
+      def initialize(term)
+        @term = term
+      end
+    end
+    class Varref
+      attr_reader :varname
+      def initialize(varname)
+        @varname = varname
+      end
+    end
+  end
+  
+  context "when called with a hash" do
+    let(:parsed) { CodeTree.parse{ ~(a & (b | c)) } }
+    subject{ parsed.digest(:'?' => CodeTreeAstNodeDigestTest::Varref, 
+                           :&   => CodeTreeAstNodeDigestTest::And, 
+                           :|   => CodeTreeAstNodeDigestTest::Or, 
+                           :~   => CodeTreeAstNodeDigestTest::Complement) }
+    it { should be_kind_of(CodeTreeAstNodeDigestTest::Complement) }
+    specify { 
+      subject.term.should be_kind_of(CodeTreeAstNodeDigestTest::And)
+      subject.term.left.should be_kind_of(CodeTreeAstNodeDigestTest::Varref)
+      subject.term.left.varname.should == :a
+      subject.term.right.should be_kind_of(CodeTreeAstNodeDigestTest::Or)
+      subject.term.right.left.should be_kind_of(CodeTreeAstNodeDigestTest::Varref)
+    }
+  end
+
+  context "when called with a proc" do
+    let(:parsed) { CodeTree.parse{ ~(a & (b | c)) } }
+    subject{ parsed.digest{|name|
+      case name
+        when :'?'
+          CodeTreeAstNodeDigestTest::Varref
+        when :&
+          CodeTreeAstNodeDigestTest::And
+        when :|
+          CodeTreeAstNodeDigestTest::Or
+        when :~
+          CodeTreeAstNodeDigestTest::Complement
+      end
+    } }
+    it { should be_kind_of(CodeTreeAstNodeDigestTest::Complement) }
+    specify { 
+      subject.term.should be_kind_of(CodeTreeAstNodeDigestTest::And)
+      subject.term.left.should be_kind_of(CodeTreeAstNodeDigestTest::Varref)
+      subject.term.left.varname.should == :a
+      subject.term.right.should be_kind_of(CodeTreeAstNodeDigestTest::Or)
+      subject.term.right.left.should be_kind_of(CodeTreeAstNodeDigestTest::Varref)
+    }
+  end
+
+  context "when called with a module" do
+    let(:parsed) { CodeTree.parse{ ~(a & (b | c)) } }
+    let(:renamed) { parsed.rename!(CodeTree::OPERATOR_NAMES) }
+    subject{ renamed.digest(CodeTreeAstNodeDigestTest) }  
+    it { should be_kind_of(CodeTreeAstNodeDigestTest::Complement) }
+    specify { 
+      subject.term.should be_kind_of(CodeTreeAstNodeDigestTest::And)
+      subject.term.left.should be_kind_of(CodeTreeAstNodeDigestTest::Varref)
+      subject.term.left.varname.should == :a
+      subject.term.right.should be_kind_of(CodeTreeAstNodeDigestTest::Or)
+      subject.term.right.left.should be_kind_of(CodeTreeAstNodeDigestTest::Varref)
+    }
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/ast_node/rename.spec

@@ -0,0 +1,36 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#rename" do
+  
+  let(:expr){ CodeTree::parse{ ~(a & (b | c)) } }
+  
+  context "When called with CodeTree::OPERATOR_NAMES" do
+    subject{ expr.rename!(CodeTree::OPERATOR_NAMES) }
+    it { should == expr }
+    specify { subject.to_s.should == "(complement (and (varref :a), (or (varref :b), (varref :c))))" }
+  end
+  
+  context "When called with a hash" do
+    subject{ expr.rename!(:~ => :not, :& => :and, :| => :or, :'?' => :varref) }
+    it { should == expr }
+    specify { subject.to_s.should == "(not (and (varref :a), (or (varref :b), (varref :c))))" }
+  end
+  
+  context "When called with a proc" do
+    subject{ expr.rename!{|name|
+      case name
+        when :~
+          :not
+        when :&
+          :and
+        when :|
+          :or
+        when :'?'
+          :varref
+      end
+    }}
+    it { should == expr }
+    specify { subject.to_s.should == "(not (and (varref :a), (or (varref :b), (varref :c))))" }
+  end
+  
+end

data/test/spec/unit/sbyc/codetree/ast_node/to_s.spec

@@ -1,6 +1,6 @@
 require File.expand_path('../../../../../spec_helper', __FILE__)
 
-describe "CodeTree::AstNode#inspect" do
+describe "CodeTree::AstNode#to_s" do
   
   subject{ node.to_s }
 

data/test/spec/unit/sbyc/codetree/ast_node/visit.spec

@@ -1,6 +1,6 @@
 require File.expand_path('../../../../../spec_helper', __FILE__)
 
-describe "CodeTree::AstNode#functional_eval" do
+describe "CodeTree::AstNode#visit" do
   
   context('when called on a leaf node, through coercion') do
     let(:node) { CodeTree::AstNode.coerce(12) }
@@ -17,7 +17,7 @@ describe "CodeTree::AstNode#functional_eval" do
   context('when called for productions') do
     let(:node) { CodeTree::parse{ (say x, "Hello") } }
     subject { 
-      node.produce{|n, collected|
+      node.visit{|n, collected|
         case n.function
           when :'_'
             collected.first.inspect

data/test/spec/unit/sbyc/codetree/name2x/delegate/coerce.spec

@@ -0,0 +1,38 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::Delegate.coerce" do
+
+  subject{ CodeTree::Name2X::Delegate::coerce(arg) }
+ 
+  context "When called on a Delegate instance" do
+    let(:arg) { CodeTree::Name2X::Delegate.new({}) }
+    it { should be_kind_of(CodeTree::Name2X::Delegate) }
+  end
+
+  context "When called on a hash" do
+    let(:arg) { Hash.new }
+    it { should be_kind_of(CodeTree::Name2X::Delegate) }
+  end
+
+  context "When called on a proc" do
+    let(:arg) { Kernel.proc{|x| x} }
+    it { should be_kind_of(CodeTree::Name2X::Delegate) }
+  end
+
+  context "When called on a module" do
+    let(:arg) { CodeTree }
+    it { should be_kind_of(CodeTree::Name2X::Delegate) }
+  end
+
+  context "When called on an object responding to :[]" do
+    let(:arg) { o = Object.new; def o.[](name); end; o; }
+    it { should be_kind_of(CodeTree::Name2X::Delegate) }
+  end
+
+  context "When called on something else" do
+    let(:arg) { Object.new }
+    subject{ lambda{ CodeTree::Name2X::Delegate::coerce(arg) } }
+    it { should raise_error(ArgumentError) }
+  end
+  
+end

data/test/spec/unit/sbyc/codetree/name2x/delegate/fetch.spec

@@ -0,0 +1,15 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::Delegate#fetch" do
+
+  let(:hash){ {:to_name => :name, 
+               :to_module => CodeTree, 
+               :to_class => Class.new} }
+
+  let(:delegate){ CodeTree::Name2X::Delegate.new(hash) }
+
+  subject{ delegate.fetch(:to_module) }
+  
+  it { should == CodeTree }
+ 
+end

data/test/spec/unit/sbyc/codetree/name2x/delegate/name2class.spec

@@ -0,0 +1,31 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::Delegate#name2class" do
+
+  let(:hash){ {:to_name   => :name, 
+               :to_module => CodeTree, 
+               :to_class  => CodeTree::AstNode} }
+
+  let(:delegate){ CodeTree::Name2X::Delegate.new(hash) }
+
+  describe "when called with a target module" do
+    subject{ delegate.name2class(:to_module) }
+    it { should be_nil }
+  end
+ 
+  describe "when called with a target class" do
+    subject{ delegate.name2class(:to_class) }
+    it { should == CodeTree::AstNode }
+  end
+ 
+  describe "when called on something else" do
+    subject{ delegate.name2class(:to_name) }
+    it { should be_nil }
+  end
+ 
+  describe "when called on unexisting" do
+    subject{ delegate.name2class(:not_exists) }
+    it { should be_nil }
+  end
+ 
+end

data/test/spec/unit/sbyc/codetree/name2x/delegate/name2module.spec

@@ -0,0 +1,31 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::Delegate#name2module" do
+
+  let(:hash){ {:to_name   => :name, 
+               :to_module => CodeTree, 
+               :to_class  => CodeTree::AstNode} }
+
+  let(:delegate){ CodeTree::Name2X::Delegate.new(hash) }
+
+  describe "when called with a target module" do
+    subject{ delegate.name2module(:to_module) }
+    it { should == CodeTree }
+  end
+ 
+  describe "when called with a target module, through a class" do
+    subject{ delegate.name2module(:to_class) }
+    it { should == CodeTree::AstNode }
+  end
+ 
+  describe "when called on something else" do
+    subject{ delegate.name2module(:to_name) }
+    it { should be_nil }
+  end
+ 
+  describe "when called on unexisting" do
+    subject{ delegate.name2module(:not_exists) }
+    it { should be_nil }
+  end
+ 
+end

data/test/spec/unit/sbyc/codetree/name2x/delegate/name2name.spec

@@ -0,0 +1,31 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::Delegate#name2name" do
+
+  let(:hash){ {:to_name   => :name, 
+               :to_module => CodeTree, 
+               :to_class  => CodeTree::AstNode} }
+
+  let(:delegate){ CodeTree::Name2X::Delegate.new(hash) }
+
+  describe "when called with a target module" do
+    subject{ delegate.name2name(:to_module) }
+    it { should be_nil }
+  end
+ 
+  describe "when called with a target class" do
+    subject{ delegate.name2name(:to_class) }
+    it { should be_nil }
+  end
+ 
+  describe "when called with a target Symbol" do
+    subject{ delegate.name2name(:to_name) }
+    it { should == :name }
+  end
+ 
+  describe "when called on unexisting" do
+    subject{ delegate.name2name(:not_exists) }
+    it { should be_nil }
+  end
+ 
+end

data/test/spec/unit/sbyc/codetree/name2x/module_delegate/name2class.spec

@@ -0,0 +1,27 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::ModuleDelegate#name2class" do
+
+  let(:delegate){ CodeTree::Name2X::ModuleDelegate.new(CodeTree) }
+
+  describe "when called on some valid capitalized target" do
+    subject{ delegate.name2class(:AstNode) }
+    it { should == CodeTree::AstNode }
+  end
+ 
+  describe "when called on some valid non-capitalized target" do
+    subject{ delegate.name2class(:astNode) }
+    it { should == CodeTree::AstNode }
+  end
+ 
+  describe "when called on some valid non-capitalized target with underscores" do
+    subject{ delegate.name2class(:ast_node) }
+    it { should == CodeTree::AstNode }
+  end
+   
+  describe "when called with no such target" do
+    subject{ delegate.name2module(:nosuchone) }
+    it { should be_nil }
+  end
+
+end

data/test/spec/unit/sbyc/codetree/name2x/module_delegate/name2module.spec

@@ -0,0 +1,22 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::ModuleDelegate#name2module" do
+
+  let(:delegate){ CodeTree::Name2X::ModuleDelegate.new(CodeTree) }
+
+  describe "when called on some valid capitalized target" do
+    subject{ delegate.name2module(:Producing) }
+    it { should == CodeTree::Producing }
+  end
+ 
+  describe "when called on some valid non-capitalized target" do
+    subject{ delegate.name2module(:producing) }
+    it { should == CodeTree::Producing }
+  end
+ 
+  describe "when called with no such target" do
+    subject{ delegate.name2module(:nosuchone) }
+    it { should be_nil }
+  end
+ 
+end

data/test/spec/unit/sbyc/codetree/name2x/module_delegate/name2name.spec

@@ -0,0 +1,18 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Name2X::ModuleDelegate#name2name" do
+
+  let(:delegate){ CodeTree::Name2X::ModuleDelegate.new(CodeTree) }
+
+  [ [:Producing, :Producing],
+    [:producing, :Producing],
+    [:AstNode,   :AstNode],
+    [:astNode,   :AstNode],
+    [:ast_node,  :AstNode] ].each do |source, expected|
+    describe "when called on #{source}, should return #{expected}" do
+      subject{ delegate.name2name(source) }
+      it { should == expected }
+    end
+  end
+ 
+end

data/test/spec/unit/sbyc/codetree/parse.spec

@@ -0,0 +1,32 @@
+require File.expand_path('../../../../spec_helper', __FILE__)
+describe "CodeTree::parse" do
+  
+  let(:code)     { lambda { 
+    (puts (to_s x)) 
+    (say "hello")
+  } }
+  let(:expected){ ["(puts (to_s (? (_ :x))))", '(say (_ "hello"))'] }
+
+  context "when called with a multiline option and proc as first" do
+    subject { CodeTree::parse(code, :multiline => true) }
+    specify{
+      subject.collect{|s| s.inspect}.should == expected
+    }
+  end
+
+  context "when called with a multiline option and proc as block, with nil as first" do
+    subject { CodeTree::parse(nil, :multiline => true, &code) }
+    specify{
+      subject.collect{|s| s.inspect}.should == expected
+    }
+  end
+  
+  context "when called with a multiline option and proc as block, and nothing as first" do
+    subject { CodeTree::parse(:multiline => true, &code) }
+    specify{
+      subject.collect{|s| s.inspect}.should == expected
+    }
+  end
+  
+end
+