wood 0.1.1

data/lib/wood/tree_pattern/any_matcher.rb

@@ -0,0 +1,20 @@
+module Wood::TreePattern
+  # Matches anything it is matched / compared against.
+  class AnyMatcher
+    def === node
+      return true
+    end
+
+    def == node
+      return true
+    end
+
+    def sexp
+      [:any_matcher]
+    end
+
+    def inspect
+      sexp.inspect
+    end
+  end
+end

data/lib/wood/tree_pattern/matcher.rb

@@ -0,0 +1,40 @@
+module Wood::TreePattern
+  module Matcher
+    module ClassMethods
+      def pattern_builders
+        @pattern_builders = [] unless @pattern_builders
+        @pattern_builders
+      end
+
+      def pattern(&block)
+        p = PatternBuilder.new(&block)
+        pattern_builders << p
+        p
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def replacement_for(node)
+      self.class.pattern_builders.each do |pb|
+        if pb === node
+          if replacement = pb.replacement_for(node)
+            return replacement
+          end
+        end
+      end
+      return node
+    end
+
+    def === node
+      self.class.pattern_builders.each do |p|
+        if match = (p === node)
+          return match
+        end
+      end
+      return false
+    end
+  end
+end

data/lib/wood/tree_pattern/node_finder.rb

@@ -0,0 +1,164 @@
+module Wood::TreePattern
+  # Provides methods for searching for parent and child nodes
+  # relative to a given {Node}.
+  class NodeFinder
+    # {Node} to start relative search from.
+    attr_accessor :ast
+
+    # Initializes {NodeFinder} with a given {Node}.
+    #
+    # @param ast [Node] AST node to start the search from.
+    def initialize(ast = nil)
+      @ast = ast
+    end
+
+    # Finds a parent node that matches a given pattern.
+    #
+    # @param node_pattern Node pattern to find a parent node with.
+    # @return [Node] Parent node found via `node_pattern` or `nil`.
+    def find_parent_node(node_pattern)
+      ast = @ast
+      while ast = ast.parent_node
+        return ast if node_pattern === ast
+      end
+      return nil
+    end
+
+    # Finds any parent nodes that match a given pattern.
+    #
+    # @param node_pattern Node pattern to find parent nodes with.
+    # @return [Array<Node>] All parent nodes that match `node_pattern`.
+    def find_parent_nodes(node_pattern)
+      ast = @ast
+      found = []
+      while ast = ast.parent_node
+        found << ast if node_pattern === ast
+      end
+      return found
+    end
+
+    # Finds a child node that matches a given pattern.
+    #
+    # @param node_pattern Node pattern to find a child node with.
+    # @return [Node] First child node that matches `node_pattern` or `nil`.
+    def find_child_node(node_pattern)
+      ast.child_nodes.each do |child|
+        if found = __find_child_node__(child, node_pattern)
+          return found
+        end
+      end
+      return nil
+    end
+
+    # Finds all child nodes that match a given pattern.
+    #
+    # @param node_pattern Node pattern to find child nodes with.
+    # @return [Array<Node>] All child nodes that match `node_pattern`.
+    def find_child_nodes(node_pattern)
+      found = []
+      ast.child_nodes.each do |child|
+        found += __find_child_nodes__(child, node_pattern)
+      end
+      found.uniq!
+      return found
+    end
+
+    def delete_child_node(node_pattern)
+      __delete_child_node__(ast, node_pattern)
+    end
+
+    def delete_child_nodes(node_pattern)
+      __delete_child_nodes__(ast, node_pattern)
+    end
+
+    private
+
+    def __find_child_node__(node, node_pattern)
+      return node if node_pattern === node
+      return nil unless node.respond_to?(:child_nodes)
+
+      node.child_nodes.each do |child|
+        if node_pattern === child
+          return child
+        end
+
+        if found = __find_child_node__(child, node_pattern)
+          return found
+        end
+      end
+
+      return nil
+    end
+
+    def __find_child_nodes__(node, node_pattern)
+      found = []
+      found << node if node_pattern === node
+      return found unless node.respond_to?(:child_nodes)
+
+      node.child_nodes.each do |child|
+        if node_pattern === child
+          found << child
+        end
+        found += __find_child_nodes__(child, node_pattern)
+      end
+
+      return found
+    end
+
+    def __delete_child_node__(node, node_pattern)
+      return node if node_pattern === node
+
+      node.each_child_with_name do |child, child_name|
+        case child
+        when node_pattern
+          node.set_child(child_name, nil)
+          return child
+        end
+
+        if deleted = __delete_child_node__(child, node_pattern)
+          return deleted
+        end
+      end
+      return nil
+    end
+
+
+    def __delete_child_nodes__(node, node_pattern)
+      deleted = []
+
+      if Array === node
+        to_del = node.select do |n|
+          node_pattern === n
+        end
+
+        deleted += to_del
+
+        node.each do |n|
+          if del = __delete_child_nodes__(n, node_pattern)
+            deleted += del
+          end
+        end
+
+        to_del.each do |n|
+          node.delete(n)
+        end
+      end
+
+      if Wood::Node === node
+        node.each_child_with_name do |child, child_name|
+          case child
+          when node_pattern
+            node.set_child(child_name, nil)
+            deleted << child
+          end
+
+          if del = __delete_child_nodes__(child, node_pattern)
+            deleted += del
+          end
+        end
+      end
+
+      return deleted
+    end
+  end
+end

