wood 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06461ae1653d67b6313731b6cf748bbb42f2f56f
+  data.tar.gz: a70aa6de996d62eaec7a70b6e18fea232db71eb8
+SHA512:
+  metadata.gz: 144f8160f047702df5d83f7594440d88a7c7bdee35e89c55aa300a633bce941c113504df175963ba3c9a11bbedc27fe665ecb9a35c4b2cc2f1ee5dde06eb2675
+  data.tar.gz: 052a2acf8f7585575434e63b8a8b12f695ebf0613097c13960759d31bf22fb63df4dadedc4b5163640a7dbf016e4fe2afea3d3c329417d858a0f912ee93a84d7

data/Gemfile

@@ -0,0 +1,8 @@
+# Ruby Dependencies
+
+source 'https://rubygems.org'
+
+group :development do
+  gem "rspec"
+  gem "simplecov"
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2014 Christopher Bertels
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+      disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the original authors nor the names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,21 @@
+# Wood - Tree manipulation library
+
+Wood is a library for creating, manipulating & rewriting trees,
+in particular Abstract Syntax Trees (ASTs).
+
+Wood was extracted from a source to source compiler I worked on for
+Marft Inc. in 2013/14.
+Marft has granted me the rights to this library, so I'm releasing it under the
+3-clause BSD license (see LICENSE file).
+
+The compiler that was built using this library (which was then called Forest)
+translated a subset of ANSI C to multiple target languages, including Java, C#
+and JavaScript.
+
+Wood provides an easy to use DSL for searching & rewriting whole sub-trees
+in place, which can be used for things like subsequently translating a parse tree
+into a target language tree (in the compiler project's case to Java::AST,
+CSharp::AST and JavaScript::AST trees).
+
+You can find some example tree node definitions & rewriting rules in the
+examples directory.

data/Rakefile

@@ -0,0 +1,55 @@
+require "rspec/core/rake_task"
+
+RootDir = File.expand_path(File.dirname(__FILE__))
+
+task :default => :spec
+
+desc "Run RSpec tests"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-r ./spec/spec_helper", "--format progress"]
+  t.verbose = false
+end
+
+desc "Run RSpec tests & generate test coverage report"
+RSpec::Core::RakeTask.new(:spec_cov) do |t|
+  t.rspec_opts = ["-r ./spec/spec_cov", "-r ./spec/spec_helper", "--format progress"]
+  t.verbose = false
+end
+
+desc "Generate & open test coverage report"
+task :coverage => :spec_cov do
+  system "open coverage/index.html"
+end
+
+task "coverage/" => :coverage
+
+desc "Cleanup generated files and stuff"
+task :clean do
+  rm_rf "#{RootDir}/coverage/"
+  rm_rf "#{RootDir}/doc/"
+  Dir.glob("./**/*.class").each do |f|
+    rm f
+  end
+end
+
+
+LOC_EXCLUDE = []
+def count_loc(dir, exclude_files = LOC_EXCLUDE)
+  source_files = Dir.glob("#{dir}/**/*") - exclude_files
+  source_files.reject!{ |f| File.directory?(f) }
+  `wc -l #{source_files.join(" ")}`.split("\n").last.split("total").first.to_i
+end
+
+desc "Show LOC"
+task :loc do
+  source_dirs = ["lib", "spec"]
+  total = 0
+  source_dirs.each do |d|
+    lines = count_loc(d)
+    total += lines
+    printf("%5s : %i\n", d, lines)
+  end
+  total = "total : #{total}"
+  puts "-" * total.size
+  puts total
+end

data/examples/binary_ops.rb

