wood 0.1.1

data/spec/spec_cov.rb

@@ -0,0 +1,2 @@
+require "simplecov"
+SimpleCov.start

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require_relative "../lib/wood"
+
+include Wood

data/spec/wood/indented_printer_spec.rb

@@ -0,0 +1,61 @@
+class MyIndentedPrinter
+  include Wood::IndentedPrinter
+  attr_accessor :io, :indentation
+  def initialize(indentation = 2)
+    @io = StringIO.new
+    @indentation = indentation
+  end
+
+  def output
+    @io.string
+  end
+end
+
+describe Wood::IndentedPrinter do
+  before :each do
+    @p = MyIndentedPrinter.new
+  end
+
+  it "starts out with indentation = 0" do
+    @p.print "Hello"
+    @p.output.should == "Hello"
+  end
+
+  it "indents by the given amount" do
+    @p.print "Hello"
+    @p.with_indentation {
+      @p.print "World"
+    }
+    @p.output.should == "Hello\n  World\n"
+  end
+
+  it "indents by a specific indentation" do
+    @p.indentation = 5
+    @p.print "Hello"
+    @p.with_indentation {
+      @p.print "yo"
+      @p.newline
+      @p.print "done"
+    }
+    @p.output.should == "Hello\n     yo\n     done\n"
+  end
+
+  it "indents and unindents the output explicitly" do
+    @p.print "ok"
+    @p.indent
+    @p.newline
+    @p.print "what"
+    @p.unindent
+    @p.newline
+    @p.print "done"
+
+    @p.output.should == "ok\n  what\ndone"
+  end
+
+  it "prints followed by a newline" do
+    @p.println "start"
+    @p.println "done"
+
+    @p.output.should == "start\ndone\n"
+  end
+end

data/spec/wood/node_spec.rb

