hyrarchy 0.3.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 The Indianapolis Star
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,69 @@
+= Hyrarchy
+
+Hyrarchy (Hybrid hieRarchy) is a gem and Rails plugin for working with hierarchic data in ActiveRecord. Your models gain methods for finding an instance's parent, children, ancestors, descendants, and depth, as well as a named scope for finding root nodes.
+
+To use Hyrarchy in your Rails app, copy the plugin from the gem into your app's vendors/plugins directory. (The plugin is just a two-liner that loads and activates the gem.)
+
+To use Hyrarchy in one of your models, add the following line to the class:
+
+  class Comment < ActiveRecord::Base
+    is_hierarchic
+  end
+
+Then add the hierarchic columns to the model's database table:
+
+  class MakeCommentsHierarchic < ActiveRecord::Migration
+    def self.up
+      add_hierarchy :comments
+    end
+    
+    def self.down
+      remove_hierarchy :comments
+    end
+  end
+
+Or you can put it in the same migration as the table's creation:
+
+  class CreateCommentsTable < ActiveRecord::Migration
+    def self.up
+      create_table :comments do |t|
+        t.integer :author_id
+        t.text :body
+      end
+      add_hierarchy :comments
+    end
+    
+    def self.down
+      drop_table :comments
+    end
+  end
+
+== Performance
+
+On MySQL, Hyrarchy scales to at least one million nodes with insertion and access times below 100ms. On SQLite, times are below 200ms.
+
+== Database Compatibility
+
+Hyrarchy has been tested on MySQL 5 and SQLite 3.
+
+== Replacing awesome_nested_set
+
+Hyrarchy is designed to be an almost-drop-in replacement for awesome_nested_set. All of awesome_nested_set's methods are implemented by Hyrarchy, but you'll need to replace calls to acts_as_nested_set with is_hierarchic. You'll also need to replace awesome_nested_set's database columns with Hyrarchy's, which you can do with an option to the add_hierarchy migration method:
+
+  add_hierarchy :comments, :convert => :awesome_nested_set
+
+The convert option will modify the table structure but it won't rebuild the hierarchy information. You can rebuild it by calling rebuild! on your hierarchic model class:
+
+  Comment.rebuild!
+
+The same option can be used with remove_hierarchy for the down half of a migration.
+
+Hyrarchy doesn't yet support awesome_nested_set's scoping feature or its view helper.
+
+== Implementation Details
+
+Under the hood, Hyrarchy uses a combination of an adjacency list and a rational nested set. The nested set uses a technique developed by (I think) Vadim Tropashko, in which the left and right values are generated using Farey sequences. This makes it possible to insert new records without adjusting the left and right values of any other records. It also makes it possible to do many operations (like determining a record's depth in the tree) without accessing the database. For operations where rational nested sets perform poorly (such as finding a node's immediate descendants), the adjacency list is used.
+
+== Credits and Copyright
+
+Heavily based on works by Vadim Tropashko and Wim Lewis. Implemented by Dana Danger. Tolerated by VivaZoya. Copyright (c) 2008 The Indianapolis Star, released under the MIT license. See LICENSE for details.

data/lib/hyrarchy.rb

