sbyc 0.1.0

data/test/spec/unit/sbyc/codetree/proc_parser/expr.spec

@@ -0,0 +1,20 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::ProcParser::Expr" do
+
+  let(:the_expr) { CodeTree::ProcParser::Expr.new }
+
+  describe("should not have access to Kernel methods") do
+    specify{ 
+      x = the_expr.instance_eval{ puts "hello" } 
+      lambda{ x.__to_functional_code }.should_not raise_error
+      x.__to_functional_code.should be_kind_of(CodeTree::AstNode)
+    }
+  end
+  
+  describe "should not have a to_s method" do
+    subject { the_expr.to_s.__to_functional_code }
+    it { should be_kind_of(CodeTree::AstNode) }
+  end
+  
+end

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

@@ -0,0 +1,83 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::ProcParser#parse" do
+  
+  subject { CodeTree::ProcParser::parse(code) }
+
+  context "when called with an argument" do 
+    let(:expected)   { "(+ (? (_ :a)), (_ 12))" }
+  
+    context("with a simple literal") do
+      let(:code)  { proc {|t| 12 } }
+      specify     { subject.should be_kind_of(CodeTree::AstNode) }
+      specify     { subject.inspect.should == CodeTree::parse{ 12 }.inspect }
+    end
+  
+    context("with a simple operator call") do
+      let(:code)  { proc {|t| t[:a] + 12 }             }
+      specify     { subject.inspect.should == expected }
+    end
+      
+    context("with a simple operator call and dot heuristic") do
+      let(:code)        { proc {|t| t.a + 12 } }
+      specify { subject.inspect.should == expected }
+    end
+      
+    context("with left literal at left") do
+      let(:code)        { proc {|t| 12 + t[:a]       } }
+      specify { subject.inspect.should == expected }
+    end
+      
+    context("with left literal at left and dot heuristic") do
+      let(:code)        { proc {|t| 12 + t.a       } }
+      specify { subject.inspect.should == expected }
+    end
+  end
+  
+  context "when called without argument" do
+    let(:expected)   { "(+ (? (_ :a)), (_ 12))" }
+  
+    context("with a simple literal") do
+      let(:code)        { proc { 12 } }
+      specify     { subject.should be_kind_of(CodeTree::AstNode) }
+      specify { subject.inspect.should == CodeTree::parse{ 12 }.inspect }
+    end
+  
+    context("with a simple operator call") do
+      let(:code)        { proc { a + 12 } }
+      specify { subject.inspect.should == expected }
+    end
+  
+    context("with left literal at left") do
+      let(:code)        { proc { 12 + a } }
+      specify { subject.inspect.should == expected }
+    end
+  end
+   
+  context "when called and used with method calls" do
+    let(:expected)   { "(plus (? (_ :a)), (_ 12))" }
+   
+    context("with a simple method call") do
+      let(:code)        { proc {|t| t[:a].plus(12)   } }
+      specify { subject.inspect.should == expected }
+    end
+      
+    context("with a simple method call and dot heuristic") do
+      let(:code)        { proc {|t| t.a.plus(12)   } }
+      specify { subject.inspect.should == expected }
+    end
+  end
+  
+  context "when call on expressions that refer to ruby Kernel methods" do
+    let(:expected) { "(puts (to_s (? (_ :x))))"}
+    let(:code)     { lambda { (puts (to_s x)) } }
+    specify{ subject.inspect.should == expected }
+  end
+  
+  context "when call on expressions that refer to typical inherited methods/operators" do
+    let(:expected) { "(== (hash (? (_ :x))), (_ 12))"}
+    let(:code)     { lambda { x.hash == 12 } }
+    specify{ subject.inspect.should == expected }
+  end
+  
+end

data/test/spec/unit/sbyc/codetree/producing/producer.spec

