treevisitor 0.2.3 → 0.2.4

data/lib/treevisitor/leaf_node.rb

@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-module TreeVisitor
-
-  #
-  # Represent a LeafNode
-  #
-  class LeafNode < AbsNode
-
-    #
-    # @param [Object] content of node
-    #
-    def initialize( content, parent = nil )
-      super( content )
-      parent.add_leaf(self) if parent
-    end
-
-    #
-    # @return false because a leaf_node cannot be a root
-    #
-    def root?
-      false
-    end
-
-    #
-    # @return [TreeNodeVisitor] the visitor
-    #
-    def accept( visitor )
-      visitor.visit_leaf( self )
-      visitor
-    end
-
-  end
-end

data/lib/treevisitor/tree_node.rb

@@ -1,251 +0,0 @@
-# -*- coding: utf-8 -*-
-module TreeVisitor
-  #
-  # TreeNode can contains other TreeNode (children)
-  # and can contains LeafNode (leaves)
-  #
-  # TreeNode @children -1---n-> TreeNode
-  #          @leaves   -1---n-> LeafNode
-  #
-  class TreeNode < AbsNode
-
-    class << self
-
-      def create(class1 = TreeNode, class2 = LeafNode, &block)
-        if class1.ancestors.include?(TreeNode) and class2.ancestors.include?(LeafNode)
-          @tree_node_class = class1
-          @leaf_node_class = class2
-        elsif class1.ancestors.include?(LeafNode) and class2 == LeafNode
-          @tree_node_class = self
-          @leaf_node_class = class1
-        end
-
-        if @tree_node_class.nil? || @leaf_node_class.nil?
-          raise "Must be specified class derived from TreeNode and LeafNode"
-        end
-
-        @scope_stack = []
-        class_eval(&block)
-      end
-
-      private
-
-      def node(*args, &block)
-        parent_node = @scope_stack.length > 0 ? @scope_stack[-1] : nil
-        args << parent_node
-        tree_node = @tree_node_class.new(*args)
-        @scope_stack.push tree_node
-        if block
-          if block.arity == 0 || block.arity == -1
-            class_eval(&block)
-          elsif block.arity == 1
-            new_block = Proc.new { block.call(tree_node) }
-            class_eval(&new_block)
-          else
-            raise "block take too much arguments #{block.arity}"
-          end
-        end
-        @scope_stack.pop
-      end
-
-      def leaf(*args, &block)
-        tree_node = @scope_stack[-1]
-        args << tree_node
-        leaf_node = @leaf_node_class.new(*args)
-        if block
-          if block.arity == 0 || block.arity == -1
-            class_eval(&block)
-          elsif block.arity == 1
-            new_block = Proc.new { block.call(leaf_node) }
-            class_eval(&new_block)
-          else
-            raise "block take too much arguments #{block.arity}"
-          end
-        end
-        leaf_node
-      end
-    end
-
-    attr_reader :leaves
-    attr_reader :children
-
-    #
-    # @param [Object] content of this node
-    #
-    def initialize(content, parent = nil)
-      @leaves   = []
-      @children = []
-      super(content)
-      parent.add_child(self) if parent
-    end
-
-    #
-    # Test if is a root
-    #
-    def root?
-      @parent.nil?
-    end
-
-    #
-    # invalidate cached info
-    # invalidate propagates form parent to children and leaves
-    #
-    def invalidate
-      super
-      @children.each { |c| c.invalidate }
-      @leaves.each { |l| l.invalidate }
-    end
-
-    #
-    # @return [FixNum] total number of nodes
-    #
-    def nr_nodes
-      nr = @leaves.length + @children.length
-      @children.inject(nr) { |sum, c| sum + c.nr_nodes }
-    end
-
-    #
-    # @return [FixNum] total number of leaves
-    #
-    def nr_leaves
-      @leaves.length + @children.inject(0) { |sum, child| sum + child.nr_leaves }
-    end
-
-    #
-    # @return [FixNum] total number of children
-    #
-    def nr_children
-      @children.length + @children.inject(0) { |sum, child| sum + child.nr_children }
-    end
-
-    #
-    # Add a Leaf
-    # @param [LeafNode]
-    #
-    # @return self
-    #
-    def add_leaf(leaf)
-      return if leaf.parent == self
-      if not leaf.parent.nil?
-        leaf.remove_from_parent
-      end
-      leaf.parent = self
-      if @leaves.length > 0
-        @leaves.last.next = leaf
-        leaf.prev         = @leaves.last
-      else
-        leaf.prev = nil
-      end
-      leaf.next = nil
-      leaf.invalidate
-      @leaves << leaf
-      self
-    end
-
-    #
-    # Add a Tree
-    # @param [LeafNode]
-    #
-    # @return self
-    #
-    def add_child(tree_node)
-      return if tree_node.parent == self
-      if not tree_node.parent.nil?
-        tree_node.remove_from_parent
-      else
-        tree_node.prefix_path = nil
-      end
-      tree_node.invalidate
-      tree_node.parent = self
-      if @children.length > 0
-        @children.last.next = tree_node
-        tree_node.prev      = @children.last
-      else
-        tree_node.prev = nil
-      end
-      tree_node.next = nil
-      @children << tree_node
-      self
-    end
-
-    #
-    # Find a node down the hierarchy with content
-    # @param [Object,Regexp] content of searched node
-    # @return [Object, nil] nil if not found
-    #
-    def find(content = nil, &block)
-      if content and block_given?
-        raise "TreeNode::find - passed content AND block"
-      end
-
-      if content
-        if content.class == Regexp
-          block = proc { |l| l.content =~ content }
-        else
-          block = proc { |l| l.content == content }
-        end
-      end
-      return self if block.call(self)
-
-      leaf = @leaves.find { |l| block.call(l) }
-      return leaf if leaf
-
-      @children.each do |child|
-        node = child.find &block
-        return node if node
-      end
-      nil
-    end
-
-    #
-    # return the visitor
-    #
-    def accept(visitor)
-      visitor.enter_node(self)
-      @leaves.each { |leaf|
-        leaf.accept(visitor)
-      }
-      @children.each { |child|
-        child.accept(visitor)
-      }
-      visitor.exit_node(self)
-      visitor
-    end
-
-    #
-    # Format the content of tree
-    #
-    def to_str(prefix= "")
-      str = ""
-
-      if root?
-        str << to_s << "\n"
-      else
-        str << prefix
-        if self.next
-          str << '|-- '
-        else
-          str << '`-- '
-        end
-        str << to_s << "\n"
-        prefix += self.next ? "|   " : "    "
-      end
-
-      @leaves.each do |leaf|
-        str << prefix
-        if !leaf.next.nil? or !@children.empty?
-          str << '|-- '
-        else
-          str << '`-- '
-        end
-        str << leaf.to_s << "\n"
-      end
-
-      @children.each do |child|
-        str << child.to_str(prefix)
-      end
-      str
-    end
-
-  end
-end

