acts_as_sane_tree 2.0 → 2.0.1

data/acts_as_sane_tree.gemspec

@@ -19,6 +19,9 @@ README.rdoc
 CHANGELOG.rdoc
 lib/acts_as_sane_tree.rb
 lib/acts_as_sane_tree/version.rb
+lib/acts_as_sane_tree/acts_as_sane_tree.rb
+lib/acts_as_sane_tree/singleton_methods.rb
+lib/acts_as_sane_tree/instance_methods.rb
 rails/init.rb
 }
 end

data/lib/acts_as_sane_tree/acts_as_sane_tree.rb

@@ -0,0 +1,67 @@
+require 'active_record'
+require 'acts_as_sane_tree/instance_methods'
+require 'acts_as_sane_tree/singleton_methods.rb'
+
+module ActsAsSaneTree
+  
+  def self.included(base) # :nodoc:
+    base.extend(ClassMethods)
+  end
+
+  # Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children
+  # association. This requires that you have a foreign key column, which by default is called +parent_id+.
+  #
+  #   class Category < ActiveRecord::Base
+  #     acts_as_sane_tree :order => "name"
+  #   end
+  #
+  #   Example:
+  #   root
+  #    \_ child1
+  #         \_ subchild1
+  #         \_ subchild2
+  #
+  #   root      = Category.create("name" => "root")
+  #   child1    = root.children.create("name" => "child1")
+  #   subchild1 = child1.children.create("name" => "subchild1")
+  #
+  #   root.parent   # => nil
+  #   child1.parent # => root
+  #   root.children # => [child1]
+  #   root.children.first.children.first # => subchild1
+  #
+  # The following class methods are also added:
+  # 
+  # * <tt>nodes_within?(src, chk)</tt> - Returns true if chk contains any nodes found within src and all ancestors of nodes within src
+  # * <tt>nodes_within(src, chk)</tt> - Returns any matching nodes from chk found within src and all ancestors within src
+  # * <tt>nodes_and_descendents(*args)</tt> - Returns all nodes and descendents for given IDs or records. Accepts multiple IDs and records. Valid options:
+  #   * :raw - No Hash nesting
+  #   * :no_self - Will not return given nodes in result set
+  #   * {:depth => n} - Will set maximum depth to query
+  #   * {:to_depth => n} - Alias for :depth
+  #   * {:at_depth => n} - Will return times at given depth (takes precedence over :depth/:to_depth)
+  module ClassMethods
+    # Configuration options are:
+    #
+    # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+)
+    # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
+    # * <tt>counter_cache</tt> - keeps a count in a +children_count+ column if set to +true+ (default: +false+).
+    def acts_as_sane_tree(options = {})
+      @configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil, :max_depth => 10000, :class => self }
+      @configuration.update(options) if options.is_a?(Hash)
+
+      class_eval do
+        cattr_accessor :configuration
+        belongs_to :parent, :class_name => name, :foreign_key => @configuration[:foreign_key], :counter_cache => @configuration[:counter_cache]
+        has_many :children, :class_name => name, :foreign_key => @configuration[:foreign_key], :order => @configuration[:order], :dependent => :destroy
+        
+        validates_each @configuration[:foreign_key] do |record, attr, value|
+          record.errors.add attr, 'cannot be own parent.' if !record.id.nil? && value.to_i == record.id.to_i
+        end
+      end
+      self.configuration = @configuration
+      include ActsAsSaneTree::InstanceMethods
+      extend ActsAsSaneTree::SingletonMethods
+    end
+  end
+end

data/lib/acts_as_sane_tree/instance_methods.rb

