sbyc 0.1.0

data/test/spec/unit/sbyc/codetree/eval/functional_compile.spec

@@ -0,0 +1,30 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#functional_compile" do
+  
+  context('when called on a leaf node') do
+    let(:node) { CodeTree::expr{ 12 } }
+    subject{ node.functional_compile }
+    it { should == "12" }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::expr{ x } }
+    subject{ node.functional_compile }
+    it { should == "scope[:x]" }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node)   { CodeTree::expr{ (say x, "Hello") } }
+    subject{ node.functional_compile }
+    it { should == 'receiver.say(scope[:x], "Hello")' }
+  end
+  
+  context('when called with specific arguments') do
+    let(:node)   { CodeTree::expr{ (say x, "Hello") } }
+    subject{ node.functional_compile('r', 'hash', 'get') }
+    it { should == 'r.say(hash.get(:x), "Hello")' }
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/eval/functional_eval.spec

@@ -0,0 +1,34 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#functional_eval" do
+  
+  context('when called on a leaf node') do
+    let(:node) { CodeTree::expr{ 12 } }
+    subject{ node.functional_eval(Kernel, { }) }
+    it { should == 12 }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::expr{ x } }
+    subject{ node.functional_eval(Kernel, :x => 12) }
+    it { should == 12 }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node)   { CodeTree::expr{ (say x, "You") } }
+    let(:master) { x = Object.new; def x.say(*args); args.join(" "); end; x}
+  
+    subject{ node.functional_eval(master, :x => "hello") }
+    
+    it { subject.should == "hello You" }
+  end
+  
+  context('when called on a object-like expression with specific scope method') do
+    let(:node)   { CodeTree::expr{ (say x, "You") } }
+    let(:master) { x = Object.new; def x.say(*args); args.join(" "); end; x}
+    subject{ node.functional_eval(master, {:x => "hello"}, :fetch) }
+    it { subject.should == "hello You" }
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/eval/functional_proc.spec

@@ -0,0 +1,36 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#functional_proc" do
+  
+  let(:receiver) {
+    o = Object.new
+    def o.upcase(x); x.upcase; end
+    o
+  }
+  
+  context('when called on a leaf node') do
+    let(:node) { CodeTree::expr{ 12 } }
+    subject{ node.functional_proc.call(nil, nil) }
+    it { should == 12 }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::expr{ x } }
+    subject{ node.functional_proc.call(receiver, :x => "hello") }
+    it { should == "hello" }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node)   { CodeTree::expr{ (upcase x) } }
+    subject{ node.functional_proc.call(receiver, :x => "hello") }
+    it { should == 'HELLO' }
+  end
+  
+  context('when called with specific arguments') do
+    let(:node)   { CodeTree::expr{ (upcase x) } }
+    subject{ node.functional_proc(:fetch).call(receiver, :x => "hello") }
+    it { should == 'HELLO' }
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/eval/object_compile.spec

@@ -0,0 +1,36 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#object_compile" do
+  
+  context('when called on a leaf node, through coercion') do
+    let(:node) { CodeTree::expr{ 12 } }
+    subject{ node.object_compile }
+    it { should == "12" }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::expr{ x } }
+    subject{ node.object_compile }
+    it { should == "scope[:x]" }
+  end
+  
+  context('when called on an expression') do
+    let(:node) { CodeTree::expr{ x + z } }
+    subject{ node.object_compile }
+    it { should == "scope[:x].+(scope[:z])" }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node) { CodeTree::expr{ x.say_hello } }
+    subject{ node.object_compile }
+    it { should == "scope[:x].say_hello()" }
+  end
+  
+  context('when called with specific arguments') do
+    let(:node) { CodeTree::expr{ x.say_hello } }
+    subject{ node.object_compile('hash', :get) }
+    it { should == "hash.get(:x).say_hello()"}
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/eval/object_eval.spec

@@ -0,0 +1,38 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#object_eval" do
+  
+  context('when called on a leaf node, through coercion') do
+    let(:node) { CodeTree::expr{ 12 } }
+    subject{ node.object_eval }
+    it { should == 12 }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::expr{ x } }
+    subject{ node.object_eval(:x => 12) }
+    it { should == 12 }
+  end
+  
+  context('when called on an expression') do
+    let(:node) { CodeTree::expr{ x + z } }
+    subject{ node.object_eval(:x => 12, :z => 15) }
+    it { should == 27 }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node) { CodeTree::expr{ x.say_hello } }
+    let(:twel) { x = Object.new; def x.say_hello(); "hello"; end; x}
+    subject{ node.object_eval(:x => twel) }
+    it { should == "hello" }
+  end
+  
+  context('when called on a object-like expression and specific scope method') do
+    let(:node) { CodeTree::expr{ x.say_hello } }
+    let(:twel) { x = Object.new; def x.say_hello(); "hello"; end; x}
+    subject{ node.object_eval({:x => twel}, :fetch) }
+    it { should == "hello" }
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/eval/object_proc.spec

