wood 0.1.1

data/lib/core_ext.rb

@@ -0,0 +1,4 @@
+require_relative "core_ext/string"
+require_relative "core_ext/enumerable"
+require_relative "core_ext/kernel"
+require_relative "core_ext/class"

data/lib/core_ext/class.rb

@@ -0,0 +1,13 @@
+class Class
+  def delegate(methods:, to:)
+    code = methods.map do |method|
+      "
+      def #{method}(*args, &block)
+        #{to}.#{method}(*args, &block)
+      end
+      "
+    end.join("\n")
+
+    class_eval code
+  end
+end

data/lib/core_ext/enumerable.rb

@@ -0,0 +1,47 @@
+module Enumerable
+  # Helper class for iterating over elements in a {Enumerable} while
+  # calling a given block between each element.
+  class InBetweenEnum
+    include Enumerable
+    def initialize(enum, block)
+      @enum = enum
+      @block = block
+    end
+
+    # Calls a given block with each element while also calling `@block`
+    # in between each element during iteration.
+    def each
+      block = -> { block = @block }
+      @enum.each do |x|
+        block.call
+        yield x
+      end
+    end
+  end
+
+  # Creates a {InBetweenEnum} for iteration while calling `block` in between.
+  #
+  # @param block [Proc, #call] Block to be called in between each element
+  #
+  # @return [InBetweenEnum] Enumerable like object for iterating over elements
+  #                         in `self` while calling `block` in between.
+  def in_between(&block)
+    InBetweenEnum.new(self, block)
+  end
+
+  # Same as #map but passing along the index with each element to a given block.
+  #
+  # @return [Array] Mapped items based on block given.
+  # @example
+  #         ["a","b","c"].map_with_index do |x, i|
+  #           x + (i * 2).to_s
+  #         end
+  #         => ["a0", "b2", "c4"]
+  def map_with_index
+    arr = []
+    each_with_index do |x, i|
+      arr << yield(x, i)
+    end
+    arr
+  end
+end

data/lib/core_ext/kernel.rb

@@ -0,0 +1,16 @@
+module Kernel
+  # Requires any ruby files in a given path.
+  #
+  # @param path [String] Path to require all ruby files from.
+  # @param relative_to [String] Path relative to where `path` exists.
+  #
+  # @example require_all "compile_stages", relative_to: __FILE__
+  def require_all(path, relative_to: nil)
+    if rt = relative_to
+      path = "#{File.dirname(rt)}/#{path}"
+    end
+    Dir.glob("#{path}/*.rb").each do |f|
+      require f
+    end
+  end
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,32 @@
+class String
+  # Returns a snake cases version of a {String}.
+  #
+  # @return [String] Snake cased version of `self`.
+  # @example "FooBarBaz".snake_cased # => "foo_bar_baz"
+  def snake_cased
+    r1 = /([A-Z]+)([A-Z][a-z])/
+    r2 = /([a-z\d])([A-Z])/
+
+    gsub(r1,'\1_\2').gsub(r2,'\1_\2').tr("-", "_").downcase
+  end
+
+  # Returns a camel cased version of a {String}.
+  #
+  # @return [String] Camel cased version of `self`.
+  # @example "foo_bar_baz".camel_cased # => "FooBarBaz"
+  def camel_cased
+    split("_").map(&:capitalize).join
+  end
+
+  # Returns `self` with all trailing whitespace removed.
+  #
+  # @return [String] `self` without any trailing whitespace.
+  def without_trailing_whitespace
+    lines.map(&:rstrip).join("\n")
+  end
+
+  def capitalized?
+    c = self[0]
+    c && c.upcase == c
+  end
+end

data/lib/wood.rb

@@ -0,0 +1,13 @@
+require_relative "core_ext"
+
+require_relative "wood/node"
+require_relative "wood/node_rewriter"
+require_relative "wood/node_visitor"
+require_relative "wood/tree_pattern"
+require_relative "wood/tree_rewriter"
+require_relative "wood/nodes"
+
+require_relative "wood/types"
+
+require_relative "wood/indented_printer"
+require_relative "wood/version"

data/lib/wood/indented_printer.rb