data/lib/treevisitor/tree_node_visitor.rb

@@ -1,119 +0,0 @@
-# -*- coding: utf-8 -*-
-module TreeVisitor
-
-  #
-  # More complex TreeNodeVisitor, define a simple dsl
-  # @example
-  #   TreeNodeVisitor.new do
-  #     on_enter_node do |node|
-  #       puts "hello #{node}"
-  #     end
-  #     on_exit_node do |node|
-  #       puts "bye #{node}"
-  #     end
-  #     on_leaf do |leaf|
-  #       puts "how you do #{leaf}"
-  #     end
-  #   end
-  #
-  class TreeNodeVisitor
-
-    def initialize(delegate = nil, &block)
-      @on_enter_tree_node_blocks = []
-      @on_exit_tree_node_blocks  = []
-      @on_visit_leaf_node_blocks = []
-      @stack                     = []
-      @root                      = nil
-      @delegate                  = delegate
-      if block
-        instance_eval(&block)
-      end
-    end
-
-    #
-    # called on tree node at start of the visit i.e. we start to visit the subtree
-    #
-    def enter_node(tree_node)
-      parent = @stack.last
-      if @delegate
-        @delegate.enter_node(tree_node) if @delegate.respond_to? :enter_node
-      else
-        @on_enter_tree_node_blocks.each do |b|
-          if b.arity == 1
-            b.call(tree_node)
-          elsif b.arity == 2
-            b.call(tree_node, parent)
-          end
-        end
-      end
-      @root = tree_node if @stack.empty?
-      @stack.push(tree_node)
-    end
-
-    #
-    # called on tree node at end of the visit i.e. oll subtree are visited
-    #
-    def exit_node(tree_node)
-      parent = @stack.last
-      if @delegate
-        @delegate.exit_node(tree_node) if @delegate.respond_to? :exit_node
-      else
-        @on_exit_tree_node_blocks.each do |b|
-          if b.arity == 1
-            b.call(tree_node)
-          elsif b.arity == 2
-            b.call(tree_node, parent)
-          end
-        end
-      end
-      @stack.pop
-    end
-
-    #
-    # called when visit leaf node
-    #
-    def visit_leaf(leaf_node)
-      parent = @stack.last
-      if @delegate
-        @delegate.visit_leaf(leaf_node) if @delegate.respond_to? :visit_leaf
-      else
-        @on_visit_leaf_node_blocks.each do |b|
-          if b.arity == 1
-            b.call(leaf_node)
-          elsif b.arity == 2
-            b.call(leaf_node, parent)
-          end
-        end
-      end
-    end
-
-    #
-    # add a block to be called when entering into a tree_node
-    #
-    def on_enter_node(&block)
-      raise "already defined a delegate" if @delegate
-      raise "block missing" unless block
-      @on_enter_tree_node_blocks << block
-    end
-
-    #
-    # add a block to be called when exiting from a TreeNode
-    #
-    def on_exit_node(&block)
-      raise "already defined a delegate" if @delegate
-      raise "block missing" unless block
-      @on_exit_tree_node_blocks << block
-    end
-
-    #
-    # add a block to be called when visiting a leaf node
-    #
-    def on_leaf(&block)
-      raise "already defined a delegate" if @delegate
-      raise "block missing" unless block
-      @on_visit_leaf_node_blocks << block
-    end
-
-  end
-
-end

data/lib/treevisitor/util/dir_processor.rb

@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-module TreeVisitor
-
-  #
-  # Visit a directory tree
-  # not TreeNode related
-  #
-  class DirProcessor
-
-    def initialize( &action )
-      @processors = {}
-      @default_processor = action
-    end
-
-    def add_processor( re, &action )
-      @processors[ re ] = action
-    end
-
-    def process( dirname )
-      @dirname = dirname
-      old_dirname = Dir.pwd
-      Dir.chdir( @dirname )
-      Dir["**/*"].each { |f|
-        pn = Pathname.new( f ).expand_path
-        # puts "#{self.class.name}#loadfromdir #{f}"
-        next if pn.directory?
-        process_file( pn )
-      }
-      Dir.chdir( old_dirname )
-      self
-    end
-
-    private
-  
-    def process_file( pn )
-      # puts "file: #{f}"
-      pair = @processors.find { |re,action| re =~ pn.to_s }
-      unless pair.nil?
-        pair[1].call( pn )
-      else
-        @default_processor.call( pn ) if @default_processor
-      end
-    end
-
-  end
-end