path_tree 1.0.11

data/README.rdoc

@@ -0,0 +1,11 @@
+= PathTree
+
+This gem provides support for creating tree data structures. The structure of the tree is defined with dot delimited paths on each node. This has a couple of advantages over the +acts_as_tree+ plugin.
+
+1. Each node gets a unique character identifier that has semantic qualities and indicates the structure in the tree.
+
+2. Queries for all ancestors or all descendants are far more efficient. 
+
+3. Out of the box the code works with ActiveRecord, but it can easily be made to work with other ORM's if they implement just a few methods.
+
+See PathTree for more details.

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'rake'
+
+desc 'Default: run unit tests'
+task :default => :test
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
+rescue LoadError
+  task :test do
+    raise "You must have rspec 2.0 installed to run the tests"
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "path_tree"
+    gem.summary = %Q{Helper module for constructing tree data structures}
+    gem.description = %Q{Module that defines a tree data structure based on a path.}
+    gem.authors = ["Brian Durand"]
+    gem.email = ["mdobrota@tribune.com", "ddpr@tribune.com"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile", "License.txt"].to_a
+    gem.has_rdoc = true
+    gem.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+    gem.extra_rdoc_files = ["README.rdoc"]
+    gem.add_dependency('activerecord')
+    gem.add_development_dependency('rspec', '>= 2.0.0')
+    gem.add_development_dependency('sqlite3')
+    gem.add_development_dependency('activerecord')
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+rescue LoadError
+end

data/lib/path_tree.rb

@@ -0,0 +1,248 @@
+# This module implements a tree structure by using a convention of converting a name into a path.
+# Paths created by normalizing a name attribute and then separating levels with periods with
+# the lowest level coming last.
+#
+# In order to use this module, the model must respond to the +first+ and +all+ methods like ActiveRecord,
+# have support for after_destroy and after_save callbacks, validates_* macros and include attributes
+# for name, node_path, path, and parent_path.
+module PathTree  
+  if RUBY_VERSION.match(/^1\.8/)
+    require File.expand_path("../ruby_18_patterns.rb", __FILE__)
+  else
+    require File.expand_path("../ruby_19_patterns.rb", __FILE__)
+  end
+  include Patterns
+
+  def self.included (base)
+    base.extend(ClassMethods)
+    
+    base.validates_uniqueness_of :path
+    base.validates_uniqueness_of :node_path, :scope => :parent_path
+    base.validates_presence_of :name, :node_path, :path
+    
+    base.after_save do |record|
+      if record.path_changed? and !record.path_was.nil?
+        record.children.each do |child|
+          child.update_attributes(:parent_path => record.path)
+        end
+      end
+      record.instance_variable_set(:@children, nil)
+    end
+    
+    base.after_destroy do |record|
+      record.children.each do |child|
+        child.update_attributes(:parent_path => record.parent_path)
+      end
+    end
+  end
+
+  module ClassMethods
+    include Patterns
+    
+    NON_WORD_PATTERN = /[^a-z0-9_]+/.freeze
+    DASH_AT_START_PATTERN = /^-+/.freeze
+    DASH_AT_END_PATTERN = /-+$/.freeze
+    
+    # Get all the root nodes (i.e. those without any parents)
+    def roots
+      all(:conditions => {:parent_path => nil})
+    end
+    
+    # Set the path delimiter (default is '.').
+    def path_delimiter= (char)
+      @path_delimiter = char
+    end
+    
+    def path_delimiter
+      @path_delimiter ||= '.'
+    end
+    
+    # Load the entire branch of the tree under path at once. If you will be traversing the
+    # tree, this is the fastest way to load it. Returns the root node of the branch.
+    def branch (path)
+      raise ArgumentError.new("branch path must not be blank") if path.blank?
+      root = first(:conditions => {:path => path})
+      return [] unless root
+      nodes = path_like(path).sort{|a,b| b.path <=> a.path}
+      nodes << root
+      return populate_tree_structure!(nodes.pop, nodes)
+    end
+    
+    # Translate a value into a valid path part. By default this will translate it into an ascii
+    # lower case value with words delimited by dashes. Implementations can override this logic.
+    def pathify (value)
+      if value
+        asciify(unquote(value)).strip.downcase.gsub(NON_WORD_PATTERN, '-').gsub(DASH_AT_START_PATTERN, '').gsub(DASH_AT_END_PATTERN, '')
+      end
+    end
+    
+    # Replace accented characters with the closest ascii equivalent
+    def asciify (value)
+      if value
+        value.gsub(UPPER_A_PATTERN, 'A').gsub(LOWER_A_PATTERN, 'a').
+          gsub(UPPER_E_PATTERN, 'E').gsub(LOWER_E_PATTERN, 'e').
+          gsub(UPPER_I_PATTERN, 'I').gsub(LOWER_I_PATTERN, 'i').
+          gsub(UPPER_O_PATTERN, 'O').gsub(LOWER_O_PATTERN, 'o').
+          gsub(UPPER_U_PATTERN, 'U').gsub(LOWER_U_PATTERN, 'u').
+          gsub(UPPER_Y_PATTERN, 'Y').gsub(LOWER_Y_PATTERN, 'y').
+          gsub(UPPER_N_PATTERN, 'N').gsub(LOWER_N_PATTERN, 'n').
+          gsub(UPPER_C_PATTERN, 'C').gsub(LOWER_C_PATTERN, 'c').
+          gsub(UPPER_AE_PATTERN, 'AE').gsub(LOWER_AE_PATTERN, 'ae').
+          gsub(SS_PATTERN, 'ss').gsub(UPPER_D_PATTERN, 'D')
+      end
+    end
+    
+    # Remove quotation marks from a string.
+    def unquote (value)
+      value.gsub(/['"]/, '') if value
+    end
+    
+    # Abstract way of finding paths that start with a value so it can be overridden by non-SQL implementations.
+    def path_like (value)
+      all(:conditions => ["path LIKE ?", "#{value}#{path_delimiter}%"])
+    end
+    
+    # Expand a path into an array of the path and all its ancestor paths.
+    def expanded_paths (path)
+      expanded = []
+      path.split(path_delimiter).each do |part|
+        if expanded.empty?
+          expanded << part
+        else
+          expanded << "#{expanded.last}#{path_delimiter}#{part}"
+        end
+      end
+      expanded
+    end
+    
+    private
+    
+    def populate_tree_structure! (root, sorted_nodes)
+      while !sorted_nodes.empty? do
+        node = sorted_nodes.last
+        if node.parent_path == root.path
+          sorted_nodes.pop
+          node.parent = root
+          root.send(:append_child, node)
+        else
+          last_child = root.children.last
+          if last_child and node.parent_path == last_child.path
+            populate_tree_structure!(last_child, sorted_nodes)
+          else
+            break
+          end
+        end
+      end
+      return root
+    end
+  end
+  
+  # Get the full name of a node including the names of all it's parent nodes. Specify the separator string to use
+  # between values with :separator (defaults to " > "). You can also specify the context for the full name by
+  # specifying a path in :context. This will only render the names up to and not including that part of the tree.
+  def full_name (options = {})
+    separator = options[:separator] || " > "
+    n = ""
+    n << parent.full_name(options) if parent_path and parent_path != options[:context]
+    n << separator unless n.blank?
+    n << name
+  end
+  
+  def path_delimiter
+    self.class.path_delimiter
+  end
+
+  # Get the parent node.
+  def parent
+    unless instance_variable_defined?(:@parent)
+      if path.index(path_delimiter)
+        @parent = self.class.base_class.first(:conditions => {:path => parent_path})
+      else
+        @parent = nil
+      end
+    end
+    @parent
+  end
+  
+  # Set the parent node.
+  def parent= (node)
+    node_path = node.path if node
+    self.parent_path = node_path unless parent_path == node_path
+    @parent = node
+  end
+  
+  # Set the parent path
+  def parent_path= (value)
+    unless value == parent_path
+      self[:parent_path] = value
+      recalculate_path
+      remove_instance_variable(:@parent) if instance_variable_defined?(:@parent)
+    end
+    value
+  end
+  
+  def name= (value)
+    unless value == name
+      self[:name] = value
+      self.node_path = value if node_path.blank?
+    end
+    value
+  end
+  
+  def node_path= (value)
+    pathified = self.class.pathify(value)
+    self[:node_path] = pathified
+    recalculate_path
+  end
+  
+  # Get all nodes that are direct children of this node.
+  def children
+    unless @children
+      childrens_path = new_record? ? path : path_was
+      @children = self.class.base_class.all(:conditions => {:parent_path => childrens_path})
+      @children.each{|c| c.parent = self}
+    end
+    @children
+  end
+
+  # Get all nodes that share the same parent as this node.
+  def siblings
+    self.class.base_class.all(:conditions => {:parent_path => parent_path}).reject{|node| node == self}
+  end
+
+  # Get all descendant of this node.
+  def descendants
+    self.class.base_class.path_like(path)
+  end
+
+  # Get all ancestors of this node with the root node first.
+  def ancestors
+    ancestor_paths = expanded_paths
+    ancestor_paths.pop
+    if ancestor_paths.empty?
+      []
+    else
+      self.class.base_class.all(:conditions => {:path => ancestor_paths}).sort{|a,b| a.path.length <=> b.path.length}
+    end
+  end
+
+  # Returns an array containing the paths of this node and those of all its ancestors.
+  def expanded_paths
+    self.class.expanded_paths(path)
+  end
+  
+  protected
+  
+  def append_child (node)
+    @children ||= []
+    @children << node
+    node.parent = self
+  end
+  
+  def recalculate_path
+    path = ""
+    path << "#{parent_path}#{path_delimiter}" unless parent_path.blank?
+    path << node_path if node_path
+    self.path = path
+  end
+end

data/lib/ruby_18_patterns.rb

@@ -0,0 +1,24 @@
+module PathTree
+  module Patterns
+    UPPER_A_PATTERN = /\xC3[\x80-\x85]/.freeze
+    LOWER_A_PATTERN = /\xC3[\xA0-\xA5]/.freeze
+    UPPER_E_PATTERN = /\xC3[\x88-\x8B]/.freeze
+    LOWER_E_PATTERN = /\xC3[\xA8-\xAB]/.freeze
+    UPPER_I_PATTERN = /\xC3[\x8C-\x8F]/.freeze
+    LOWER_I_PATTERN = /\xC3[\xAC-\xAF]/.freeze
+    UPPER_O_PATTERN = /\xC3[\x92-\x96\x98]/.freeze
+    LOWER_O_PATTERN = /\xC3[\xB2-\xB6\xB8]/.freeze
+    UPPER_U_PATTERN = /\xC3[\x99-\x9C]/.freeze
+    LOWER_U_PATTERN = /\xC3[\xB9-\xBC]/.freeze
+    UPPER_Y_PATTERN = /\xC3\x9D/.freeze
+    LOWER_Y_PATTERN = /\xC3[\xBD\xBF]/.freeze
+    UPPER_C_PATTERN = /\xC3\x87/.freeze
+    LOWER_C_PATTERN = /\xC3\xA7/.freeze
+    UPPER_N_PATTERN = /\xC3\x91/.freeze
+    LOWER_N_PATTERN = /\xC3\xB1/.freeze
+    UPPER_D_PATTERN = /\xC3\x90/.freeze
+    UPPER_AE_PATTERN = /\xC3\x86/.freeze
+    LOWER_AE_PATTERN = /\xC3\xA6/.freeze
+    SS_PATTERN = /\xC3\x9F/.freeze
+  end
+end

data/lib/ruby_19_patterns.rb

@@ -0,0 +1,24 @@
+module PathTree
+  module Patterns
+    UPPER_A_PATTERN = /[\xC3\x80-\xC3\x85]/u.freeze
+    LOWER_A_PATTERN = /[\xC3\xA0-\xC3\xA5]/u.freeze
+    UPPER_E_PATTERN = /[\xC3\x88-\xC3\x8B]/u.freeze
+    LOWER_E_PATTERN = /[\xC3\xA8-\xC3\xAB]/u.freeze
+    UPPER_I_PATTERN = /[\xC3\x8C-\xC3\x8F]/u.freeze
+    LOWER_I_PATTERN = /[\xC3\xAC-\xC3\xAF]/u.freeze
+    UPPER_O_PATTERN = /[\xC3\x92-\xC3\x96\xC3\x98]/u.freeze
+    LOWER_O_PATTERN = /[\xC3\xB2-\xC3\xB6\xC3\xB8]/u.freeze
+    UPPER_U_PATTERN = /[\xC3\x99-\xC3\x9C]/u.freeze
+    LOWER_U_PATTERN = /[\xC3\xB9-\xC3\xBC]/u.freeze
+    UPPER_Y_PATTERN = /\xC3\x9D/u.freeze
+    LOWER_Y_PATTERN = /[\xC3\xBD\xC3\xBF]/u.freeze
+    UPPER_C_PATTERN = /\xC3\x87/u.freeze
+    LOWER_C_PATTERN = /\xC3\xA7/u.freeze
+    UPPER_N_PATTERN = /\xC3\x91/u.freeze
+    LOWER_N_PATTERN = /\xC3\xB1/u.freeze
+    UPPER_D_PATTERN = /\xC3\x90/u.freeze
+    UPPER_AE_PATTERN = /\xC3\x86/u.freeze
+    LOWER_AE_PATTERN = /\xC3\xA6/u.freeze
+    SS_PATTERN = /\xC3\x9F/u.freeze
+  end
+end

data/spec/path_tree_spec.rb

@@ -0,0 +1,276 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe PathTree do
+  
+  module PathTree
+    class Test < ActiveRecord::Base
+      self.table_name = :test_path_trees
+      
+      def self.create_tables
+        connection.create_table(table_name) do |t|
+          t.string :name
+          t.string :node_path
+          t.string :path
+          t.string :parent_path
+        end unless table_exists?
+      end
+
+      def self.drop_tables
+        connection.drop_table(table_name)
+      end
+      
+      include PathTree
+    end
+  end
+
+  before :all do
+    PathTree::Test.create_tables
+  end
+
+  after :all do
+    PathTree::Test.drop_tables
+  end
+  
+  context "path construction" do
+    it "should turn accented characters into ascii equivalents" do
+      PathTree::Test.asciify("ÀÂÄÃÅàâáããä-ÈÊÉËèêéë-ÌÎÍÏìîíï-ÒÔÖØÓÕòôöøóõ-ÚÜÙÛúüùû-ÝýÿÑñÇçÆæßÐ").should == "AAAAAaaaaaa-EEEEeeee-IIIIiiii-OOOOOOoooooo-UUUUuuuu-YyyNnCcAEaessD"
+    end
+
+    it "should unquote strings" do
+      PathTree::Test.unquote(%Q("This is a 'test'")).should == "This is a test"
+    end
+
+    it "should translate a value to a path part" do
+      PathTree::Test.pathify("This is the 1st / test À...").should == "this-is-the-1st-test-a"
+    end
+
+    it "should expand a path to its component paths" do
+      PathTree::Test.expanded_paths("this.is.a.test").should == ["this", "this.is", "this.is.a", "this.is.a.test"]
+    end
+    
+    it "should set the parent path when setting the parent" do
+      parent = PathTree::Test.new(:name => "parent")
+      node = PathTree::Test.new(:name => "child")
+      node.parent = parent
+      node.parent_path.should == "parent"
+      node.parent = nil
+      node.parent_path.should == nil
+    end
+  end
+  
+  context "with default delimiter" do
+    before :all do
+      @root_1 = PathTree::Test.create!(:name => "Root 1")
+      @parent_a = PathTree::Test.create!(:name => "Parent A", :parent_path => "root-1")
+      @parent_b = PathTree::Test.create!(:name => "Parent B", :parent_path => "root-1")
+      @parent_c = PathTree::Test.create!(:name => "Parent C", :parent_path => "root-1")
+      @child_a1 = PathTree::Test.create!(:name => "Child A1", :parent_path => "root-1.parent-a")
+      @child_a2 = PathTree::Test.create!(:name => "Child A2", :parent_path => "root-1.parent-a")
+      @grandchild = PathTree::Test.create!(:name => "Grandchild A1.1", :parent_path => "root-1.parent-a.child-a1")
+      @root_2 = PathTree::Test.create!(:name => "Root 2")
+      @parent_z = PathTree::Test.create!(:name => "Parent Z", :parent_path => "root-2")
+    end
+
+    after :all do
+      PathTree::Test.delete_all
+    end
+
+    it "should get the root nodes" do
+      PathTree::Test.roots.sort{|a,b| a.path <=> b.path}.should == [@root_1, @root_2]
+    end
+
+    it "should load an entire branch structure" do
+      branch = PathTree::Test.branch("root-1.parent-a")
+      branch.should == @parent_a
+      branch.instance_variable_get(:@children).should == [@child_a1, @child_a2]
+      branch.children.first.instance_variable_get(:@children).should == [@grandchild]
+    end
+
+    it "should construct a fully qualified name with a delimiter" do
+      @grandchild.full_name.should == "Root 1 > Parent A > Child A1 > Grandchild A1.1"
+      @grandchild.full_name(:separator => "/").should == "Root 1/Parent A/Child A1/Grandchild A1.1"
+      @grandchild.full_name(:context => "root-1.parent-a").should == "Child A1 > Grandchild A1.1"
+    end
+
+    it "should be able to get and set a parent node" do
+      node = PathTree::Test.find_by_path("root-1.parent-a")
+      node.parent.should == @root_1
+      node.parent = @root_2
+      node.parent_path.should == "root-2"
+      node.path.should == "root-2.parent-a"
+    end
+
+    it "should be able to set the parent by path" do
+      node = PathTree::Test.find_by_path("root-1.parent-a")
+      node.parent_path = "root-2"
+      node.parent.should == @root_2
+      node.path.should == "root-2.parent-a"
+    end
+
+    it "should have child nodes" do
+      node = PathTree::Test.find_by_path("root-1.parent-a")
+      node.children.should == [@child_a1, @child_a2]
+    end
+
+    it "should have descendant nodes" do
+      node = PathTree::Test.find_by_path("root-1.parent-a")
+      node.descendants.should == [@child_a1, @child_a2, @grandchild]
+    end
+
+    it "should have sibling nodes" do
+      node = PathTree::Test.find_by_path("root-1.parent-a")
+      node.siblings.should == [@parent_b, @parent_c]
+    end
+
+    it "should have ancestor nodes" do
+      node = PathTree::Test.find_by_path("root-1.parent-a.child-a1")
+      node.ancestors.should == [@root_1, @parent_a]
+    end
+
+    it "should maintain the path with the name path" do
+      node = PathTree::Test.find_by_path("root-1.parent-a")
+      node.node_path = "New Name"
+      node.path.should == "root-1.new-name"
+    end
+
+    it "should get the expanded paths for a node" do
+      @grandchild.expanded_paths.should == ["root-1", "root-1.parent-a", "root-1.parent-a.child-a1", "root-1.parent-a.child-a1.grandchild-a1-1"]
+    end
+
+    it "should update child paths when the path is changed" do
+      PathTree::Test.transaction do
+        node = PathTree::Test.find_by_path("root-1.parent-a")
+        node.node_path = "New Name"
+        node.save!
+        node.reload
+        node.children.collect{|c| c.path}.should == ["root-1.new-name.child-a1", "root-1.new-name.child-a2"]
+        node.children.first.children.collect{|c| c.path}.should == ["root-1.new-name.child-a1.grandchild-a1-1"]
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    it "should update child paths when a node is destroyed" do
+      PathTree::Test.transaction do
+        node = PathTree::Test.find_by_path("root-1.parent-a")
+        node.name = "New Name"
+        node.destroy
+        root = PathTree::Test.find_by_path("root-1")
+        root.children.collect{|c| c.path}.should == ["root-1.parent-b", "root-1.parent-c", "root-1.child-a1", "root-1.child-a2"]
+        root.children[2].children.collect{|c| c.path}.should == ["root-1.child-a1.grandchild-a1-1"]
+        raise ActiveRecord::Rollback
+      end
+    end
+  end
+
+  
+  context "with default delimiter" do
+    before :all do
+      PathTree::Test.path_delimiter = '/'
+      @root_1 = PathTree::Test.create!(:name => "Root 1")
+      @parent_a = PathTree::Test.create!(:name => "Parent A", :parent_path => "root-1")
+      @parent_b = PathTree::Test.create!(:name => "Parent B", :parent_path => "root-1")
+      @parent_c = PathTree::Test.create!(:name => "Parent C", :parent_path => "root-1")
+      @child_a1 = PathTree::Test.create!(:name => "Child A1", :parent_path => "root-1/parent-a")
+      @child_a2 = PathTree::Test.create!(:name => "Child A2", :parent_path => "root-1/parent-a")
+      @grandchild = PathTree::Test.create!(:name => "Grandchild A1.1", :parent_path => "root-1/parent-a/child-a1")
+      @root_2 = PathTree::Test.create!(:name => "Root 2")
+      @parent_z = PathTree::Test.create!(:name => "Parent Z", :parent_path => "root-2")
+    end
+
+    after :all do
+      PathTree::Test.path_delimiter = nil
+    end
+
+    it "should get the root nodes" do
+      PathTree::Test.roots.sort{|a,b| a.path <=> b.path}.should == [@root_1, @root_2]
+    end
+
+    it "should load an entire branch structure" do
+      branch = PathTree::Test.branch("root-1/parent-a")
+      branch.should == @parent_a
+      branch.instance_variable_get(:@children).should == [@child_a1, @child_a2]
+      branch.children.first.instance_variable_get(:@children).should == [@grandchild]
+    end
+
+    it "should construct a fully qualified name with a delimiter" do
+      @grandchild.full_name.should == "Root 1 > Parent A > Child A1 > Grandchild A1.1"
+      @grandchild.full_name(:separator => ":").should == "Root 1:Parent A:Child A1:Grandchild A1.1"
+      @grandchild.full_name(:context => "root-1/parent-a").should == "Child A1 > Grandchild A1.1"
+    end
+
+    it "should be able to get and set a parent node" do
+      node = PathTree::Test.find_by_path("root-1/parent-a")
+      node.parent.should == @root_1
+      node.parent = @root_2
+      node.parent_path.should == "root-2"
+      node.path.should == "root-2/parent-a"
+    end
+
+    it "should be able to set the parent by path" do
+      node = PathTree::Test.find_by_path("root-1/parent-a")
+      node.parent_path = "root-2"
+      node.parent.should == @root_2
+      node.path.should == "root-2/parent-a"
+    end
+
+    it "should have child nodes" do
+      node = PathTree::Test.find_by_path("root-1/parent-a")
+      node.children.should == [@child_a1, @child_a2]
+    end
+
+    it "should have descendant nodes" do
+      node = PathTree::Test.find_by_path("root-1/parent-a")
+      node.descendants.should == [@child_a1, @child_a2, @grandchild]
+    end
+
+    it "should have sibling nodes" do
+      node = PathTree::Test.find_by_path("root-1/parent-a")
+      node.siblings.should == [@parent_b, @parent_c]
+    end
+
+    it "should have ancestor nodes" do
+      node = PathTree::Test.find_by_path("root-1/parent-a/child-a1")
+      node.ancestors.should == [@root_1, @parent_a]
+    end
+
+    it "should maintain the path with the name path" do
+      node = PathTree::Test.find_by_path("root-1/parent-a")
+      node.node_path = "New Name"
+      node.path.should == "root-1/new-name"
+    end
+
+    it "should get the expanded paths for a node" do
+      @grandchild.expanded_paths.should == ["root-1", "root-1/parent-a", "root-1/parent-a/child-a1", "root-1/parent-a/child-a1/grandchild-a1-1"]
+    end
+
+    it "should update child paths when the path is changed" do
+      PathTree::Test.transaction do
+        node = PathTree::Test.find_by_path("root-1/parent-a")
+        node.node_path = "New Name"
+        node.save!
+        node.reload
+        node.children.collect{|c| c.path}.should == ["root-1/new-name/child-a1", "root-1/new-name/child-a2"]
+        node.children.first.children.collect{|c| c.path}.should == ["root-1/new-name/child-a1/grandchild-a1-1"]
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    it "should update child paths when a node is destroyed" do
+      begin
+      PathTree::Test.transaction do
+        node = PathTree::Test.find_by_path("root-1/parent-a")
+        node.name = "New Name"
+        node.destroy
+        root = PathTree::Test.find_by_path("root-1")
+        root.children.collect{|c| c.path}.should == ["root-1/parent-b", "root-1/parent-c", "root-1/child-a1", "root-1/child-a2"]
+        root.children[2].children.collect{|c| c.path}.should == ["root-1/child-a1/grandchild-a1-1"]
+        raise ActiveRecord::Rollback
+      end
+    rescue
+      puts $@.join("\n")
+    end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'active_record'
+require 'sqlite3'
+
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError
+  # simplecov not installed
+end
+
+ActiveRecord::Base.establish_connection("adapter" => "sqlite3", "database" => ":memory:")
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'path_tree'))