wood 0.1.1

data/spec/wood/tree_pattern/type_matcher_spec.rb

@@ -0,0 +1,69 @@
+describe Wood::TreePattern::TypeMatcher do#
+  context "match certain node pattern and type pattern" do
+    before do
+      @m = Wood::TreePattern::TypeMatcher[
+        node: Variable::Reference,
+        type: Wood::Types::U8
+      ]
+      @m2 = Variable::Reference.with_type(Wood::Types::U8)
+    end
+
+    it "matches the right nodes" do
+      [
+        Variable::Reference[name: :foo, type: Wood::Types::U8],
+        Variable::Reference[name: :bar, type: Wood::Types::U8]
+      ].each do |node|
+        @m.should === node
+        @m2.should === node
+      end
+    end
+
+    it "doesn't match the wrong nodes" do
+      [
+        Variable::Reference[name: :foo, type: Wood::Types::Char],
+        Variable::Reference[name: :bar, type: Wood::Types::Int],
+        Variable::Declaration[],
+        NoOp[]
+      ].each do |node|
+        @m.should_not === node
+        @m.should_not == node
+        @m2.should_not === node
+        @m2.should_not == node
+      end
+    end
+  end
+
+  context "match any node pattern and certain type pattern" do
+    before do
+      @type = Wood::Types::Array[Wood::Types::Int]
+      @m = Wood::TreePattern::TypeMatcher[type: @type]
+      @m2 = Node.with_type(@type)
+    end
+
+    it "matches the right nodes" do
+      [
+        Function::Declaration[type: @type, name: :foo],
+        Return[type: @type, expression: Variable::Reference[name: :bar]],
+        Variable::Reference[type: @type, name: :baz]
+      ].each do |node|
+        @m.should === node
+        @m.should == node
+        @m2.should === node
+        @m2.should_not == node
+      end
+    end
+
+    it "doesn't match the wrong nodes" do
+      [
+        Function::Declaration[type: Wood::Types::Int, name: :foo],
+        Return[type: Wood::Types::Int, expression: Variable::Reference[name: :bar]],
+        Variable::Reference[type: Wood::Types::Int, name: :baz]
+      ].each do |node|
+        @m.should_not === node
+        @m.should_not == node
+        @m2.should_not === node
+        @m2.should_not == node
+      end
+    end
+  end
+end

data/spec/wood/tree_pattern/variable_matcher_spec.rb

@@ -0,0 +1,37 @@
+describe Wood::TreePattern::VariableMatcher do
+  before :each do
+    @pb = Wood::TreePattern::PatternBuilder.new
+    @vm = Wood::TreePattern::VariableMatcher.new(@pb, :var_name)
+  end
+
+  it "matches any node and adds a corresponding var to its PatternBuilder" do
+    @pb.vars.should be_empty
+    @vm.should === IntLiteral[10] # do the match
+    @pb.vars.should_not be_empty
+
+    @pb.vars.first.tap do |var|
+      var.name.should == :var_name
+      var.value.should == IntLiteral[10]
+    end
+  end
+
+  it "equal to any node" do
+    @vm.should == IntLiteral[10]
+    @vm.should == StringLiteral["foo"]
+    @vm.should == @vm
+  end
+
+  it "returns a sexp notation" do
+    @vm.sexp.should == [:variable_matcher, :var_name]
+  end
+
+  it "returns a string notation of self" do
+    @vm.inspect.should == @vm.sexp.inspect
+  end
+
+  it "returns a TypeMatcher based on self" do
+    tm = @vm.with_type(Wood::Types::Int)
+    tm.node_pattern.should == @vm
+    tm.type_pattern.should == Wood::Types::Int
+  end
+end

data/spec/wood/tree_rewriter_spec.rb