@@ -0,0 +1,321 @@
+require 'hyrarchy/encoded_path'
+require 'hyrarchy/collection_proxy'
+require 'hyrarchy/awesome_nested_set_compatibility'
+
+module Hyrarchy
+  # Fudge factor to account for imprecision with floating point approximations
+  # of a node's left and right fractions.
+  FLOAT_FUDGE_FACTOR = 0.00000000001 # :nodoc:
+  
+  # Mixes Hyrarchy into ActiveRecord.
+  def self.activate!
+    ActiveRecord::Base.extend IsHierarchic
+    ActiveRecord::Migration.extend Migrations
+  end
+  
+  # These methods are available in ActiveRecord migrations for adding and
+  # removing columns and indexes required by Hyrarchy.
+  module Migrations
+    def add_hierarchy(table, options = {})
+      convert = options.delete(:convert)
+      unless options.empty?
+        raise(ArgumentError, "unknown keys: #{options.keys.join(', ')}")
+      end
+      
+      case convert
+      when :awesome_nested_set
+        remove_column table, :lft
+        remove_column table, :rgt
+      when '', nil
+      else
+        raise(ArgumentError, "don't know how to convert hierarchy from #{convert}")
+      end
+      
+      add_column table, :lft,       :float
+      add_column table, :rgt,       :float
+      add_column table, :lft_numer, :integer
+      add_column table, :lft_denom, :integer
+      add_column table, :parent_id, :integer unless convert == :awesome_nested_set
+      add_index table, :lft
+      add_index table, [:lft_numer, :lft_denom], :unique => true
+      add_index table, :parent_id
+    end
+    
+    def remove_hierarchy(table, options = {})
+      convert = options.delete(:convert)
+      unless options.empty?
+        raise(ArgumentError, "unknown keys: #{options.keys.join(', ')}")
+      end
+      
+      remove_column table, :lft
+      remove_column table, :rgt
+      remove_column table, :lft_numer
+      remove_column table, :lft_denom
+      remove_column table, :parent_id, :integer unless convert == :awesome_nested_set
+      
+      case convert
+      when :awesome_nested_set
+        add_column table, :lft, :integer
+        add_column table, :rgt, :integer
+      when '', nil
+      else
+        raise(ArgumentError, "don't know how to convert hierarchy to #{convert}")
+      end
+    end
+  end
+  
+  module IsHierarchic
+    # Declares that a model represents hierarchic data. Adds a has_many
+    # association for instances' children, and a named scope for the model's
+    # root nodes (called +roots+).
+    def is_hierarchic
+      extend ClassMethods
+      include InstanceMethods
+      
+      has_many :children,
+        :foreign_key => 'parent_id',
+        :order       => 'rgt DESC, lft',
+        :class_name  => self.to_s,
+        :dependent   => :destroy
+      
+      before_save :set_encoded_paths
+      before_save :set_parent_id
+      after_save :update_descendant_paths
+      after_save :reset_flags
+      
+      named_scope :roots,
+        :conditions => { :parent_id => nil },
+        :order      => 'rgt DESC, lft'
+    end
+  end
+  
+  # These private methods are available to model classes that have been
+  # declared is_hierarchic. They're used internally and aren't intended to be
+  # used by application developers.
+  module ClassMethods # :nodoc:
+    include Hyrarchy::AwesomeNestedSetCompatibility::ClassMethods
+    
+  private
+    
+    # Finds the first unused child path beneath +parent_path+.
+    def next_child_encoded_path(parent_path)
+      if parent_path == Hyrarchy::EncodedPath::ROOT
+        if sibling = roots.last
+          child_path = sibling.send(:encoded_path).next_sibling
+        else
+          child_path = Hyrarchy::EncodedPath::ROOT.first_child
+        end
+      else
+        node = find_by_encoded_path(parent_path)
+        child_path = node ?
+          node.send(:next_child_encoded_path) : parent_path.first_child
+      end
+      while self.exists?(:lft_numer => child_path.numerator, :lft_denom => child_path.denominator)
+        child_path = child_path.next_sibling
+      end
+      child_path
+    end
+    
+    # Returns the node with the specified encoded path.
+    def find_by_encoded_path(p)
+      find(:first, :conditions => {
+        :lft_numer => p.numerator,
+        :lft_denom => p.denominator
+      })
+    end
+  end
+  
+  # These methods are available to instances of models that have been declared
+  # is_hierarchic.
+  module InstanceMethods
+    include Hyrarchy::AwesomeNestedSetCompatibility::InstanceMethods
+    
+    # Returns this node's parent, or +nil+ if this is a root node.
+    def parent
+      return @new_parent if @new_parent
+      p = encoded_path.parent
+      return nil if p.nil?
+      self.class.send(:find_by_encoded_path, p)
+    end
+    
+    # Sets this node's parent. To make this node a root node, set its parent to
+    # +nil+.
+    def parent=(other)
+      @make_root = false
+      if other.nil?
+        @new_parent = nil
+        @make_root = true
+      elsif encoded_path && other.encoded_path == (encoded_path.parent rescue nil)
+        @new_parent = nil
+      else
+        @new_parent = other
+      end
+      other
+    end
+    
+    # Returns an array of this node's descendants: its children, grandchildren,
+    # and so on. The array returned by this method is a named scope.
+    def descendants
+      cached[:descendants] ||=
+        self_and_descendants.scoped :conditions => "id <> #{id}"
+    end
+    
+    # Returns an array of this node's ancestors--its parent, grandparent, and
+    # so on--ordered from parent to root. The array returned by this method is
+    # a has_many association, so you can do things like this:
+    #
+    #   node.ancestors.find(:all, :conditions => { ... })
+    #
+    def ancestors(with_self = false)
+      cache_key = with_self ? :self_and_ancestors : :ancestors
+      return cached[cache_key] if cached[cache_key]
+      
+      paths = []
+      path = with_self ? encoded_path : encoded_path.parent
+      while path do
+        paths << path
+        path = path.parent
+      end
+      
+      cached[cache_key] = CollectionProxy.new(
+        self,
+        cache_key,
+        :conditions => paths.empty? ? "id <> id" : [
+          paths.collect {|p| "(lft_numer = ? AND lft_denom = ?)"}.join(" OR "),
+          *(paths.collect {|p| [p.numerator, p.denominator]}.flatten)
+        ],
+        :order => 'rgt, lft DESC'
+      )
+    end
+    
+    # Returns the root node related to this node, or nil if this node is a root
+    # node.
+    def root
+      return cached[:root] if cached[:root]
+      
+      path = encoded_path.parent
+      while path do
+        parent = path.parent
+        break if parent.nil?
+        path = parent
+      end
+      
+      if path
+        self.class.send :find_by_encoded_path, path
+      else
+        nil
+      end
+    end
+    
+    # Returns the number of nodes between this one and the top of the tree.
+    def depth
+      encoded_path.depth - 1
+    end
+    
+    # Overrides ActiveRecord's reload method to clear cached scopes and ad hoc
+    # associations.
+    def reload(options = nil) # :nodoc:
+      @cached = {}
+      reset_flags
+      super
+    end
+
+  protected
+    
+    # Sets the node's encoded path, updating all relevant database columns to
+    # match.
+    def encoded_path=(r) # :nodoc:
+      @cached = {}
+      if r.nil?
+        self.lft_numer = nil
+        self.lft_denom = nil
+        self.lft = nil
+        self.rgt = nil
+      else
+        @path_has_changed = true
+        self.lft_numer = r.numerator
+        self.lft_denom = r.denominator
+        self.lft = r.to_f
+        self.rgt = encoded_path.next_farey_fraction.to_f
+      end
+      r
+    end
+    
+    # Returns the node's encoded path (its rational left value).
+    def encoded_path # :nodoc:
+      return nil if lft_numer.nil? || lft_denom.nil?
+      Hyrarchy::EncodedPath(lft_numer, lft_denom)
+    end
+    
+    # Returns a hash for caching scopes and ad hoc associations.
+    def cached # :nodoc:
+      @cached ||= {}
+    end
+    
+    # Returns the first unused child path under this node.
+    def next_child_encoded_path
+      return nil unless encoded_path
+      if children.empty?
+        encoded_path.first_child
+      else
+        children.last.send(:encoded_path).next_sibling
+      end
+    end
+    
+  private
+    
+    # before_save callback to ensure that this node's encoded path is a child
+    # of its parent.
+    def set_encoded_paths # :nodoc:
+      @path_has_changed = false if @path_has_changed.nil?
+      p = nil
+      self.lft_numer = self.lft_denom = nil if @make_root
+      
+      if @new_parent.nil?
+        if lft_numer.nil? || lft_denom.nil?
+          p = Hyrarchy::EncodedPath::ROOT
+        end
+      else
+        p = @new_parent.encoded_path
+      end
+      
+      if p
+        new_path = self.class.send(:next_child_encoded_path, p)
+        if @path_has_changed = (encoded_path != new_path)
+          self.encoded_path = new_path
+        end
+      end
+      
+      true
+    end
+    
+    # before_save callback to ensure that this node's parent_id attribute
+    # agrees with its encoded path.
+    def set_parent_id # :nodoc:
+      parent = self.class.send(:find_by_encoded_path, encoded_path.parent(false))
+      self.parent_id = parent ? parent.id : nil
+      true
+    end
+    
+    # after_save callback to ensure that this node's descendants are updated if
+    # this node has moved.
+    def update_descendant_paths # :nodoc:
+      return true unless @path_has_changed
+      children.reload if children.loaded? && children.empty?
+      
+      child_path = encoded_path.first_child
+      children.each do |c|
+        c.encoded_path = child_path
+        c.save!
+        child_path = child_path.next_sibling
+      end
+      
+      true
+    end
+    
+    # Resets internal flags after saving.
+    def reset_flags # :nodoc:
+      @path_has_changed = @new_parent = @make_root = nil
+    end
+  end
+end