@@ -0,0 +1,258 @@
+class MyNode < Node
+  child_nodes :a, :b, :c
+end
+
+include Wood::Nodes
+
+describe Node do
+  it "has no default child nodes" do
+    Node.__child_nodes__.should == []
+  end
+
+  it "includes the ClassMethods on subclasses" do
+    MyNode.__child_nodes__.should == [:a, :b, :c]
+    MyNode.node_name.should == :my_node
+  end
+
+  it "returns the correct node_name" do
+    module MyModule
+      class MyNode < Node
+      end
+    end
+
+    MyNode.node_name.should == :my_node
+    MyModule::MyNode.node_name.should == :my_module_my_node
+  end
+
+  it "provides a default sexp implementation" do
+    class EmptyNode < Node
+    end
+
+    class ValueNode < Node
+      child_nodes :value
+      def sexp
+        [:value_node, value]
+      end
+    end
+
+    e = EmptyNode.new
+    n = MyNode.new a: e, b: e, c: e
+    n.sexp.should == [:my_node, [:empty_node], [:empty_node], [:empty_node]]
+
+    n = MyNode.new a: e, b: ValueNode.new(value: "foo"), c: e
+    n.sexp.should == [
+      :my_node, [:empty_node], [:value_node, "foo"], [:empty_node]
+    ]
+  end
+
+  it "compares nodes correctly for equality" do
+    n1 = MyNode.new a: EmptyNode.new, b: MyNode.new, c: EmptyNode.new
+    n2 = MyNode.new a: EmptyNode.new, b: MyNode.new, c: EmptyNode.new
+    n3 = MyNode.new a: MyNode.new, b: EmptyNode.new, c: EmptyNode.new
+
+    n1.should == n1
+    n2.should == n2
+    n3.should == n3
+
+    n1.should == n2
+    n2.should == n1
+
+    n1.should_not == n3
+    n2.should_not == n3
+
+    n3.should_not == n1
+    n3.should_not == n2
+  end
+
+  it "compares nodes correctly for matching" do
+    any = Wood::TreePattern::AnyMatcher.new
+    IntLiteral[10].should === IntLiteral[10]
+    IntLiteral[10].should === IntLiteral[any]
+    IntLiteral[any].should === IntLiteral[10]
+
+    Operator[
+      name: :*,
+      left: any,
+      right: any
+    ].should === Operator[
+      name: :*,
+      left: IntLiteral[-10],
+      right: IntLiteral[10]
+    ]
+
+    Operator[name: :*].should === Operator[
+      name: :*,
+      left: IntLiteral[10],
+      right: IntLiteral[10]
+    ]
+
+    Operator[
+      name: :*,
+      left: IntLiteral[10],
+      right: IntLiteral[10]
+    ].should_not === Operator[name: :*]
+  end
+
+  it "supports node construction via Node##[]" do
+    a = MyNode[a: EmptyNode[], b: MyNode[], c: EmptyNode[]]
+    b = MyNode.new a: EmptyNode.new, b: MyNode.new, c: EmptyNode.new
+
+    a.should == b
+  end
+
+  it "returns its child nodes" do
+    node = MyNode[
+      a: StringLiteral["foo"],
+      b: IntLiteral[10],
+      c: TrueLiteral.new
+    ]
+
+    node.child_nodes.should == [
+      StringLiteral["foo"],
+      IntLiteral[10],
+      TrueLiteral.new
+    ]
+
+    MyNode.new.child_nodes.should == [nil, nil, nil]
+  end
+
+  it "returns the names of its child nodes" do
+    MyNode.new.child_node_names.should == [:a, :b, :c]
+
+    class EmptyNode < Node
+    end
+    EmptyNode.new.child_node_names.should be_empty
+  end
+
+  it "sets a child value" do
+    n = MyNode[
+      a: nil,
+      b: IntLiteral[10],
+      c: StringLiteral["foo"]
+    ]
+    n.set_child(:a, IntLiteral[42])
+    n.should == MyNode[
+      a: IntLiteral[42],
+      b: IntLiteral[10],
+      c: StringLiteral["foo"]
+    ]
+  end
+
+  it "gets a child value" do
+    n = MyNode[
+      a: IntLiteral[42],
+      b: IntLiteral[10],
+      c: StringLiteral["foo"]
+    ]
+    n.get_child(:a).should == IntLiteral[42]
+    n.get_child(:b).should == IntLiteral[10]
+    n.get_child(:c).should == StringLiteral["foo"]
+  end
+
+  it "returns a default sexp implementation for basic ruby types" do
+    :foo.sexp.should == :foo
+    "foo".sexp.should == "foo"
+    1.sexp.should == 1
+    1.5.sexp.should == 1.5
+    nil.sexp.should == nil
+    true.sexp.should == true
+    false.sexp.should == false
+    [1,2,3].sexp.should == [1,2,3]
+  end
+
+  context "finds node up & down the tree" do
+    before :each do
+      @outer_while = WhileLoop[
+        condition: Operator[
+          name: :<,
+          left: Variable::Reference[:x],
+          right: Variable::Reference[:y]
+        ],
+        body: CodeBlock[
+          Assignment[
+            var: Variable::Reference[:x],
+            value: Function::Call[name: :foo, args: [Variable::Reference[:y]]]
+          ],
+          WhileLoop[
+            condition: Operator[
+              name: :<,
+              left: Variable::Reference[:y],
+              right: Variable::Reference[:z]
+            ],
+            body: CodeBlock[
+              Assignment[
+                var: Variable::Reference[:y],
+                value: Function::Call[name: :bar, args: [Variable::Reference[:z]]]
+              ],
+              Assignment[
+                var: Variable::Reference[:z],
+                value: IntLiteral[10]
+              ]
+            ]
+          ]
+        ]
+      ]
+
+      @x_assign    = @outer_while.body[0]
+      @inner_while = @outer_while.body[1]
+      @y_assign    = @inner_while.body[0]
+      @z_assign    = @inner_while.body[1]
+    end
+
+    it "finds nodes up the tree" do
+      @x_assign.find_parent_node(WhileLoop).should == @outer_while
+      @y_assign.find_parent_node(WhileLoop).should == @inner_while
+      @inner_while.find_parent_node(WhileLoop).should == @outer_while
+
+      @x_assign.find_parent_nodes(WhileLoop).should == [@outer_while]
+      @y_assign.find_parent_nodes(WhileLoop).should == [@inner_while, @outer_while]
+      @inner_while.find_parent_nodes(WhileLoop).should == [@outer_while]
+
+      @x_assign.find_parent_node(Assignment).should be_nil
+      @y_assign.find_parent_node(Assignment).should be_nil
+      @inner_while.find_parent_node(Assignment).should be_nil
+    end
+
+    it "finds nodes down the tree" do
+      @outer_while.find_child_node(WhileLoop).should == @inner_while
+      @outer_while.find_child_node(Assignment).should == @x_assign
+      @inner_while.find_child_node(WhileLoop).should be_nil
+      @inner_while.find_child_node(Assignment).should == @y_assign
+
+      @outer_while.find_child_nodes(WhileLoop).should == [@inner_while]
+      @outer_while.find_child_nodes(Assignment).should == [@x_assign, @y_assign, @z_assign]
+      @inner_while.find_child_nodes(WhileLoop).should == []
+      @inner_while.find_child_nodes(Assignment).should == [@y_assign, @z_assign]
+    end
+
+    it "deletes nodes down the tree" do
+      @outer_while.delete_child_node(
+        Assignment[
+          var: Variable::Reference[name: :y],
+          value: Function::Call[
+            name: :bar,
+            args: [ Variable::Reference[name: :z] ]
+          ]
+        ]
+      ).should == @y_assign
+      @inner_while.body.size.should == 1
+      @inner_while.body[0].should   == @z_assign
+    end
+
+    it "deleted all child nodes that match down the tree" do
+      any = Wood::TreePattern::AnyMatcher.new
+
+      @outer_while.delete_child_nodes(
+        Assignment[
+          name: any,
+          value: Function::Call[
+            name: any,
+            args: any
+          ]
+        ]
+      ).should == [@x_assign, @y_assign]
+      @inner_while.body.size.should == 1
+      @inner_while.body[0].should   == @z_assign
+    end
+  end
+end