@@ -0,0 +1,48 @@
+module Wood
+  # Mixin used for indented pretty-printing of code.
+  # Expects `#io` and `#indentation` methods to work.
+  module IndentedPrinter
+    # Yields to a given block while indenting the output generated
+    # within the block.
+    def with_indentation
+      indent
+      newline
+      yield
+      unindent
+      newline
+    end
+
+    # Prints any arguments passed to `io`.
+    # @param args [Array] List of objects to print to `io`.
+    def print(*args)
+      args.each do |a|
+        io << a
+      end
+    end
+
+    # Prints a {String} to `io` followed by a line break.
+    # @param str [String] String to be printed to `io` followed by a newline.
+    def println(str)
+      print str, "\n"
+    end
+
+    # Inserts a line break into `io` together with correct reindentation on
+    # the next line.
+    def newline
+      io << "\n"
+      io << (" " * @__indent__.to_i)
+    end
+
+    # Increases the current indentation by `indentation` spaces.
+    def indent
+      @__indent__ ||= 0
+      @__indent__ += indentation
+    end
+
+    # Decreases the current indentation by `indentation` spaces.
+    def unindent
+      @__indent__ ||= 0
+      @__indent__ -= indentation
+    end
+  end
+end

data/lib/wood/node.rb

@@ -0,0 +1,259 @@
+module Wood
+  # Base node class.
+  # Represents a generic AST node to be visited, processed & rewritten
+  # in the compiler pipeline.
+  class Node
+    def self.with_type(type_pattern)
+      Wood::TreePattern::TypeMatcher.new(self, type_pattern)
+    end
+
+    def with_type(type_pattern)
+      Wood::TreePattern::TypeMatcher.new(self, type_pattern)
+    end
+
+    module ClassMethods
+      # @return [Array<Symbol>]
+      #         List of child node names for a {Node} class.
+      def __child_nodes__
+        superclass.__child_nodes__ + (@__child_nodes__ || [])
+      end
+
+      # @param child_nodes [Array<Symbol>]
+      #        Sets the list of child nodes for a {Node} class.
+      def child_nodes(*child_nodes)
+        @__child_nodes__ = child_nodes
+        attr_accessor *child_nodes
+      end
+
+      # Prefix to be ignored for #node_name
+      attr_accessor :node_name_prefix
+
+      # Overrides the default node name of a {Node} class.
+      #
+      # @param node_name [Symbol] New node name for {Node} class.
+      def node_name(node_name = nil)
+       @__node_name__ = node_name if node_name
+        unless @__node_name__
+          camel_cased = (name.split("::") - node_name_prefix.split("::")).join
+          @__node_name__ = camel_cased.snake_cased.to_sym
+        end
+        @__node_name__
+      end
+
+      # Instantiates a new instance of `self` with `options`.
+      def [](options = {})
+        new(options)
+      end
+    end
+
+    def self.__child_nodes__
+      []
+    end
+
+    def self.inherited(klass)
+      klass.extend ClassMethods
+      klass.node_name_prefix = "Wood::Nodes"
+      klass.__send__ :include, Wood::TreePattern::CombinatorialMatching
+      klass.extend Wood::TreePattern::CombinatorialMatching
+    end
+
+    Position = Struct.new(:line, :column)
+
+    # {Position} of node in the original source code.
+    attr_reader   :pos
+    # Type of node, like they're defined in {Wood::Types}.
+    attr_accessor :type
+    # Parent of this node within the AST.
+    attr_accessor :parent_node
+
+    def initialize(options = {})
+      @pos  = options[:pos] || Position.new
+      @type = options[:type]
+
+      self.class.__child_nodes__.each do |c|
+        node = options[c]
+        instance_variable_set("@#{c}", node)
+        if node.respond_to? :parent_node=
+          node.parent_node = self
+        end
+      end
+
+      setup
+    end
+
+    # Gets called on initialization, should be overwritten by subclass
+    # if any checking needs to be done on the child node data etc.
+    def setup
+    end
+
+    # @return [Symbol] Node name of this node.
+    def node_name
+      self.class.node_name
+    end
+
+    # @return [Array] S-expression version of `self`.
+    def sexp
+      [self.class.node_name, *child_nodes.map(&:sexp)]
+    end
+
+    # @param block [Proc, #call] Block to be called with each child node.
+    def each_child(&block)
+      self.class.__child_nodes__.each(&block)
+    end
+
+    def each_child_with_name(&block)
+      self.class.__child_nodes__.each do |child_name|
+        yield(get_child(child_name), child_name)
+      end
+    end
+
+    # @return [Array<Node>] List of child nodes for `self`.
+    def child_nodes
+      child_node_names.map do |c|
+        get_child(c)
+      end
+    end
+
+    # @return [Array<Symbol>] List of child node names for `self`.
+    def child_node_names
+      self.class.__child_nodes__
+    end
+
+    # Compares a node to another.
+    # @return [true, false] `true` if nodes equal, `false` otherwise.
+    def == other
+      case other
+      when self.class
+        each_child do |child|
+          return false unless self.__send__(child) == other.__send__(child)
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    # Matches a node with another.
+    # @return [true, false] `true` if nodes match, `false` otherwise.
+    def === other
+      case other
+      when self.class
+        each_child do |child|
+          child_val = get_child(child) || Wood::TreePattern::AnyMatcher.new
+          return false unless child_val === other.get_child(child)
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    def inspect
+      sexp.inspect
+    end
+
+    # @param child_name [Symbol] Name of child to get node value for.
+    # @return [Node] Child node named `child_name`.
+    def get_child(child_name)
+      __send__(child_name)
+    end
+
+    # @param child_name [Symbol] Name of child node to set value for.
+    # @param node_val [Node] Node value to set child node to.
+    def set_child(child_name, node_val)
+      __send__("#{child_name}=", node_val)
+    end
+
+    # Allows per-node custom pattern matchers & rewriters.
+    def __rewriter_class__
+      @rewriter_class ||= Class.new do
+        include Wood::TreePattern::Matcher
+        include Wood::TreeRewriter
+        patterns self.new
+      end
+    end
+
+    def pattern(&block)
+      __rewriter_class__.pattern(&block)
+    end
+
+    def rewrite!
+      __rewriter_class__.new.rewrite(self)
+    end
+
+    delegate methods: [
+      :find_parent_node, :find_parent_nodes,
+      :find_child_node, :find_child_nodes,
+      :delete_child_node, :delete_child_nodes
+    ], to: :__node_finder__
+
+    private
+
+    def __node_finder__
+      @node_finder ||= Wood::TreePattern::NodeFinder.new(self)
+    end
+  end
+end
+
+# sexp methods for core classes
+
+BuiltinNodeClasses = [
+  Symbol, String, Regexp, Numeric,
+  NilClass, TrueClass, FalseClass
+]
+
+BuiltinNodeClasses.each do |c|
+  c.class_eval do
+    def sexp
+      self
+    end
+
+    def each_child_with_name
+      self
+    end
+  end
+end
+
+class Array
+  def sexp
+    map(&:sexp)
+  end
+
+  def node_name
+    :array
+  end
+
+  def parent_node=(parent_node)
+    each do |node|
+      node.parent_node = parent_node if node.respond_to?(:parent_node=)
+    end
+  end
+
+  def === other
+    case other
+    when Array
+      self.each_with_index do |x, i|
+        return false unless x === other[i]
+      end
+    else
+      return false
+    end
+
+    return true
+  end
+
+  def child_nodes
+    self
+  end
+
+  alias_method :each_child_with_name, :each_with_index
+
+  def set_child(child_name, node_val)
+    case node_val
+    when nil
+      self.delete_at(child_name)
+    else
+      self[child_name] = node_val
+    end
+  end
+end

data/lib/wood/node_rewriter.rb

@@ -0,0 +1,29 @@
+module Wood
+  class NodeRewriter
+    instance_methods.each do |m|
+      undef_method m unless m =~ /(^__|^send$|^object_id$)/
+    end
+
+    attr_reader :node
+
+    def initialize(node, name = nil, parent = nil)
+      @node = node
+      @parent = parent
+      @name = name
+    end
+
+    def method_missing(method, *args, &block)
+      NodeRewriter.new(@node.__send__(method, *args, &block), method, self)
+    end
+
+    def rewrite(new_node_val)
+      if new_node_val.respond_to? :node
+        new_node_val = new_node_val.node
+      end
+
+      if @parent && @name
+        @parent.set_child(@name, new_node_val)
+      end
+    end
+  end
+end