@@ -0,0 +1,138 @@
+require_relative "../lib/wood"
+
+require "pp"
+
+include Wood
+include Wood::Nodes
+
+# Let's define some node types
+
+class BinaryOperator < Node
+  child_nodes :left, :right
+end
+
+class PlusOperator < BinaryOperator
+end
+
+class MinusOperator < BinaryOperator
+end
+
+class MultiplyOperator < BinaryOperator
+end
+
+class DivideOperator < BinaryOperator
+end
+
+class NumberLiteral < Wood::Node
+  child_nodes :value
+end
+
+RedundantBinaryOpsRewriter = TreeRewriter.new do
+  Zero = IntLiteral[0]
+
+  pattern {
+    opts = { left: l, right: Zero }
+    PlusOperator[opts] | MinusOperator[opts]
+  }.rewrite {
+    l
+  }
+
+  pattern {
+    op = { left: Zero, right: r }
+    PlusOperator[op] | MinusOperator[op]
+  }.rewrite {
+    r
+  }
+
+  pattern {
+    MultiplyOperator[left: Zero, right: _]
+  }.rewrite {
+    Zero
+  }
+
+  pattern {
+    MultiplyOperator[left: _, right: Zero]
+  }.rewrite {
+    Zero
+  }
+
+  pattern {
+    DivideOperator[left: _, right: Zero]
+  }.perform {
+    raise "Can't divide by zero. Fix this ASAP!"
+  }
+
+  pattern {
+    PlusOperator[left: IntLiteral[x], right: IntLiteral[y]]
+  }.rewrite {
+    if x == y
+      IntLiteral[x * 2]
+    end
+  }
+end
+
+# Now, let's use the rewriter:
+
+add_zero = PlusOperator[
+  left: MultiplyOperator[
+    left:  IntLiteral[2],
+    right: IntLiteral[0]
+  ],
+  right: IntLiteral[0]
+]
+
+# rewrite once:
+result1 = RedundantBinaryOpsRewriter.rewrite add_zero
+
+# rewrite repeatedly until no more rewrites happen:
+result2 = RedundantBinaryOpsRewriter.rewrite add_zero, true
+
+puts "Original AST:"
+pp add_zero
+# => [:plus_operator,
+#      [:multiply_operator, [:int_literal, 2], [:int_literal, 0]],
+#      [:int_literal, 0]]
+
+puts "\nAfter a single rewrite:"
+pp result1
+# => [:multiply_operator, [:int_literal, 2], [:int_literal, 0]]
+
+puts "\nAfter all possible rewrites:"
+pp result2
+# => [:int_literal, 0]
+
+# Let's let it crash by dividing by (static) 0 literal
+
+divide_by_zero = DivideOperator[
+  left:  IntLiteral[10],
+  right: MultiplyOperator[
+    left:  IntLiteral[100],
+    right: IntLiteral[0]
+  ]
+]
+
+puts "\nDivide by zero with 1 rewrite:"
+pp RedundantBinaryOpsRewriter.rewrite(divide_by_zero)
+# => [:divide_operator, [:int_literal, 10], [:int_literal, 0]]
+
+puts "\nDivide by zero with repeated rewrites fails:"
+begin
+  RedundantBinaryOpsRewriter.rewrite(divide_by_zero)
+rescue => e
+  pp e
+end
+# => #<RuntimeError: Can't divide by zero. Fix this ASAP!>
+
+puts "\nRewrite 2 + 2 => 4"
+pp RedundantBinaryOpsRewriter.rewrite(PlusOperator[
+  left: IntLiteral[2],
+  right: IntLiteral[2]
+])
+# => [:int_literal, 4]
+
+puts "\nDon't rewrite 3 + 2"
+pp RedundantBinaryOpsRewriter.rewrite(PlusOperator[
+  left: IntLiteral[3],
+  right: IntLiteral[2]
+])
+# => [:plus_operator, [:int_literal, 3], [:int_literal, 2]]

data/examples/node_finder.rb

