sbyc 0.1.0

data/test/spec/documentation/readme/functional_evaluation.spec

@@ -0,0 +1,29 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "README # object-evaluation section" do
+
+  let(:expr){ ::CodeTree::parse{ (display (concat x, y)) } }
+  
+  describe('what is said about the ast') do
+    subject{ expr.to_s }
+    it { should == "(display (concat x, y))" }
+  end
+  
+  describe("what is said about apply") do
+    let(:receiver) {
+      r = Object.new
+      r.instance_eval <<-EOF
+        def concat(*args)
+          args.join
+        end
+        def display(arg)
+          arg
+        end
+      EOF
+      r
+    }
+    subject{ expr.apply(receiver, :x => 3, :y => 25)  }
+    it { should == "325" }
+  end
+  
+end

data/test/spec/documentation/readme/object_evaluation.spec

@@ -0,0 +1,17 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "README # object-evaluation section" do
+
+  let(:expr){ CodeTree::parse{ (x + y).to_s } }
+  
+  describe('what is said about the ast') do
+    subject{ expr.to_s }
+    it { should == "(to_s (+ x, y))" }
+  end
+  
+  describe("what is said about eval") do
+    subject{ expr.eval(:x => 3, :y => 25)  }
+    it { should == "28" }
+  end
+  
+end

data/test/spec/documentation/readme/rewriting.spec

@@ -0,0 +1,60 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "README # rewriting section" do
+  
+  let(:code) { lambda{ (concat "hello ", who, (times "!", 3)) } }
+  let(:ast)  { CodeTree::parse(code) }
+  
+  describe('What is said about the ast') do
+    subject{ ast.inspect }
+    it { should == '(concat (_ "hello "), (? (_ :who)), (times (_ "!"), (_ 3)))' }
+  end
+
+  describe("What is said about the evaluation") do
+    let(:rewriter) { CodeTree::rewriter {|r|
+      r.rule(:concat)      {|r, node, *children|   r.apply(children).join("")                }  
+      r.rule(:capitalize)  {|r, node, who|         r.apply(who).capitalize                   }
+      r.rule(:times)       {|r, node, who, times|  r.apply(who) * r.apply(times)             }
+      r.rule(:'?')         {|r, node, what|        r.scope[r.apply(what)]                    }
+      r.rule(:'_')         {|r, node, literal|     literal                                   }
+    }}
+    
+    subject { rewriter.rewrite(ast, :who => "You") }
+    
+    it { should == "hello You!!!" }
+  end
+
+  describe("What is said about the code generation") do
+    let(:rewriter) { CodeTree::rewriter {|r|
+      r.rule(:concat)      {|r, node, *children|   r.apply(children).join(" + ")                }  
+      r.rule(:capitalize)  {|r, node, who|         "#{r.apply(who)}.capitalize()"               }
+      r.rule(:times)       {|r, node, who, times|  "(#{r.apply(who)} * #{r.apply(times)})"      }
+      r.rule(:'?')         {|r, node, what|        "scope[#{r.apply(what)}]"                    }
+      r.rule(:'_')         {|r, node, literal|     literal.inspect                              }
+    }}
+    
+    subject { rewriter.rewrite(ast) }
+    
+    it { should == '"hello " + scope[:who] + ("!" * 3)' }
+  end
+  
+  describe("What is said about the code tree rewriting") do
+    let(:rewriter) { CodeTree::rewriter {|r|
+      r.rule(:concat)  {|r, node, left, right, *residual| 
+        rewrited = r.node(:+, r.apply(left), r.apply(right))
+        if residual.empty? 
+          rewrited
+        else 
+          r.apply(r.node(:concat, [ rewrited ] + residual))
+        end
+      }
+      r.rule(:times)   {|r, node, *children|   r.node(:*, r.apply(children))                  }
+      r.rule(r.ANY)    {|r, node, *children|   r.node(node.function, children)                }
+    }}
+    
+    subject { rewriter.rewrite(ast).to_s }
+    
+    it { should == '(+ (+ "hello ", who), (* "!", 3))' }
+  end
+
+end

data/test/spec/documentation/readme/semantics.spec

@@ -0,0 +1,21 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "README # semantics section" do
+  
+  [
+    [ lambda { 12 }, "(_ 12)" ],
+    [ lambda { :x }, "(_ :x)" ],
+    [ lambda { x  }, "(? (_ :x))" ]
+  ].each do |expr, expected|
+    specify { CodeTree::parse(expr).inspect.should == expected }
+  end
+  
+  [
+    [ lambda { x + 12 }, :inspect, "(+ (? (_ :x)), (_ 12))" ],
+    [ lambda { x + 12 }, :to_s,    "(+ x, 12)" ],
+  ].each do |expr, meth, expected|
+    specify { CodeTree::parse(expr).send(meth).should == expected }
+  end
+  
+end
+  

data/test/spec/documentation/readme/synopsis.spec