@@ -0,0 +1,31 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Producing::Producer" do
+  
+  let(:expr){ CodeTree::parse{ ~(a & b) } }
+  
+  context 'when called with default rules' do
+    let(:producer) { 
+      CodeTree::producer{|p|
+        p.rule(:~){|r, n| "not(#{r.apply(n[0])})"                  }
+        p.rule(:&){|r, n| "(#{r.apply(n.children).join(' and ')})" }
+        p.rule(:|){|r, n| "(#{r.apply(n.children).join(' or ')})"  }
+      }
+    }
+    subject{ producer.apply(expr) }
+    it{ should == "not((a and b))" }
+  end
+  
+  context 'when called without default rules' do
+    let(:producer) { 
+      CodeTree::producer(false){|p|
+        p.rule("*"){|r,n| [n.function] + r.apply(n.children)}
+      }
+    }
+    subject{ producer.apply(expr) }
+    specify{ producer.rules.size.should == 1 }
+    it{ should == [:~, [:&, [:'?', [:_, :a]], [:'?', [:_, :b]]]] }
+  end
+  
+end
+

data/test/spec/unit/sbyc/codetree/producing/producer/apply_args_conventions.spec

@@ -0,0 +1,60 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Producing::Producer#apply_args_conventions" do
+
+  let(:producer) { ::CodeTree::producer }
+
+  context "when called with a literal" do
+    let(:node)     { 12 }
+    subject { producer.send(:apply_args_conventions,node) }
+    it { should == node }
+  end
+
+  context "when called with a single ASTNode instance" do
+    let(:node)     { ::CodeTree::parse{ 12 }  }
+    subject { producer.send(:apply_args_conventions,node) }
+    it { should == node }
+  end
+
+  context "when called with multiple ASTNode instances" do
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "world" }                          }
+    subject        { producer.send(:apply_args_conventions,child1, child2)   }
+    it { should == [child1, child2] }
+  end
+
+  context "when called with an array of ASTNode instances" do
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "world" }                          }
+    subject        { producer.send(:apply_args_conventions,[child1, child2]) }
+    it { should == [child1, child2] }
+  end
+
+  context "when called with a function and a single ASTNode child" do
+    let(:function) { :testfunc                      }
+    let(:child)    { ::CodeTree::parse{ 12 }            }
+    let(:expected) { ::CodeTree::parse{ (testfunc 12) } }
+    subject{ producer.send(:apply_args_conventions,function, child) }
+    it { should == expected }
+  end 
+  
+  context "when called with a function and two ASTNode children" do
+    let(:function) { :say                                              }
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "world" }                          }
+    let(:expected) { ::CodeTree::parse{ (say "hello", "world") }           }
+    subject{ producer.send(:apply_args_conventions,function, child1, child2) }
+    it { should == expected }
+  end 
+  
+  context "when called with a function and mix of ASTNode children" do
+    let(:function) { :say                                              }
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "you" }                            }
+    let(:child3)   { ::CodeTree::parse{ "world" }                          }
+    let(:expected) { ::CodeTree::parse{ (say "hello", "you", "world") }    }
+    subject{ producer.send(:apply_args_conventions,function, child1, [child2, child3]) }
+    it { should == expected }
+  end 
+  
+end

data/test/spec/unit/sbyc/codetree/rewriting/instance_methods/apply_args_conventions.spec