@@ -0,0 +1,96 @@
+require_relative "../lib/wood"
+
+require "pp"
+
+include Wood
+include Wood::Nodes
+
+func_def = Function::Definition[
+  name: :print_while_positive,
+  type: Types::Int,
+  args: [
+    Function::Argument[name: :x, type: Types::Int]
+  ],
+  body: CodeBlock[
+    WhileLoop[
+      condition: Operator[
+        name:  :<,
+        left:  Variable::Reference[:x],
+        right: IntLiteral[0]
+      ],
+      body: CodeBlock[
+        Function::Call[
+          name: :print,
+          args: [
+            Variable::Reference[:x]
+          ]
+        ],
+        SubAssignment[
+          var: Variable::Reference[:x],
+          value: Operator[
+            name:  :/,
+            left:  Variable::Reference[:x],
+            right: IntLiteral[2]
+          ]
+        ],
+        IfElse[
+          condition: Operator[
+            name: :==,
+            left: Operator[
+              name:  :%,
+              left:  Variable::Reference[:x],
+              right: IntLiteral[2]
+            ],
+            right: IntLiteral[0]
+          ],
+          then_branch: Function::Call[
+            name: :print,
+            args: [
+              StringLiteral["even!"]
+            ]
+          ]
+        ]
+      ]
+    ]
+  ]
+]
+
+
+# the above should look something like this in C:
+# int print_while_positive(int x) {
+#   while(x > 0) {
+#     print(x);
+#     x -= (x / 2);
+#     if(x % 2 == 0)
+#       print("even!");
+#   }
+# }
+
+# let's find the inner print with the string literal:
+
+pp func_def.find_child_node Function::Call[
+  name: :print,
+  args: [Node.with_type(Wood::Types::String)]
+]
+# => [:call, :print, [[:string_literal, "even!"]]]
+
+if_else = func_def.find_child_node IfElse
+pp if_else
+# => [:if,
+#      [:operator, :==,
+#        [:operator, :%,
+#          [:var_ref, :x],
+#          [:int_literal, 2]],
+#        [:int_literal, 0]],
+#      [:call, :print, [[:string_literal, "even!"]]],
+#      nil]
+
+# we can also look up the tree:
+pp func_def == if_else.find_parent_node(Function::Definition)
+# => true
+
+pp if_else == if_else.then_branch.find_parent_node(IfElse)
+# => true
+
+pp func_def.find_child_node(WhileLoop) == if_else.find_parent_node(WhileLoop)
+# => true

data/examples/visitors.rb

@@ -0,0 +1,105 @@
+require_relative "../lib/wood"
+
+require "pp"
+
+include Wood
+include Wood::Nodes
+
+class SourcePrinter
+  include Wood::NodeVisitor
+  include Wood::IndentedPrinter
+
+  # We can keep custom context information available
+  # for visited nodes up the visit call stack
+  SourcePrinterContext = Struct.new(:ignored, :io_flushed)
+
+  def new_context
+    SourcePrinterContext.new(false, false)
+  end
+
+  attr_reader :io
+
+  def initialize(io)
+    @io = io
+  end
+
+  def indentation
+    2
+  end
+
+  def var_ref(var_ref)
+    print var_ref.name
+  end
+
+  def string_literal(sl)
+    print sl.value.inspect
+  end
+end
+
+class JavaPrinter < SourcePrinter
+  def assign(assign)
+    visit_type assign.var
+    print " "
+    visit assign.var
+    print " = "
+    visit assign.value
+    print ";"
+    newline
+  end
+
+  def string_type(st)
+    print "String"
+  end
+end
+
+class RubyPrinter < SourcePrinter
+  def assign(assign)
+    visit assign.var
+    print " = "
+    visit assign.value
+    newline
+  end
+end
+
+class JavaScriptPrinter < SourcePrinter
+  def assign(assign)
+    print "var "
+    visit assign.var
+    print " = "
+    visit(assign.value)
+
+    # # Context example:
+    # # visit returns the context object for that visit
+    # if visit(assign.value).io_flushed
+    #   # do something here if context.io_flushed was set on visit of assign.value
+    # end
+
+    print ";"
+    newline
+  end
+
+  def string_literal(sl)
+    super
+    # # Example use of context:
+    # context.io_flushed = true
+  end
+end
+
+assign_funcall = Assignment[
+  var: Variable::Reference[name: :foo, type: Types::String],
+  value: StringLiteral["Hello, World!"]
+]
+
+# Usage:
+
+print "AST:           "
+pp assign_funcall
+
+print "Java output:   "
+JavaPrinter.new($stdout).visit assign_funcall
+
+print "Ruby output:   "
+RubyPrinter.new($stdout).visit assign_funcall
+
+print "JS output:     "
+JavaScriptPrinter.new($stdout).visit assign_funcall