@@ -0,0 +1,27 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "README # synopsis section" do
+  
+  let(:expr){ CodeTree::expr{ x > y } }
+  
+  specify {
+    expr.to_s.should == "(> x, y)"
+  }
+  
+  specify {
+    expr.inspect.should == "(> (? (_ :x)), (? (_ :y)))"
+  }
+  
+  specify {
+    expr.eval(:x => 5, :y => 2).should == true
+  }
+  
+  describe "what is said about marshalling" do
+    let(:marshaled)    { Marshal::dump(expr)      }
+    let(:unmarshaled)  { Marshal::load(marshaled) }
+    subject { unmarshaled }
+    it { should == expr }
+  end
+  
+end
+  

data/test/spec/documentation/readme/syntax.spec

@@ -0,0 +1,26 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "README # syntax section" do
+
+  describe "what is said about imperative styles" do
+    let(:expected) { "(& (> x, 5), (<= z, 10))" }
+
+    let(:hash_style)       { lambda{|t| (t[:x] > 5) & (t[:z] <= 10)                  } }
+    let(:object_style)     { lambda{|t| (t.x > 5) & (t.z <= 10)                      } }
+    let(:context_style)    { lambda{ (x > 5) & (z <= 10)                             } }
+    let(:tested)           { [hash_style, object_style, context_style] }
+    
+    subject{ tested.collect{|t| CodeTree::parse(t) } }
+    
+    specify{ subject.collect{|c| c.to_s}.uniq.should == [ expected ] }
+  end
+  
+  describe "what is said about functional style" do
+    let(:functional)    { lambda{ (both (gt x, 5), (lte y, 10)) } }
+    
+    subject { CodeTree::parse(functional) }
+    
+    specify{ subject.to_s.should == "(both (gt x, 5), (lte y, 10))" }
+  end
+  
+end

data/test/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.expand_path('../', __FILE__))
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rubygems'
+require 'sbyc'
+require 'spec'
+require 'spec/autorun'
+
+# require spec support files
+Dir[File.expand_path('../support/**/*.spec', __FILE__)].each { |f| require f }
+
+Spec::Runner.configure do |config|
+end

data/test/spec/test_all.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+test_files = Dir[File.join(File.dirname(__FILE__), '**/*.spec')]
+test_files.each { |file|
+  ::Kernel.load(file) 
+}
+

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

@@ -0,0 +1,60 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#coerce" do
+  
+  context("with a literal") do
+    subject { CodeTree::AstNode.coerce(12) }
+  
+    it { should be_kind_of(CodeTree::AstNode) }
+    
+    specify { 
+      subject.literal.should == 12 
+      subject.children.should == [ 12 ]
+      subject.to_s.should == "12"
+      subject.inspect.should == "(_ 12)"
+    }
+  end
+  
+  context("with a literal in array form") do
+    subject { CodeTree::AstNode.coerce([:_, [ 12 ]]) }
+    it { should be_kind_of(CodeTree::AstNode) }
+    specify { subject.inspect.should == "(_ 12)" }
+  end
+  
+  context("without children") do
+    subject { CodeTree::AstNode.coerce([:plus, []]) }
+  
+    it { should be_kind_of(CodeTree::AstNode) }
+  
+    specify { 
+      subject.name.should == :plus 
+      subject.children.should be_empty
+    }
+  end
+  
+  context("with literal children") do
+    subject { CodeTree::AstNode.coerce([ :plus, [ 12, 15 ] ]) }
+  
+    it { should be_kind_of(CodeTree::AstNode) }
+  
+    specify { 
+      subject.name.should == :plus 
+      subject.children.collect{|a| a.literal}.should == [ 12, 15 ]
+    }
+  end
+  
+  context("with complex structure") do
+    subject { CodeTree::AstNode.coerce([ :plus, [ [ :minus, [12, 15] ] ] ]) }
+  
+    it { should be_kind_of(CodeTree::AstNode) }
+    
+    specify {
+      subject.name.should == :plus
+      subject.children.size.should == 1
+      subject.children[0].name.should == :minus
+      subject.children[0].children.should be_kind_of(Array)
+      subject.children[0].children.collect{|a| a.literal}.should == [12, 15]
+    }
+  end
+  
+end 

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