@@ -0,0 +1,60 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Rewriting::Rewriter#apply_args_conventions" do
+
+  let(:rewriter) { ::CodeTree::rewriter }
+
+  context "when called with a literal" do
+    let(:node)     { 12 }
+    subject { rewriter.apply_args_conventions(node) }
+    it { should == node }
+  end
+
+  context "when called with a single ASTNode instance" do
+    let(:node)     { ::CodeTree::parse{ 12 }  }
+    subject { rewriter.apply_args_conventions(node) }
+    it { should == node }
+  end
+
+  context "when called with multiple ASTNode instances" do
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "world" }                          }
+    subject        { rewriter.apply_args_conventions(child1, child2)   }
+    it { should == [child1, child2] }
+  end
+
+  context "when called with an array of ASTNode instances" do
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "world" }                          }
+    subject        { rewriter.apply_args_conventions([child1, child2]) }
+    it { should == [child1, child2] }
+  end
+
+  context "when called with a function and a single ASTNode child" do
+    let(:function) { :testfunc                      }
+    let(:child)    { ::CodeTree::parse{ 12 }            }
+    let(:expected) { ::CodeTree::parse{ (testfunc 12) } }
+    subject{ rewriter.apply_args_conventions(function, child) }
+    it { should == expected }
+  end 
+  
+  context "when called with a function and two ASTNode children" do
+    let(:function) { :say                                              }
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "world" }                          }
+    let(:expected) { ::CodeTree::parse{ (say "hello", "world") }           }
+    subject{ rewriter.apply_args_conventions(function, child1, child2) }
+    it { should == expected }
+  end 
+  
+  context "when called with a function and mix of ASTNode children" do
+    let(:function) { :say                                              }
+    let(:child1)   { ::CodeTree::parse{ "hello" }                          }
+    let(:child2)   { ::CodeTree::parse{ "you" }                            }
+    let(:child3)   { ::CodeTree::parse{ "world" }                          }
+    let(:expected) { ::CodeTree::parse{ (say "hello", "you", "world") }    }
+    subject{ rewriter.apply_args_conventions(function, child1, [child2, child3]) }
+    it { should == expected }
+  end 
+  
+end

data/test/spec/unit/sbyc/codetree/rewriting/instance_methods/node.spec

@@ -0,0 +1,19 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Rewriting::Rewriter#copy" do
+  
+  let(:engine) { CodeTree::rewriter }
+  
+  context "when called with a literal" do 
+    subject{ engine.node(:test, [ 12 ]) }
+    it { should == CodeTree::parse{ (test 12) } }
+  end
+  
+  context "when called with copy in mind" do
+    let(:node) { CodeTree::parse{ 12 } } 
+    subject{ engine.node(node.function, node.children) }
+    it { should == CodeTree::parse{ 12 } }
+  end
+  
+end
+

data/test/spec/unit/sbyc/codetree/rewriting/instance_methods/rewrite.spec

@@ -0,0 +1,76 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Rewriting::Rewriter" do
+
+  describe "when called without scope" do 
+    subject{
+      CodeTree::rewriter {|r|
+        r.rule(:concat)        {|r, node, *args| args.collect{|c| r.apply(c)}.join }
+        r.rule(:_)             {|r, node| node.literal                             }
+      }
+    }
+  
+    it { should be_kind_of(CodeTree::Rewriting::Rewriter) }
+  
+    context("when applied on an ast string") do
+      specify { subject.rewrite("(concat 1, 2, 3)").should == "123" }
+    end
+  
+    context("when applied with a proc argument") do
+      let(:code){ lambda{ (concat 1, 2, 3) } }
+      specify { subject.rewrite(code).should == "123" }
+    end
+  
+    context("when applied with a block") do
+      specify { subject.rewrite{ (concat 1, 2, 3) }.should == "123" }
+    end
+    
+  end
+
+  describe "when called with a scope object" do 
+    subject{
+      CodeTree::rewriter     {|r|
+        r.rule(:concat)        {|r, node, *args| args.collect{|c| r.apply(c)}.join }
+        r.rule(:get)           {|r, node, name|  r.scope[r.apply(name)]            }
+        r.rule(:_)             {|r, node| node.literal                             }
+      }
+    }
+  
+    it { should be_kind_of(CodeTree::Rewriting::Rewriter) }
+  
+    context("when applied on an ast string") do
+      specify { subject.rewrite("(get :hello)", :hello => "world").should == "world" }
+    end
+      
+    context("when applied with a proc argument") do
+      let(:code){ lambda{ (get :hello) } }
+      specify { subject.rewrite(code, :hello => "world").should == "world" }
+    end
+      
+    context("when applied with a block") do
+      specify { subject.rewrite(:hello => "world"){ (get :hello) }.should == "world" }
+    end
+  end
+  
+  describe "when only an ANY match is installed" do
+    subject{ CodeTree::rewriter{|r| 
+      r.rule(CodeTree::Rewriting::Rewriter::Match::ANY){|r, node, arg| node.leaf? ? arg : r.apply(arg) } 
+    }}
+    
+    it "should return inner-most argument" do
+      subject.rewrite{ (call (other (one :hello))) }.should == :hello
+    end
+  end
+  
+  describe "when only an LEAF/BRANCH are used" do
+    subject{ CodeTree::rewriter{|r| 
+      r.rule(CodeTree::Rewriting::Rewriter::Match::BRANCH){|r, node, child| r.apply(child)}
+      r.rule(CodeTree::Rewriting::Rewriter::Match::LEAF){|r, node| node.literal}
+    }}
+    
+    it "should return inner-most argument" do
+      subject.rewrite{ (call (other (one :hello))) }.should == :hello
+    end
+  end
+  
+end