data/spec/wood/node_visitor_spec.rb

@@ -0,0 +1,43 @@
+class MyVisitor
+  include Wood::NodeVisitor
+
+  ignore_nodes :node_c, :node_d
+
+  attr_reader :value
+
+  def node_a(node)
+    @value = "in node_a"
+  end
+
+  def node_b(node)
+    @value = "in node_b"
+  end
+end
+
+describe Wood::NodeVisitor do
+  before :each do
+    @v = MyVisitor.new
+    @node = Struct.new(:node_name)
+  end
+
+  it "dispatches based on node_name" do
+    a = @node.new("node_a")
+    b = @node.new("node_b")
+
+    @v.visit(a)
+    @v.value.should == "in node_a"
+    @v.visit(b)
+    @v.value.should == "in node_b"
+  end
+
+  it "raises an exception when trying to visit an undefined node" do
+    expect {
+      @v.visit @node.new("foo")
+    }.to raise_error(NoMethodError)
+  end
+
+  it "ignores specified nodes" do
+    @v.visit(@node.new("node_c")).ignored.should be_truthy
+    @v.visit(@node.new("node_d")).ignored.should be_truthy
+  end
+end

data/spec/wood/nodes/code_block_spec.rb

@@ -0,0 +1,32 @@
+describe Wood::Nodes::CodeBlock do
+  it "defaults to an empty array of expressions" do
+    CodeBlock[].expressions.should be_empty
+    CodeBlock[].should be_empty
+    CodeBlock[].empty?.should be_truthy
+  end
+
+  it "behaves as an Enumerable and forward delegates #each" do
+    expressions = [
+      Function::Call[name: :foo],
+      Function::Call[name: :bar],
+      Return[]
+    ]
+    cb = CodeBlock[expressions: expressions]
+    cb.to_a.should == expressions
+    expressions.size.times do |i|
+      cb[i].should == expressions[i]
+    end
+    cb << Function::Call[name: :final]
+    cb.size.should == 4
+    cb[-1].should == Function::Call[name: :final]
+  end
+
+  it "returns an array of the body's sexps" do
+    expressions = [
+      Function::Call[name: :foo],
+      Function::Call[name: :bar],
+      Return[]
+    ]
+    CodeBlock[expressions: expressions].sexp.should == expressions.map(&:sexp)
+  end
+end

data/spec/wood/nodes/no_op_spec.rb

@@ -0,0 +1,5 @@
+describe Wood::Nodes::NoOp do
+  it "has type void" do
+    Wood::Nodes::NoOp[].type.should == Wood::Types::Void
+  end
+end

data/spec/wood/nodes/operator_spec.rb

@@ -0,0 +1,31 @@
+describe Wood::Nodes::Operator do
+  Operator = Wood::Nodes::Operator
+
+  it "is boolean" do
+    Operator::BOOL_OPS.each do |name|
+      Operator[name: name].boolean?.should be_truthy
+    end
+  end
+
+  it "it is not boolean" do
+    Operator::NON_BOOL_OPS.each do |name|
+      Operator[name: name].boolean?.should be_falsey
+    end
+  end
+
+  it "returns itself as a boolean operator" do
+    Operator::NON_BOOL_OPS.each do |name|
+      op = Operator[name: name]
+      op.to_boolean.should == Operator[
+        name: :"!=",
+        left: op,
+        right: IntLiteral[0]
+      ]
+    end
+
+    Operator::BOOL_OPS.each do |name|
+      op = Operator[name: name]
+      op.to_boolean.should == op
+    end
+  end
+end

data/spec/wood/tree_pattern/any_matcher_spec.rb

@@ -0,0 +1,32 @@
+describe Wood::TreePattern::AnyMatcher do
+  before do
+    @m = Wood::TreePattern::AnyMatcher.new
+  end
+
+  it "matches any node" do
+    @m.should === Function::Call[name: :foo]
+    @m.should === Variable::Declaration[
+      name: :x,
+      type: Wood::Types::Int,
+      value: IntLiteral[10]
+    ]
+    @m.should === CharLiteral["c"]
+    @m.should === IntLiteral[10]
+
+    IntLiteral[@m].should === IntLiteral[10]
+  end
+
+  it "is equal to any node" do
+    @m.should == IntLiteral[10]
+    @m.should == StringLiteral["foo"]
+    @m.should == @m
+  end
+
+  it "returns a sexp notation" do
+    @m.sexp.should == [:any_matcher]
+  end
+
+  it "returns a string notation of self" do
+    @m.inspect.should == @m.sexp.inspect
+  end
+end