@@ -0,0 +1,75 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#==" do
+  
+  context "when applied on equal literal nodes" do
+    let(:n1) { CodeTree::parse{ 12 } }
+    let(:n2) { CodeTree::parse{ 12 } }
+    subject { (n1 == n2) and (n2 == n1) }
+    it { should be_true }
+  end
+
+  context "when applied on itself with a literal node" do
+    let(:n1) { CodeTree::parse{ 12 } }
+    let(:n2) { n1 }
+    subject { (n1 == n2) and (n2 == n1) }
+    it { should be_true }
+  end
+  
+  context "when applied on non equal literal nodes" do
+    let(:n1) { CodeTree::parse{ 12 } }
+    let(:n2) { CodeTree::parse{ 13 } }
+    subject { (n1 == n2) or (n2 == n1) }
+    it { should be_false }
+  end
+
+  context "when applied on itself with a tree" do
+    let(:n1) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    let(:n2) { n1 }
+    subject { (n1 == n2) and (n2 == n1) }
+    it { should be_true }
+  end
+  
+  context "when applied on equal trees" do
+    let(:n1) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    let(:n2) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    subject { (n1 == n2) and (n2 == n1) }
+    it { should be_true }
+  end
+  
+  context "when applied on non equal trees (with one being a literal)" do
+    let(:n1) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    let(:n2) { 12 }
+    subject { (n1 == n2) or (n2 == n1) }
+    it { should be_false }
+  end
+  
+  context "when applied on non equal trees (none being a literal)" do
+    let(:n1) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    let(:n2) { CodeTree::parse{ (concat "hello", "world") } }
+    subject { (n1 == n2) or (n2 == n1) }
+    it { should be_false }
+  end
+  
+  context "when applied on non equal trees (with a literal difference)" do
+    let(:n1) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    let(:n2) { CodeTree::parse{ (concat (say "hello"), "world2") } }
+    subject { (n1 == n2) or (n2 == n1) }
+    it { should be_false }
+  end
+  
+  context "when applied on non equal trees (with a function difference)" do
+    let(:n1) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    let(:n2) { CodeTree::parse{ (concat (say2 "hello"), "world") } }
+    subject { (n1 == n2) or (n2 == n1) }
+    it { should be_false }
+  end
+  
+  context "when applied on non equal trees (order difference)" do
+    let(:n1) { CodeTree::parse{ (concat (say "hello"), "world") } }
+    let(:n2) { CodeTree::parse{ (concat "world", (say "hello")) } }
+    subject { (n1 == n2) or (n2 == n1) }
+    it { should be_false }
+  end
+  
+end

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

@@ -0,0 +1,23 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#inspect" do
+  
+  subject{ node.inspect }
+
+  context('when called on a leaf node, through coercion') do
+    let(:node) { CodeTree::AstNode.coerce(12) }
+    it { should == "(_ 12)" }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::AstNode.coerce([:'?', [:x]]) }
+    it { should == "(? (_ :x))" }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node)   { CodeTree::parse{ (say x, "Hello") } }
+    it { subject.should == '(say (? (_ :x)), (_ "Hello"))' }
+  end
+  
+end
+  

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

@@ -0,0 +1,15 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#literal" do
+  
+  context "when called on a leaf node" do
+    subject{ CodeTree::parse{ 12 }.literal }
+    it { should == 12 }
+  end
+  
+  context "when called on a branch node" do
+    subject{ CodeTree::parse{ ~(~(12)) }.literal }
+    it { should == 12 }
+  end
+  
+end

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

@@ -0,0 +1,27 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#to_a" do
+  
+  context("with a _") do
+    subject { CodeTree::AstNode.coerce(12).to_a }
+    it { should == [:_, [ 12 ]] }
+  end
+  
+  context("without children") do
+    subject { CodeTree::AstNode.coerce([ :plus, [ ] ]).to_a }
+    it { should == [ :plus, [ ] ] }
+  end
+  
+  context("with _ children") do
+    let(:expected) { [ :plus, [ [:_, [12]], [:_, [15]] ] ] }
+    subject { CodeTree::parse{ (plus 12, 15) }.to_a }
+    it { should == expected }
+  end
+  
+  context("with variables") do
+    let(:expected) { [ :plus, [ [:'?', [ [:_, [ :x ] ] ] ] ] ] }
+    subject { CodeTree::parse{ (plus x) }.to_a }
+    it { should == expected }
+  end
+  
+end 

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

@@ -0,0 +1,23 @@
+require File.expand_path('../../../../../spec_helper', __FILE__)
+
+describe "CodeTree::AstNode#inspect" do
+  
+  subject{ node.to_s }
+
+  context('when called on a leaf node, through coercion') do
+    let(:node) { CodeTree::AstNode.coerce(12) }
+    it { should == "12" }
+  end
+  
+  context('when called on a ?') do
+    let(:node) { CodeTree::AstNode.coerce([:'?', [:x]]) }
+    it { should == "x" }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node)   { CodeTree::parse{ (say x, "Hello") } }
+    it { subject.should == '(say x, "Hello")' }
+  end
+  
+end
+  

data/test/spec/unit/sbyc/codetree/ast_node/visit.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, through coercion') do
+    let(:node) { CodeTree::AstNode.coerce(12) }
+    subject{ node.visit{|node, collected| [node, collected]} }
+    it { should == [node, [12]] }
+  end
+  
+  context('when called on a object-like expression') do
+    let(:node)   { CodeTree::parse{ (say x, "Hello") } }
+    subject{ node.visit{|node, collected| [node.name, collected]} }
+    it { subject.should == [:say, [ [ :'?', [ [ :_,  [ :x ] ] ] ], [ :_, [ "Hello" ] ] ] ] }
+  end
+  
+  context('when called for productions') do
+    let(:node) { CodeTree::parse{ (say x, "Hello") } }
+    subject { 
+      node.produce{|n, collected|
+        case n.function
+          when :'_'
+            collected.first.inspect
+          when :'?'
+            "scope[#{collected.join(', ')}]"
+          else
+            "#{collected.shift}.#{n.function}(#{collected.join(', ')})"
+        end
+      }
+    }
+    it { should == 'scope[:x].say("Hello")' }
+  end
+  
+end