ordered_tree 0.1.1

data/lib/ordered_tree/instance_methods/tree.rb

@@ -0,0 +1,169 @@
+module OrderedTree
+  module InstanceMethods
+    module Tree
+      ## Tree Read Methods
+
+      # returns the top node in the object's tree
+      #
+      #   return is cached, unless nil
+      #   use root(true) to force a reload
+      def root(reload = false)
+        reload = true if !@root
+        reload ? find_root : @root
+      end
+
+      # returns an array of ancestors, starting from parent until root.
+      #   return is cached
+      #   use ancestors(true) to force a reload
+      def ancestors(reload = false)
+        reload = true if !@ancestors
+        reload ? find_ancestors : @ancestors
+      end
+
+      # returns object's parent in the tree
+      #   auto-loads itself on first access
+      #   instead of returning "<parent_node not loaded yet>"
+      #
+      #   return is cached, unless nil
+      #   use parent(true) to force a reload
+      def parent(reload=false)
+        reload = true if !@parent
+        reload ? parent_node(true) : @parent
+      end
+
+      # returns an array of the object's immediate children
+      #   auto-loads itself on first access
+      #   instead of returning "<child_nodes not loaded yet>"
+      #
+      #   return is cached
+      #   use children(true) to force a reload
+      def children(reload=false)
+        reload = true if !@children
+        reload ? child_nodes(true) : @children
+      end
+
+      # returns an array of the object's descendants
+      #
+      #   return is cached
+      #   use descendants(true) to force a reload
+      def descendants(reload = false)
+        @descendants = nil if reload
+        reload = true if !@descendants
+        reload ? find_descendants(self) : @descendants
+      end
+
+      ## Tree Update Methods
+
+      # shifts a node to another parent, optionally specifying it's position
+      #   (descendants will follow along)
+      #
+      #   shift_to()
+      #     defaults to the bottom of the "roots" list
+      #
+      #   shift_to(nil, new_sibling)
+      #     will move the item to "roots",
+      #     and position the item above new_sibling
+      #
+      #   shift_to(new_parent)
+      #     will move the item to the new parent,
+      #     and position at the bottom of the parent's list
+      #
+      #   shift_to(new_parent, new_sibling)
+      #     will move the item to the new parent,
+      #     and position the item above new_sibling
+      #
+      def shift_to(new_parent = nil, new_sibling = nil)
+        if new_parent
+          ok = new_parent.children(true) << self
+        else
+          ok = orphan
+        end
+        if ok && new_sibling
+          ok = move_above(new_sibling) if self_and_siblings(true).include?(new_sibling)
+        end
+        return ok
+      end
+
+      # orphans the node (sends it to the roots list)
+      #   (descendants follow)
+      def orphan
+        self[foreign_key_column] = 0
+        self.save
+      end
+
+      # orphans the node's children
+      #   sends all immediate children to the 'roots' list
+      def orphan_children
+        self.class.transaction do
+          children(true).each{|child| child.orphan}
+        end
+      end
+
+      # hands children off to parent
+      #   if no parent, children will be orphaned
+      def parent_adopts_children
+        if parent(true)
+          self.class.transaction do
+            children(true).each{|child| parent.children << child}
+          end
+        else
+          orphan_children
+        end
+      end
+
+      # sends self and immediate children to the roots list
+      def orphan_self_and_children
+        self.class.transaction do
+          orphan_children
+          orphan
+        end
+      end
+
+      # hands children off to parent (if possible), then orphans itself
+      def orphan_self_and_parent_adopts_children
+        self.class.transaction do
+          parent_adopts_children
+          orphan
+        end
+      end
+    end
+
+    protected
+
+    def check_parentage #:nodoc:
+      if !self_and_siblings(true).include?(self)
+        if self.parent == self
+          errors.add(:base, "cannot be a parent to itself.")
+        elsif (self.parent && self.descendants(true).include?(self.parent))
+          errors.add(:base, "is an ancestor of the new parent.")
+        end
+      end
+    end
+
+    private
+
+    def find_root
+      node = self
+      node = node.parent while node.parent(true)
+      node
+    end
+
+    def find_ancestors
+      node, nodes = self, []
+      nodes << node = node.parent while node.parent(true)
+      nodes
+    end
+
+    # recursive method
+    def find_descendants(node)
+      @descendants ||= []
+      node.children(true).each do |child|
+        @descendants << child
+        find_descendants(child)
+      end
+      @descendants
+    end
+
+  end
+end
+