data/test/spec/unit/sbyc/codetree/rewriting/match/apply.spec

@@ -0,0 +1,23 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Rewriting::Rewriter::Match#apply" do
+  
+  let(:predicate) { true }
+  let(:block)     { lambda{ |r, node, *args| [r, node, args] } }
+  subject { CodeTree::Rewriting::Rewriter::Match.new(predicate, block) }
+  
+  context "when called on a leaf node" do
+    let(:node) { CodeTree::AstNode.coerce(:literal) }
+    specify { 
+      subject.apply("rewriter", node).should == ["rewriter", node, [ :literal ]]
+    }
+  end
+  
+  context "when called on a branch node" do
+    let(:node) { CodeTree::AstNode.new(:branch, [1, 2, 3]) }
+    specify { 
+      subject.apply("rewriter", node).should == ["rewriter", node, [1, 2, 3]]
+    }
+  end
+  
+end

data/test/spec/unit/sbyc/codetree/rewriting/match/coerce.spec

@@ -0,0 +1,48 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Rewriting::Rewriter::Match.coerce?" do
+  
+  let(:branch) { CodeTree::parse{ (branch :hello) } }
+  let(:leaf)   { CodeTree::parse{ :hello }          }
+  
+  context("when called with a symbol") do
+    subject{ CodeTree::Rewriting::Rewriter::Match.coerce(:branch, nil) }
+    
+    it { should === branch }
+    it { should_not === leaf }
+  end
+  
+  context("when called with a proc") do
+    let(:predicate) { lambda{|node| node.leaf? }}
+    subject{ CodeTree::Rewriting::Rewriter::Match.coerce(predicate, nil) }
+    
+    it { should_not === branch }
+    it { should === leaf }
+  end
+  
+  context("when called with '.'") do
+    subject{ CodeTree::Rewriting::Rewriter::Match.coerce(".", nil) }
+    
+    it { should === 12 }
+    it { should === branch }
+    it { should === leaf }
+  end
+  
+  context("when called with '*'") do
+    subject{ CodeTree::Rewriting::Rewriter::Match.coerce("*", nil) }
+    
+    it { should_not === 12 }
+    it { should === branch }
+    it { should_not === leaf }
+  end
+  
+  context("when called with '@*'") do
+    subject{ CodeTree::Rewriting::Rewriter::Match.coerce("@*", nil) }
+    
+    it { should_not === 12 }
+    it { should_not === branch }
+    it { should === leaf }
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/rewriting/match/matches.spec

@@ -0,0 +1,27 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Rewriting::Rewriter::Match#matches?" do
+  
+  let(:branch)  { CodeTree::AstNode.new(:branch, [1, 2, 3]) }
+  let(:literal) { CodeTree::AstNode.coerce(12) }
+  
+  context "when built with a symbol" do
+    subject { CodeTree::Rewriting::Rewriter::Match.coerce(:_, nil) }
+    specify { 
+      (subject.matches? branch).should be_false
+      (subject.matches? literal).should be_true
+      (subject === branch).should be_false
+      (subject === literal).should be_true
+    }
+  end
+  
+  context "when built with a proc" do
+    let(:proc) { lambda {|node| node.name == :branch } }
+    subject { CodeTree::Rewriting::Rewriter::Match.coerce(proc, nil) }
+    specify { 
+      (subject.matches? branch).should be_true
+      (subject.matches? literal).should be_false
+    }
+  end
+  
+end