@@ -0,0 +1,36 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#object_proc" do
+  
+  context('when called on a leaf node, through coercion') do
+    let(:node) { CodeTree::expr{ 12 } }
+    subject{ node.object_proc.call(nil) }
+    it { should == 12 }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::expr{ x } }
+    subject{ node.object_proc.call(:x => 12) }
+    it { should == 12 }
+  end
+  
+  context('when called on an expression') do
+    let(:node) { CodeTree::expr{ x + z } }
+    subject{ node.object_proc.call(:x => 12, :z => 15) }
+    it { should == 27 }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node) { CodeTree::expr{ x.upcase } }
+    subject{ node.object_proc.call(:x => "teller") }
+    it { should == "TELLER" }
+  end
+  
+  context('when called with specific arguments') do
+    let(:node) { CodeTree::expr{ x.upcase } }
+    subject{ node.object_proc(:fetch).call(:x => "teller") }
+    it { should == "TELLER"}
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/matching/matcher/args_match.spec

@@ -0,0 +1,91 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Matcher#args_match" do
+
+  let(:imatch) { CodeTree::Matcher.new nil }
+
+  context "when called with a capture match" do
+    let(:matcher)    { CodeTree::parse{ x }  }
+    let(:matched)    { CodeTree::parse{ 12 } }
+    let(:match_data) { { }                 }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify {
+      subject.should be_true
+      match_data[:x].should == matched
+    }
+  end
+
+  context "when called with a literal match" do
+    let(:matcher)    { CodeTree::parse{ 12 }  }
+    let(:matched)    { CodeTree::parse{ 12 } }
+    let(:match_data) { { }                 }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify { subject.should be_true }
+  end
+
+  context "when called with a literal no-match" do
+    let(:matcher)    { CodeTree::parse{ 13 }  }
+    let(:matched)    { CodeTree::parse{ 12 } }
+    let(:match_data) { { }                 }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify { subject.should be_false }
+  end
+  
+  context "when called with a recursive match" do
+    let(:matcher)    { CodeTree::parse{ (match :hello, x) } }
+    let(:matched)    { CodeTree::parse{ (hello "You")   } }
+    let(:match_data) { { }                             }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify { 
+      subject.should be_true 
+      match_data[:x].should == CodeTree::parse{ "You" }
+    }
+  end
+
+  context "when called with a recursive match with varargs and one arg" do
+    let(:matcher)    { CodeTree::parse{ (match :hello, x[]) } }
+    let(:matched)    { CodeTree::parse{ (hello "You")      } }
+    let(:match_data) { { }                                }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify { 
+      subject.should be_true 
+      match_data[:x].should == [ CodeTree::parse{ "You"} ]
+    }
+  end
+
+  context "when called with a recursive match with varargs and many args" do
+    let(:matcher)    { CodeTree::parse{ (match :hello, x[])            } }
+    let(:matched)    { CodeTree::parse{ (hello "You", "and", 'world') } }
+    let(:match_data) { { }                                           }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify { 
+      subject.should be_true 
+      match_data[:x].should == [ CodeTree::parse{ "You"}, CodeTree::parse{ "and"}, CodeTree::parse{ "world"} ]
+    }
+  end
+
+  context "when called with a recursive no-match with empty varargs" do
+    let(:matcher)    { CodeTree::parse{ (match :hello, x, y[]) } }
+    let(:matched)    { CodeTree::parse{ (hello "You")         } }
+    let(:match_data) { { }                                   }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify { subject.should be_false }
+  end
+
+  context "when called with a recursive no-match" do
+    let(:matcher)    { CodeTree::parse{ (match :hello, "world") } }
+    let(:matched)    { CodeTree::parse{ (hello 12)              } }
+    let(:match_data) { { }                             }
+    let(:subject) { imatch.args_match([ matcher ], [ matched ], match_data)}
+    
+    specify { subject.should be_false }
+  end
+
+end

data/test/spec/unit/sbyc/codetree/matching/matcher/do_match.spec