data/lib/ordered_tree/instance_methods.rb

@@ -0,0 +1,13 @@
+require 'ordered_tree/instance_methods/tree'
+require 'ordered_tree/instance_methods/list'
+require 'ordered_tree/instance_methods/destroy'
+require 'ordered_tree/instance_methods/misc'
+
+module OrderedTree
+  module InstanceMethods
+    include OrderedTree::InstanceMethods::Tree
+    include OrderedTree::InstanceMethods::List
+    include OrderedTree::InstanceMethods::Destroy
+    include OrderedTree::InstanceMethods::Misc
+  end 
+end

data/lib/ordered_tree.rb

@@ -0,0 +1,33 @@
+require 'ordered_tree/class_methods'
+require 'ordered_tree/instance_methods'
+
+module OrderedTree #:nodoc:
+  # Configuration:
+  #
+  #   class Person < ActiveRecord::Base
+  #     ordered_tree :foreign_key   => :parent_id,
+  #                  :order         => :position
+  #   end
+  #
+  #   class CreatePeople < ActiveRecord::Migration
+  #     def self.up
+  #       create_table :people do |t|
+  #         t.column :parent_id ,:integer ,:null => false ,:default => 0
+  #         t.column :position  ,:integer
+  #       end
+  #       add_index(:people, :parent_id)
+  #     end
+  #   end
+
+  def ordered_tree(options = {})
+    cattr_accessor :ordered_tree_config
+    self.ordered_tree_config ||= {}
+    self.ordered_tree_config[:foreign_key] ||= :parent_id
+    self.ordered_tree_config[:order] ||= :position
+    self.ordered_tree_config.update(options) if options.is_a?(Hash)
+    include OrderedTree::ClassMethods
+    include OrderedTree::InstanceMethods
+  end #ordered_tree
+end #module OrderedTree
+
+ActiveRecord::Base.extend OrderedTree

data/ordered_tree.gemspec

@@ -0,0 +1,85 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ordered_tree}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ramon Tayag"]
+  s.date = %q{2011-06-03}
+  s.description = %q{Uses parent_id and position to create an ordered tree.}
+  s.email = %q{ramon@tayag.net}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc",
+    "README.textile"
+  ]
+  s.files = [
+    ".rvmrc",
+    "CHANGELOG",
+    "Gemfile",
+    "Gemfile.lock",
+    "Guardfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "README.textile",
+    "Rakefile",
+    "VERSION",
+    "lib/ordered_tree.rb",
+    "lib/ordered_tree/class_methods.rb",
+    "lib/ordered_tree/instance_methods.rb",
+    "lib/ordered_tree/instance_methods/destroy.rb",
+    "lib/ordered_tree/instance_methods/list.rb",
+    "lib/ordered_tree/instance_methods/misc.rb",
+    "lib/ordered_tree/instance_methods/tree.rb",
+    "ordered_tree.gemspec",
+    "spec/fixtures/person.rb",
+    "spec/ordered_tree_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ramontayag/ordered_tree}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Gem version of Wizard's ActsAsTree}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<guard-rspec>, [">= 0"])
+      s.add_development_dependency(%q<libnotify>, [">= 0"])
+      s.add_development_dependency(%q<rb-inotify>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 3.0.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<guard-rspec>, [">= 0"])
+      s.add_dependency(%q<libnotify>, [">= 0"])
+      s.add_dependency(%q<rb-inotify>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 3.0.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<guard-rspec>, [">= 0"])
+    s.add_dependency(%q<libnotify>, [">= 0"])
+    s.add_dependency(%q<rb-inotify>, [">= 0"])
+  end
+end
+

data/spec/fixtures/person.rb

@@ -0,0 +1,3 @@
+class Person < ActiveRecord::Base
+  ordered_tree
+end