data/lib/hyrarchy/awesome_nested_set_compatibility.rb

@@ -0,0 +1,375 @@
+module Hyrarchy
+  module AwesomeNestedSetCompatibility
+    module ClassMethods
+      # Returns the first root node.
+      def root
+        roots.first
+      end
+
+      # Returns true if the model's left and right values are valid, and all
+      # root nodes have no ancestors.
+      def valid?
+        left_and_rights_valid? && all_roots_valid?
+      end
+
+      # Returns true if the model's left and right values match the parent_id
+      # attributes.
+      def left_and_rights_valid?
+        # Load all nodes and index them by ID so we can leave the database
+        # alone.
+        nodes = connection.select_all("SELECT id, lft_numer, lft_denom, parent_id FROM #{quoted_table_name}")
+        nodes_by_id = {}
+        nodes.each do |node|
+          node['id']           = node['id'].to_i
+          node['encoded_path'] = Hyrarchy::EncodedPath(node['lft_numer'].to_i, node['lft_denom'].to_i)
+          node['parent_id']    = node['parent_id'] ? node['parent_id'].to_i : nil
+          nodes_by_id[node['id']] = node
+        end
+        # Check to see if the structure defined by the nodes' encoded paths
+        # matches the structure defined by their parent_id attributes.
+        nodes.all? do |node|
+          if node['parent_id'].nil?
+            node['encoded_path'].parent == nil rescue false
+          else
+            parent = nodes_by_id[node['parent_id']]
+            parent && node['encoded_path'].parent == parent['encoded_path']
+          end
+        end
+      end
+
+      # Always returns true. This method exists solely for compatibility with
+      # awesome_nested_set; the test it performs doesn't apply to Hyrarchy.
+      def no_duplicates_for_columns?
+        true
+      end
+
+      # Returns true if all roots have no ancestors.
+      def all_roots_valid?
+        each_root_valid?(roots)
+      end
+
+      # Returns true if all of the nodes in +roots_to_validate+ have no
+      # ancestors.
+      def each_root_valid?(roots_to_validate)
+        roots_to_validate.all? {|r| r.root?}
+      end
+
+      # Rebuilds the model's hierarchy attributes based on the parent_id
+      # attributes.
+      def rebuild!
+        return true if (valid? rescue false)
+        
+        update_all("lft = id, rgt = id, lft_numer = id, lft_denom = id")
+        paths_by_id = {}
+        order_by = columns_hash['created_at'] ? :created_at : :id
+        
+        nodes = roots :order => order_by
+        until nodes.empty? do
+          nodes.each do |node|
+            parent_path = paths_by_id[node.parent_id] || Hyrarchy::EncodedPath::ROOT
+            node.send(:encoded_path=, next_child_encoded_path(parent_path))
+            node.send(:create_or_update_without_callbacks) || raise(RecordNotSaved)
+            paths_by_id[node.id] = node.send(:encoded_path)
+          end
+          node_ids = nodes.collect {|n| n.id}
+          nodes = find(:all, :conditions => { :parent_id => node_ids }, :order => order_by)
+        end
+      end
+    end
+    
+    module InstanceMethods
+      # Returns this node's left value. Records that haven't yet been saved
+      # won't have left values.
+      def left
+        encoded_path
+      end
+
+      # Returns this node's left value. Records that haven't yet been saved
+      # won't have right values.
+      def right
+        encoded_path && encoded_path.next_farey_fraction
+      end
+
+      # Returns true if this is a root node.
+      def root?
+        (encoded_path.nil? || depth == 0 || @make_root) && !@new_parent
+      end
+
+      # Returns true if this node has no children.
+      def leaf?
+        children.empty?
+      end
+
+      # Returns true if this node is a child of another node.
+      def child?
+        !root?
+      end
+
+      # Compares two nodes by their left values.
+      def <=>(x)
+        x.left <=> left
+      end
+
+      # Returns an array containing this node and its ancestors, starting with
+      # this node and ending with its root. The array returned by this method
+      # is a has_many association, so you can do things like this:
+      #
+      #   node.self_and_ancestors.find(:all, :conditions => { ... })
+      #
+      def self_and_ancestors
+        ancestors(true)
+      end
+
+      # Returns an array containing this node and its siblings. The array
+      # returned by this method is a has_many association, so you can do things
+      # like this:
+      #
+      #   node.self_and_siblings.find(:all, :conditions => { ... })
+      #
+      def self_and_siblings
+        siblings(true)
+      end
+
+      # Returns an array containing this node's siblings. The array returned by
+      # this method is a has_many association, so you can do things like this:
+      #
+      #   node.siblings.find(:all, :conditions => { ... })
+      #
+      def siblings(with_self = false)
+        cache_key = with_self ? :self_and_siblings : :siblings
+        return cached[cache_key] if cached[cache_key]
+
+        if with_self
+          conditions = { :parent_id => parent_id }
+        else
+          conditions = ["parent_id #{parent_id.nil? ? 'IS' : '='} ? AND id <> ?",
+            parent_id, id]
+        end
+
+        cached[cache_key] = self.class.scoped(
+          :conditions => conditions,
+          :order      => 'rgt DESC, lft'
+        )
+      end
+
+      # Returns an array containing this node's childless descendants. The
+      # array returned by this method is a named scope.
+      def leaves
+        cached[:leaves] ||= descendants.scoped :conditions => "NOT EXISTS (
+          SELECT * FROM #{self.class.quoted_table_name} tt
+          WHERE tt.parent_id = #{self.class.quoted_table_name}.id
+        )"
+      end
+
+      # Alias for depth.
+      def level
+        depth
+      end
+
+      # Returns an array of this node and its descendants: its children,
+      # grandchildren, and so on. The array returned by this method is a
+      # has_many association, so you can do things like this:
+      #
+      #   node.self_and_descendants.find(:all, :conditions => { ... })
+      #
+      def self_and_descendants
+        cached[:self_and_descendants] ||= CollectionProxy.new(
+          self,
+          :descendants,
+          :conditions => { :lft => (lft - FLOAT_FUDGE_FACTOR)..(rgt + FLOAT_FUDGE_FACTOR) },
+          :order => 'rgt DESC, lft',
+          # The query conditions intentionally load extra records that aren't
+          # descendants to account for floating point imprecision. This
+          # procedure removes the extra records.
+          :after => Proc.new do |records|
+            r = encoded_path.next_farey_fraction
+            records.delete_if do |n|
+              n.encoded_path < encoded_path || n.encoded_path >= r
+            end
+          end,
+          # The regular count method doesn't work because of the fudge factor
+          # in the conditions. This procedure uses the length of the records
+          # array if it's been loaded. Otherwise it does a raw SQL query (to
+          # avoid the expense of instantiating a bunch of ActiveRecord objects)
+          # and prunes the results in the same manner as the :after procedure.
+          :count => Proc.new do
+            if descendants.loaded?
+              descendants.length
+            else
+              rows = self.class.connection.select_all("
+                SELECT lft_numer, lft_denom
+                FROM #{self.class.quoted_table_name}
+                WHERE #{descendants.conditions}")
+              r = encoded_path.next_farey_fraction
+              rows.delete_if do |row|
+                p = Hyrarchy::EncodedPath(
+                  row['lft_numer'].to_i,
+                  row['lft_denom'].to_i)
+                p < encoded_path || p >= r
+              end
+              rows.length
+            end
+          end,
+          # Associations don't normally have an optimized index method, but
+          # this one does. :)
+          :index => Proc.new do |obj|
+            rows = self.class.connection.select_all("
+              SELECT id, lft_numer, lft_denom
+              FROM #{self.class.quoted_table_name}
+              WHERE #{descendants.conditions}
+              ORDER BY rgt DESC, lft")
+            r = encoded_path.next_farey_fraction
+            rows.delete_if do |row|
+              p = Hyrarchy::EncodedPath(
+                row['lft_numer'].to_i,
+                row['lft_denom'].to_i)
+              row.delete('lft_numer')
+              row.delete('lft_denom')
+              p < encoded_path || p >= r
+            end
+            rows.index({'id' => obj.id.to_s})
+          end
+        )
+      end
+
+      # Returns true if this node is a descendant of +other+.
+      def is_descendant_of?(other)
+        left > other.left && left <= other.right
+      end
+
+      # Returns true if this node is a descendant of +other+, or if this node
+      # is +other+.    
+      def is_or_is_descendant_of?(other)
+        left >= other.left && left <= other.right
+      end
+
+      # Returns true if this node is an ancestor of +other+.
+      def is_ancestor_of?(other)
+        other.left > left && other.left <= right
+      end
+
+      # Returns true if this node is an ancestor of +other+, or if this node is
+      # +other+.
+      def is_or_is_ancestor_of?(other)
+        other.left >= left && other.left <= right
+      end
+
+      # Always returns true. This method exists solely for compatibility with
+      # awesome_nested_set; Hyrarchy doesn't support scoping (but maybe it will
+      # some day).
+      def same_scope?(other)
+        true
+      end
+      
+      # Returns the sibling before this node. If this node is its parent's
+      # first child, returns nil.
+      def left_sibling # :nodoc:
+        path = send(:encoded_path)
+        return nil if path == path.parent.first_child
+        sibling_path = path.previous_sibling
+        until self.class.exists?(:lft_numer => sibling_path.numerator, :lft_denom => sibling_path.denominator)
+          sibling_path = sibling_path.previous_sibling
+        end
+        self.class.send(:find_by_encoded_path, sibling_path)
+      end
+
+      # Returns the sibling after this node. If this node is its parent's last
+      # child, returns nil.
+      def right_sibling
+        siblings = root? ? self.class.roots : other.parent.children
+        return nil if self == siblings.last
+        sibling_path = send(:encoded_path).next_sibling
+        until self.class.exists?(:lft_numer => sibling_path.numerator, :lft_denom => sibling_path.denominator)
+          sibling_path = sibling_path.next_sibling
+        end
+        self.class.send(:find_by_encoded_path, sibling_path)
+      end
+
+      def move_left # :nodoc:
+        raise NotImplementedError, "awesome_nested_set's move_left method isn't implemented in this version of Hyrarchy"
+      end
+
+      def move_right # :nodoc:
+        raise NotImplementedError, "awesome_nested_set's move_right method isn't implemented in this version of Hyrarchy"
+      end
+      
+      # The semantics of left and right don't quite map exactly from
+      # awesome_nested_set to Hyrarchy. For the purpose of this method, "left"
+      # means "before."
+      #
+      # If this node isn't a sibling of +other+, its parent will be set to
+      # +other+'s parent.
+      def move_to_left_of(other)
+        # Don't attempt an impossible move.
+        if other.is_descendant_of?(self)
+          raise ArgumentError, "you can't move a node to the left of one of its descendants"
+        end
+        # Find the first unused path after +other+'s path.
+        open_path = other.send(:encoded_path).next_sibling
+        while self.class.exists?(:lft_numer => open_path.numerator, :lft_denom => open_path.denominator)
+          open_path = open_path.next_sibling
+        end
+        # Move +other+, and all nodes following it, down.
+        while open_path != other.send(:encoded_path)
+          p = open_path.previous_sibling
+          n = self.class.send(:find_by_encoded_path, p)
+          n.send(:encoded_path=, open_path)
+          n.save!
+          open_path = p
+        end
+        puts open_path
+        # Insert this node.
+        send(:encoded_path=, open_path)
+        save!
+      end
+
+      # The semantics of left and right don't quite map exactly from
+      # awesome_nested_set to Hyrarchy. For the purpose of this method, "right"
+      # means "after."
+      #
+      # If this node isn't a sibling of +other+, its parent will be set to
+      # +other+'s parent.
+      def move_to_right_of(other)
+        # Don't attempt an impossible move.
+        if other.is_descendant_of?(self)
+          raise ArgumentError, "you can't move a node to the right of one of its descendants"
+        end
+        # If +other+ is its parent's last child, we can simply append this node
+        # to the parent's children.
+        siblings = other.root? ? self.class.roots : other.parent.children
+        if other == siblings.last
+          send(:encoded_path=, other.send(:encoded_path).next_sibling)
+          save!
+        else
+          # Otherwise, this is equivalent to moving this node to the left of
+          # +other+'s right sibling.
+          move_to_left_of(other.right_sibling)
+        end
+      end
+
+      # Sets this node's parent to +node+ and calls save!.
+      def move_to_child_of(node)
+        node = self.class.find(node)
+        self.parent = node
+        save!
+      end
+
+      # Makes this node a root node and calls save!.
+      def move_to_root
+        self.parent = nil
+        save!
+      end
+
+      def move_possible?(target) # :nodoc:
+        raise NotImplementedError, "awesome_nested_set's move_possible? method isn't implemented in this version of Hyrarchy"
+      end
+
+      # Returns a textual representation of this node and its descendants.
+      def to_text
+        self_and_descendants.map do |node|
+          "#{'*'*(node.depth+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
+        end.join("\n")
+      end
+    end
+  end
+end