@@ -0,0 +1,39 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Matcher#match" do
+  
+  context 'When capture are provided' do
+    let(:matcher)    { CodeTree::parse{ (match :hello, (match :whos, x, y)) } } 
+    let(:matched)    { CodeTree::parse{ (hello (whos "world", "others"))    } }
+    let(:subject)    { CodeTree::Matcher.new(matcher) =~ matched       }
+    specify {
+      subject[:x].literal.should == "world"
+      subject[:y].literal.should == "others"
+    }
+  end
+  
+  context "When applying correct matches" do 
+    [ 
+      [CodeTree::parse{ (match :hello, "world") }, CodeTree::parse{ (hello "world") }],
+      [CodeTree::parse{ (match :hello, x)       }, CodeTree::parse{ (hello "world") }],
+      [CodeTree::parse{ (match :hello, x, y, z) }, CodeTree::parse{ (hello "world", "and", "others") }],
+      [CodeTree::parse{ (match :hello, (match :world, x)) }, CodeTree::parse{ (hello (world "I")) }],
+    ].each do |matcher, matched|
+      let(:subject){ CodeTree::Matcher.new(matcher) =~ matched }
+      it { should_not be_nil }
+    end
+  end
+  
+  context "When applying incorrect matches" do
+    [ 
+      [CodeTree::parse{ (match :hello, "world") }, CodeTree::parse{ (hello 12) }],
+      [CodeTree::parse{ (match :hello, "world") }, CodeTree::parse{ (hello "world", "and", "others") }],
+      [CodeTree::parse{ (match :hello, (match :world, x)) }, CodeTree::parse{ (hello "world") }],
+    ].each do |matcher, matched|
+      let(:subject){ CodeTree::Matcher.new(matcher) =~ matched }
+      it { should be_nil }
+    end
+  end
+  
+end
+

data/test/spec/unit/sbyc/codetree/matching/matcher/function_match.spec

@@ -0,0 +1,45 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Matcher#function_match" do
+
+  context "called with a literal match" do
+    let(:match)  { CodeTree::parse{ (match :hello)  } }
+    let(:victim) { CodeTree::parse{ (hello "world") } }
+    let(:match_data) { Hash.new }
+
+    subject{ ::CodeTree::Matcher.new(match).function_match(match, victim, match_data) }
+    
+    specify { 
+      subject.should == true 
+      match_data.should == {}
+    }
+  end
+
+  context "called with a capture match" do
+    let(:match)  { CodeTree::parse{ (match something)  } }
+    let(:victim) { CodeTree::parse{ (hello "world") } }
+    let(:match_data) { Hash.new }
+
+    subject{ ::CodeTree::Matcher.new(match).function_match(match, victim, match_data) }
+    
+    specify { 
+      subject.should == true
+      match_data.should == {:something => :hello} 
+    }
+  end
+
+  context "called without match" do
+    let(:match)  { CodeTree::parse{ (match :hello)  } }
+    let(:victim) { CodeTree::parse{ (i "world") } }
+    let(:match_data) { Hash.new }
+
+    subject{ ::CodeTree::Matcher.new(match).function_match(match, victim, match_data) }
+    
+    specify { 
+      subject.should == false 
+      match_data.should == {}
+    }
+  end
+
+end
+  

data/test/spec/unit/sbyc/codetree/matching/matcher/match.spec

@@ -0,0 +1,64 @@
+require File.expand_path('../../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::Matcher#match" do
+  
+  context "when called on something that matches" do
+    let(:matcher) { CodeTree::matcher{ (match :say, x) } }
+    let(:matched) { CodeTree::parse  { (say "hello")   } }
+    subject{ matcher =~ matched }
+    it { should_not be_nil }
+    specify{ subject[:x].should == CodeTree::parse{"hello"} }
+  end
+  
+  context "when called on something that does not match" do
+    let(:matcher) { CodeTree::matcher{ (match :say, x) } }
+    let(:matched) { CodeTree::parse  { (nosay "hello") } }
+    subject{ matcher =~ matched }
+    it { should be_nil }
+  end
+  
+  context "a generic matcher" do
+    let(:matcher) { CodeTree::matcher{ (match x, y[]) } }
+    
+    context 'against a ruby object' do
+      let(:expr) { 12               }
+      subject    { matcher =~ expr  }
+      it         { should be_nil    }
+    end
+    
+    context 'against a literal' do
+      let(:expr) { CodeTree::parse{ 12 } }
+      subject    { matcher =~ expr   }
+      it         { should_not be_nil }
+      specify    { subject[:x].should == :_ }
+      specify    { subject[:y].should == [12] }
+    end
+
+    context 'against a variable' do
+      let(:expr) { CodeTree::parse{ var } }
+      subject    { matcher =~ expr    }
+      it         { should_not be_nil  }
+      specify    { subject[:x].should == :'?'   }
+      specify    { subject[:y].should == [ CodeTree::parse{ :var }] }
+    end
+    
+    context 'against a function with one literal argument' do
+      let(:expr) { CodeTree::parse{ (func "a") } }
+      subject    { matcher =~ expr    }
+      it         { should_not be_nil  }
+      specify    { subject[:x].should == :func }
+      specify    { subject[:y].should == [ CodeTree::parse{ "a" } ] }
+    end
+    
+    context 'against a function with two arguments' do
+      let(:expr) { CodeTree::parse{ (func "a", b) } }
+      subject    { matcher =~ expr    }
+      it         { should_not be_nil  }
+      specify    { subject[:x].should == :func }
+      specify    { subject[:y].should == [ CodeTree::parse{ "a" }, CodeTree::parse{ b } ] }
+    end
+    
+  end
+  
+end
+