@@ -0,0 +1,114 @@
+module ActsAsSaneTree
+  module InstanceMethods
+
+    # Returns all ancestors of the current node. 
+    def ancestors
+      query = 
+        "(WITH RECURSIVE crumbs AS (
+          SELECT #{self.class.configuration[:class].table_name}.*,
+          1 AS depth
+          FROM #{self.class.configuration[:class].table_name}
+          WHERE id = #{id} 
+          UNION ALL
+          SELECT alias1.*, 
+          depth + 1 
+          FROM crumbs
+          JOIN #{self.class.configuration[:class].table_name} alias1 ON alias1.id = crumbs.parent_id
+        ) SELECT * FROM crumbs WHERE crumbs.id != #{id}) as #{self.class.configuration[:class].table_name}"
+      if(self.class.rails_3?)
+        self.class.configuration[:class].send(:with_exclusive_scope) do
+          self.class.configuration[:class].from(
+            query
+          ).order("#{self.class.configuration[:class].table_name}.depth DESC")
+        end
+      else
+        self.class.configuration[:class].send(:with_exclusive_scope) do
+          self.class.configuration[:class].scoped(
+            :from => query,
+            :order => "#{self.class.configuration[:class].table_name}.depth DESC"
+          )
+        end
+      end
+    end
+
+    # Returns the root node of the tree.
+    def root
+      ancestors.first
+    end
+
+    # Returns all siblings of the current node.
+    #
+    #   subchild1.siblings # => [subchild2]
+    def siblings
+      self_and_siblings - [self]
+    end
+
+    # Returns all siblings and a reference to the current node.
+    #
+    #   subchild1.self_and_siblings # => [subchild1, subchild2]
+    def self_and_siblings
+      parent ? parent.children : self.class.configuration[:class].roots
+    end
+    
+    # Returns if the current node is a root
+    def root?
+      parent_id.nil?
+    end
+    
+    # Returns all descendents of the current node. Each level
+    # is within its own hash, so for a structure like:
+    #   root
+    #    \_ child1
+    #         \_ subchild1
+    #               \_ subsubchild1
+    #         \_ subchild2
+    # the resulting hash would look like:
+    # 
+    #  {child1 => 
+    #    {subchild1 => 
+    #      {subsubchild1 => {}},
+    #     subchild2 => {}}}
+    #
+    # This method will accept two parameters.
+    #   * :raw -> Result is scope that can more finders can be chained against with additional 'level' attribute
+    #   * {:depth => n} -> Will only search for descendents to the given depth of n
+    # NOTE: You can restrict results by depth on the scope returned, but better performance will be
+    # gained by specifying it within the args so it will be applied during the recursion, not after.
+    def descendents(*args)
+      args.delete_if{|x| !x.is_a?(Hash) && x != :raw}
+      self.class.configuration[:class].nodes_and_descendents(:no_self, self, *args)
+    end
+    
+    # Returns the depth of the current node. 0 depth represents the root of the tree
+    def depth
+      query = 
+        "(WITH RECURSIVE crumbs AS (
+          SELECT parent_id, 0 AS depth
+          FROM #{self.class.configuration[:class].table_name}
+          WHERE id = #{id} 
+          UNION ALL
+          SELECT alias1.parent_id, level + 1 
+          FROM crumbs
+          JOIN #{self.class.configuration[:class].table_name} alias1 ON alias1.id = crumbs.parent_id
+        ) SELECT depth FROM crumbs) as #{self.class.configuration[:class].table_name}"
+      if(self.class.rails_3?)
+        self.class.configuration[:class].send(:with_exclusive_scope) do
+          self.class.configuration[:class].from(
+            query
+          ).order(
+            "#{self.class.configuration[:class].table_name}.depth DESC"
+          ).limit(1).try(:first).try(:depth)
+        end
+      else
+        self.class.configuration[:class].send(:with_exclusive_scope) do
+          self.class.configuration[:class].find(
+            :first,
+            :from => query,
+            :order => "#{self.class.configuration[:class].table_name}.depth DESC",
+            :limit => 1
+          ).try(:depth)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_sane_tree/singleton_methods.rb