@@ -0,0 +1,351 @@
+describe Wood::TreeRewriter do
+  it "rewrites nested nodes based on tree patterns" do
+    class MyStringMatcher
+      include Wood::TreePattern::Matcher
+      pattern {
+        StringLiteral[val]
+      }.rewrite {
+        StringLiteral[val * 2]
+      }
+    end
+
+    class MultByZeroMatcher
+      include Wood::TreePattern::Matcher
+      ZERO = IntLiteral[0]
+
+      pattern {
+        Operator[name: :*, left: ZERO, right: _]
+      }.rewrite {
+        ZERO
+      }
+
+      pattern {
+        Operator[name: :*, left: _, right: ZERO]
+      }.rewrite {
+        ZERO
+      }
+    end
+
+    class MyTreeRewriter
+      include Wood::TreeRewriter
+      patterns MyStringMatcher.new, MultByZeroMatcher.new
+    end
+
+    tree = CodeBlock[
+      Variable::Declaration[
+        type: Wood::Types::Int,
+        name: :x,
+        init_val: Operator[
+          name: :*,
+          left: IntLiteral[0],
+          right: IntLiteral[10]
+        ]
+      ],
+      Variable::Declaration[
+        type: Wood::Types::Int,
+        name: :y,
+        init_val: Operator[
+          name: :*,
+          left: IntLiteral[10],
+          right: IntLiteral[0]
+        ]
+      ]
+    ]
+    rw = MyTreeRewriter.new
+    rw.rewrite(tree)
+    tree.should == CodeBlock[
+      Variable::Declaration[
+        type: Wood::Types::Int,
+        name: :x,
+        init_val: IntLiteral[0]
+      ],
+      Variable::Declaration[
+        type: Wood::Types::Int,
+        name: :y,
+        init_val: IntLiteral[0]
+      ]
+    ]
+
+    tree = Function::Declaration[
+      name: :foo,
+      type: Wood::Types::Int,
+      body: CodeBlock[
+        Variable::Declaration[
+          type: Wood::Types::Int,
+          name: :x,
+          init_val: IntLiteral[2]
+        ],
+        Variable::Declaration[
+          type: Wood::Types::Int,
+          name: :y,
+          init_val: Operator[
+            name: :*,
+            left: IntLiteral[2],
+            right: Operator[
+              name: :*,
+              left: Variable::Reference[:x],
+              right: IntLiteral[0]
+            ]
+          ]
+        ],
+        Variable::Declaration[
+          type: Wood::Types::Int,
+          name: :z,
+          init_val: Operator[
+            name: :*,
+            left: IntLiteral[0],
+            right: Variable::Reference[:x]
+          ]
+        ],
+        Variable::Declaration[
+          type: Wood::Types::String,
+          name: :foo,
+          init_val: StringLiteral["hello, world"]
+        ]
+      ]
+    ]
+    rw = MyTreeRewriter.new
+    rw.rewrite(tree, false)
+
+    rewritten_code = <<-C
+    int foo() {
+      int x = 2;
+      int y = 0;
+      int z = 0;
+      char * foo = "hello, world!hello, world!";
+    }
+    C
+    rewritten_code = Function::Declaration[
+      name: :foo,
+      type: Wood::Types::Int,
+      body: CodeBlock[
+        Variable::Declaration[
+          type: Wood::Types::Int,
+          name: :x,
+          init_val: IntLiteral[2]
+        ],
+        Variable::Declaration[
+          type: Wood::Types::Int,
+          name: :y,
+          init_val: IntLiteral[0]
+        ],
+        Variable::Declaration[
+          type: Wood::Types::Int,
+          name: :z,
+          init_val: IntLiteral[0]
+        ],
+        Variable::Declaration[
+          type: Wood::Types::String,
+          name: :foo,
+          init_val: StringLiteral["hello, world!hello, world!"]
+        ]
+      ]
+    ]
+    tree.should == rewritten_code
+  end
+
+  it "works with OrMatchers" do
+    class MultByZeroOrRewriter
+      include Wood::TreeRewriter
+      include Wood::TreePattern::Matcher
+      ZERO = IntLiteral[0]
+
+      pattern {
+        Operator[
+          name: :*,
+          left: ZERO,
+          right: _
+        ] | Operator[
+          name: :*,
+          left: _,
+          right: ZERO
+        ]
+      }.rewrite {
+        ZERO
+      }
+
+      pattern {
+        Operator[
+          name: :+,
+          left: ZERO,
+          right: val
+        ] | Operator[
+          name: :+,
+          left: val,
+          right: ZERO
+        ]
+      }.rewrite {
+        val
+      }
+
+      patterns self.new
+    end
+
+    rw = MultByZeroOrRewriter.new
+    tree = CodeBlock[
+      Variable::Declaration[
+        type: Wood::Types::Int,
+        name: :x,
+        init_val: Operator[
+          name: :+,
+          left: Operator[
+            name: :*,
+            left: IntLiteral[2],
+            right: IntLiteral[3]
+          ],
+          right: Operator[
+            name: :*,
+            left: IntLiteral[2],
+            right: IntLiteral[0]
+          ]
+        ]
+      ]
+    ]
+    # call rewrite with repeated=false
+    rw.rewrite(tree)
+    tree.should == CodeBlock[
+      Variable::Declaration[
+        type: Wood::Types::Int,
+        name: :x,
+        init_val: Operator[
+          name: :+,
+          left: Operator[
+            name: :*,
+            left: IntLiteral[2],
+            right: IntLiteral[3]
+          ],
+          right: IntLiteral[0]
+        ]
+      ]
+    ]
+
+    # rewrite again to apply second pattern rewrite
+    rw.rewrite(tree)
+    tree.should == CodeBlock[
+      Variable::Declaration[
+        type: Wood::Types::Int,
+        name: :x,
+        init_val: Operator[
+          name: :*,
+          left: IntLiteral[2],
+          right: IntLiteral[3]
+        ]
+      ]
+    ]
+
+    # call rewrite with repeated=true (apply all rules in one run)
+    tree = Variable::Declaration[
+      type: Wood::Types::Int,
+      name: :x,
+      init_val: Operator[
+        name: :+,
+        left: Operator[
+          name: :*,
+          left: IntLiteral[2],
+          right: IntLiteral[3]
+        ],
+        right: Operator[
+          name: :*,
+          left: IntLiteral[2],
+          right: IntLiteral[0]
+        ]
+      ]
+    ]
+    rw.rewrite(tree, true)
+
+    tree.should == Variable::Declaration[
+      type: Wood::Types::Int,
+      name: :x,
+      init_val: Operator[
+        name: :*,
+        left: IntLiteral[2],
+        right: IntLiteral[3]
+      ]
+    ]
+  end
+
+  it "rewrites the root node" do
+    class MyRootRewriter
+      include Wood::TreePattern::Matcher
+      include Wood::TreeRewriter
+
+      pattern {
+        IfElse[
+          condition: Operator[name: :<, left: _, right: _],
+          then_branch: _
+        ]
+      }.perform {
+        node.condition = TrueLiteral[]
+        node.then_branch = CodeBlock[Return[StringLiteral["Hello, world!"]]]
+      }
+
+      patterns self.new
+    end
+
+    if_else = IfElse[
+      condition: Operator[name: :<, left: IntLiteral[1], right: IntLiteral[2]],
+      then_branch: CodeBlock[Return[StringLiteral["This should be rewritten"]]]
+    ]
+
+    MyRootRewriter.new.rewrite(if_else)
+
+    if_else.condition.should == TrueLiteral[]
+    if_else.then_branch.should == CodeBlock[Return[StringLiteral["Hello, world!"]]]
+  end
+
+  it "looks up parent nodes" do
+    class MyParentNodeFinderRewriter
+      include Wood::TreePattern::Matcher
+      include Wood::TreeRewriter
+
+      pattern {
+        Assignment[var: ref, value: val]
+      }.rewrite {
+        if (wl = node.find_parent_node(WhileLoop)) && wl != node.parent_node
+          case wl.condition
+          when Assignment[var: ref]
+            Function::Call[
+              name: :triedToAssign,
+              args: [
+                StringLiteral[ref.name.to_s],
+                val
+              ]
+            ]
+          end
+        end
+      }
+
+      patterns self.new
+    end
+
+    ast = WhileLoop[
+      condition: Assignment[
+        var: Variable::Reference[:x],
+        value: Function::Call[name: :foo]
+      ],
+      body: CodeBlock[
+        Assignment[
+          var: Variable::Reference[:x],
+          value: IntLiteral[10]
+        ]
+      ]
+    ]
+
+    MyParentNodeFinderRewriter.new.rewrite(ast)
+
+    target = WhileLoop[
+      condition: Assignment[
+        var: Variable::Reference[:x],
+        value: Function::Call[name: :foo]
+      ],
+      body: CodeBlock[
+        Function::Call[
+          name: :triedToAssign,
+          args: [StringLiteral["x"], IntLiteral[10]]
+        ]
+      ]
+    ]
+
+    ast.should == target
+  end
+end