data/lib/wood/tree_pattern/or_matcher.rb

@@ -0,0 +1,33 @@
+module Wood::TreePattern
+  module CombinatorialMatching
+    # @return [OrMatcher] Matcher that matches `self` or `other`.
+    def | other
+      OrMatcher.new(self, other)
+    end
+  end
+
+  # Matches a [Node], if any of two given patterns match it.
+  class OrMatcher
+    include CombinatorialMatching
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def === node
+      @a === node || @b === node
+    end
+
+    def == node
+      @a == node || @b == node
+    end
+
+    def sexp
+      [:or_matcher, @a.sexp, @b.sexp]
+    end
+
+    def inspect
+      sexp.inspect
+    end
+  end
+end

data/lib/wood/tree_pattern/pattern_builder.rb

@@ -0,0 +1,57 @@
+module Wood::TreePattern
+  # Helper class for building node patterns & replacement actions.
+  class PatternBuilder < BasicObject
+    attr_reader :pattern, :vars, :replacement_builder
+
+    def initialize(&block)
+      @vars      = []
+      @pattern   = instance_eval(&block) if block
+      @callbacks = []
+    end
+
+    def _(var_name = nil)
+      if var_name
+        VariableMatcher.new(self, var_name)
+      else
+        AnyMatcher.new
+      end
+    end
+
+    def add_var(var)
+      @vars << var
+    end
+
+    def rewrite(&block)
+      @replacement_builder = ReplacementBuilder.new(self, &block)
+    end
+
+    def perform(&block)
+      @callbacks << PatternCallback.new(self, &block)
+    end
+
+    def method_missing(var_name, var_value = nil)
+      if var_value
+        add_var PatternVariable.new(var_name, var_value)
+        return var_value
+      else
+        return VariableMatcher.new(self, var_name)
+      end
+    end
+
+    def replacement_for(node)
+      if rb = replacement_builder
+        return rb.replacement_for(node)
+      end
+    end
+
+    def === node
+      if val = (pattern === node)
+        @callbacks.each do |c|
+          c.call(node)
+        end
+        return val
+      end
+      return false
+    end
+  end
+end

data/lib/wood/tree_pattern/pattern_callback.rb

@@ -0,0 +1,5 @@
+module Wood::TreePattern
+  class PatternCallback < ReplacementBuilder
+    alias_method :call, :replacement_for
+  end
+end

data/lib/wood/tree_pattern/replacement_builder.rb

@@ -0,0 +1,27 @@
+module Wood::TreePattern
+  class ReplacementBuilder
+    def initialize(pattern_builder, &block)
+      @pattern_builder = pattern_builder
+      @block           = block
+    end
+
+    def replacement_for(node)
+      @pattern_builder.vars.each do |v|
+        singleton_class.__send__(:define_method, v.name) { v.value }
+      end
+      @node = node
+      instance_eval(&@block)
+    end
+
+    def within(node, &block)
+      node.__rewriter_class__.instance_eval &block
+      node.rewrite!
+    end
+
+    private
+
+    def node
+      @node
+    end
+  end
+end

data/lib/wood/tree_pattern/type_matcher.rb

@@ -0,0 +1,59 @@
+module Wood::TreePattern
+  class TypeMatcher
+    def self.[](*options)
+      case options.first
+      when Hash
+        options = options.first
+        new(options[:node], options[:type])
+      else
+        new(*options)
+      end
+    end
+
+    attr_reader :node_pattern, :type_pattern
+    def initialize(node_pattern, type_pattern)
+      @node_pattern = node_pattern || AnyMatcher.new
+      @type_pattern = type_pattern
+    end
+
+    def === node
+      val = @node_pattern === node
+      if val && (@type_pattern === type(node))
+        return val
+      end
+      return nil
+    end
+
+    def == node
+      val = @node_pattern == node
+      if val && (@type_pattern == type(node))
+        return val
+      end
+      return nil
+    end
+
+    def sexp
+      node_pat_sexp = if @node_pattern.respond_to?(:sexp)
+        @node_pattern.sexp
+      else
+        @node_pattern.to_s
+      end
+
+      [:type_matcher, node_pat_sexp, @type_pattern.sexp]
+    end
+
+    def inspect
+      sexp.inspect
+    end
+
+    private
+
+    def type(node)
+      if node.respond_to?(:type)
+        node.type
+      else
+        node.instance_variable_get(:@type)
+      end
+    end
+  end
+end

data/lib/wood/tree_pattern/variable_matcher.rb

@@ -0,0 +1,31 @@
+module Wood::TreePattern
+  PatternVariable = Struct.new(:name, :value)
+
+  class VariableMatcher
+    def initialize(pattern_builder, var_name)
+      @pattern_builder = pattern_builder
+      @var_name        = var_name
+    end
+
+    def === node
+      @pattern_builder.add_var(PatternVariable.new(@var_name, node))
+      return true
+    end
+
+    def == node
+      return true
+    end
+
+    def sexp
+      [:variable_matcher, @var_name]
+    end
+
+    def inspect
+      sexp.inspect
+    end
+
+    def with_type(type_pattern)
+      Wood::TreePattern::TypeMatcher.new(self, type_pattern)
+    end
+  end
+end