@@ -0,0 +1,157 @@
+module ActsAsSaneTree
+  module SingletonMethods
+    
+    # Check if we are in rails 3
+    def rails_3?
+      @is_3 ||= Rails.version.split('.').first == '3'
+    end
+
+    # Return all root nodes
+    def roots
+      if(rails_3?)
+        configuration[:class].where(
+          "#{configuration[:foreign_key]} IS NULL"
+        ).order(configuration[:order])
+      else
+        configuration[:class].scoped(
+          :conditions => "#{configuration[:foreign_key]} IS NULL",
+          :order => configuration[:order]
+        )
+      end
+    end
+
+    # Return first root node
+    def root
+      if(rails_3?)
+        configuration[:class].where("#{configuration[:foriegn_key]} IS NULL").order(configuration[:order]).first
+      else
+        configuration[:class].find(
+          :first, 
+          :conditions => "#{configuration[:foreign_key]} IS NULL", 
+          :order => configuration[:order]
+        )
+      end
+    end
+
+    # src:: Array of nodes
+    # chk:: Array of nodes
+    # Return true if any nodes within chk are found within src
+    def nodes_within?(src, chk)
+      s = (src.is_a?(Array) ? src : [src]).map{|x|x.is_a?(ActiveRecord::Base) ? x.id : x.to_i}
+      c = (chk.is_a?(Array) ? chk : [chk]).map{|x|x.is_a?(ActiveRecord::Base) ? x.id : x.to_i}
+      if(s.empty? || c.empty?)
+        false
+      else
+        q = configuration[:class].connection.select_all(
+          "WITH RECURSIVE crumbs AS (
+            SELECT #{configuration[:class].table_name}.*, 0 AS level FROM #{configuration[:class].table_name} WHERE id in (#{s.join(', ')})
+            UNION ALL
+            SELECT alias1.*, crumbs.level + 1 FROM crumbs JOIN #{configuration[:class].table_name} alias1 on alias1.parent_id = crumbs.id
+          ) SELECT count(*) as count FROM crumbs WHERE id in (#{c.join(', ')})"
+        )
+        q.first['count'].to_i > 0
+      end
+    end
+
+    # src:: Array of nodes
+    # chk:: Array of nodes
+    # Return all nodes that are within both chk and src
+    def nodes_within(src, chk)
+      s = (src.is_a?(Array) ? src : [src]).map{|x|x.is_a?(ActiveRecord::Base) ? x.id : x.to_i}
+      c = (chk.is_a?(Array) ? chk : [chk]).map{|x|x.is_a?(ActiveRecord::Base) ? x.id : x.to_i}
+      if(s.empty? || c.empty?)
+        nil
+      else
+        query = 
+          "(WITH RECURSIVE crumbs AS (
+            SELECT #{configuration[:class].table_name}.*, 0 AS depth FROM #{configuration[:class].table_name} WHERE id in (\#{s.join(', ')})
+            UNION ALL
+            SELECT alias1.*, crumbs.depth + 1 FROM crumbs JOIN #{configuration[:class].table_name} alias1 on alias1.parent_id = crumbs.id
+            #{configuration[:max_depth] ? "WHERE crumbs.depth + 1 < #{configuration[:max_depth].to_i}" : ''}
+          ) SELECT * FROM crumbs WHERE id in (#{c.join(', ')})) as #{configuration[:class].table_name}"
+        if(rails_3?)
+          configuration[:class].from(query)
+        else
+          configuration[:class].scoped(:from => query)
+        end
+      end
+    end
+    
+    # args:: ActiveRecord models or IDs - Symbols: :raw, :no_self - Hash: {:to_depth => n, :at_depth => n}
+    # Returns provided nodes plus all descendents of provided nodes in nested Hash where keys are nodes and values are children
+    # :raw:: return value will be flat array
+    # :no_self:: Do not include provided nodes in result
+    # Hash:
+    #   :to_depth:: Only retrieve values to given depth
+    #   :at_depth:: Only retrieve values from given depth
+    def nodes_and_descendents(*args)
+      raw = args.delete(:raw)
+      no_self = args.delete(:no_self)
+      at_depth = nil
+      depth = nil
+      hash = args.detect{|x|x.is_a?(Hash)}
+      if(hash)
+        args.delete(hash)
+        depth = hash[:depth] || hash[:to_depth]
+        at_depth = hash[:at_depth]
+      end
+      depth ||= configuration[:max_depth].to_i
+      depth_restriction = "WHERE crumbs.depth + 1 < #{depth}" if depth
+      depth_clause = nil
+      if(at_depth)
+        depth_clause = "#{configuration[:class].table_name}.depth + 1 = #{at_depth.to_i}"
+      elsif(depth)
+        depth_clause = "#{configuration[:class].table_name}.depth + 1 < #{depth.to_i}"
+      end
+      base_ids = args.map{|x| x.is_a?(ActiveRecord::Base) ? x.id : x.to_i}
+      query = 
+        "(WITH RECURSIVE crumbs AS (
+          SELECT #{configuration[:class].table_name}.*, #{no_self ? -1 : 0} AS depth FROM #{configuration[:class].table_name} WHERE #{base_ids.empty? ? 'parent_id IS NULL' : "id in (#{base_ids.join(', ')})"}
+          UNION ALL
+          SELECT alias1.*, crumbs.depth + 1 FROM crumbs JOIN #{configuration[:class].table_name} alias1 on alias1.parent_id = crumbs.id
+          #{depth_restriction}
+        ) SELECT * FROM crumbs) as #{configuration[:class].table_name}"
+      q = nil
+      if(rails_3?)
+        with_exclusive_scope do
+          q = configuration[:class].from(
+            query
+          ).where(
+            "#{configuration[:class].table_name}.depth >= 0"
+          )
+          if(depth_clause)
+            q = q.where(depth_clause)
+          end
+          q = q.order("#{configuration[:class].table_name}.depth ASC, #{configuration[:class].table_name}.parent_id ASC")
+        end
+      else
+        with_exclusive_scope do
+          q = configuration[:class].scoped(
+            :from => query, 
+            :conditions => "#{configuration[:class].table_name}.depth >= 0",
+            :order => "#{configuration[:class].table_name}.depth ASC, #{configuration[:class].table_name}.parent_id ASC"
+          )
+          if(depth_clause)
+            q = q.scoped(:conditions => depth_clause)
+          end
+        end
+      end
+      unless(raw)
+        res = {}
+        cache = {}
+        q.all.each do |item|
+          cache[item.id] = {}
+          if(cache[item.parent_id])
+            cache[item.parent_id][item] = cache[item.id]
+          else
+            res[item] = cache[item.id]
+          end
+        end
+        res
+      else
+        q
+      end
+    end
+
+  end
+end

data/lib/acts_as_sane_tree/version.rb

@@ -1,3 +1,3 @@
 module ActsAsSaneTree
-  VERSION = '2.0'
+  VERSION = '2.0.1'
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_sane_tree
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 13
   prerelease: 
   segments: 
   - 2
   - 0
-  version: "2.0"
+  - 1
+  version: 2.0.1
 platform: ruby
 authors: 
 - Chris Roberts
@@ -46,6 +47,9 @@ files:
 - CHANGELOG.rdoc
 - lib/acts_as_sane_tree.rb
 - lib/acts_as_sane_tree/version.rb
+- lib/acts_as_sane_tree/acts_as_sane_tree.rb
+- lib/acts_as_sane_tree/singleton_methods.rb
+- lib/acts_as_sane_tree/instance_methods.rb
 - rails/init.rb
 has_rdoc: true
 homepage: http://github.com/chrisroberts/acts_as_sane_tree