acts_as_sane_tree 1.0 → 1.1

data/CHANGELOG.rdoc

@@ -0,0 +1,6 @@
+=== v1.1
+* New class method nodes_and_descendents
+* Updated instance method #descendents to call class method nodes_and_descendents
+
+=== v1.0
+* Initial release

data/README.rdoc

@@ -22,8 +22,13 @@ A few extras are provided. Of note are:
 
 * #depth -> depth from root of the current node
 * #descendents -> all descendents of the current node (provided in either flat array or nested hash)
-* nodes_within? -> true if any of the nodes provided in the first parameter are found within the selfs or descendents of the second parameter
-* nodes_within -> same as #nodes_within? but returns array of found nodes
+* nodes_within?(src, chk) - Returns true if chk contains any nodes found within src and all ancestors of nodes within src
+* nodes_within(src, chk) - Returns any matching nodes from chk found within src and all ancestors within src
+* nodes_and_descendents(*args) - Returns all nodes and descendents for given IDs or records.
+
+== Documentation
+
+http://chrisroberts.github.com/acts_as_sane_tree
 
 == Thanks
 

data/acts_as_sane_tree.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
 acts_as_sane_tree.gemspec
 init.rb
 README.rdoc
+CHANGELOG.rdoc
 lib/acts_as_sane_tree.rb
 lib/version.rb
 }

data/lib/acts_as_sane_tree.rb

@@ -1,5 +1,6 @@
 module ActsAsSaneTree
-  def self.included(base)
+  
+  def self.included(base) # :nodoc:
     base.extend(ClassMethods)
   end
 
@@ -25,13 +26,14 @@ module ActsAsSaneTree
   #   root.children # => [child1]
   #   root.children.first.children.first # => subchild1
   #
-  # In addition to the parent and children associations, the following instance methods are added to the class
-  # after calling <tt>acts_as_sane_tree</tt>:
-  # * <tt>siblings</tt> - Returns all the children of the parent, excluding the current node (<tt>[subchild2]</tt> when called on <tt>subchild1</tt>)
-  # * <tt>self_and_siblings</tt> - Returns all the children of the parent, including the current node (<tt>[subchild1, subchild2]</tt> when called on <tt>subchild1</tt>)
-  # * <tt>ancestors</tt> - Returns all the ancestors of the current node (<tt>[child1, root]</tt> when called on <tt>subchild2</tt>)
-  # * <tt>root</tt> - Returns the root of the current node (<tt>root</tt> when called on <tt>subchild2</tt>)
-  # * <tt>nodes_within?(src, chk)</tt> - Returns true if any nodes provided in chk are found within the nodes in src or the descendents of the nodes in chk
+  # 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
   module ClassMethods
     # Configuration options are:
     #
@@ -88,6 +90,40 @@ module ActsAsSaneTree
             )
           end
         end
+        
+        def self.nodes_and_descendents(*args)
+          raw = args.delete(:raw)
+          no_self = args.delete(:no_self)
+          depth = args.detect{|x|x.is_a?(Hash)}
+          if(depth)
+            args.delete(depth)
+            depth = depth[:depth]
+          end
+          base_ids = args.map{|x| x.is_a?(ActiveRecord::Base) ? x.id : x.to_i}
+          q = self.find_by_sql(
+            "WITH RECURSIVE crumbs AS (
+              SELECT #{self.table_name}.*, \#{no_self ? -1 : 0} AS level FROM #{self.table_name} WHERE id in (\#{base_ids.join(', ')})
+              UNION ALL
+              SELECT alias1.*, crumbs.level + 1 FROM crumbs JOIN #{self.table_name} alias1 on alias1.parent_id = crumbs.id
+              \#{depth ? "WHERE crumbs.level + 1 < \#{depth.to_i}" : ''}
+            ) SELECT * FROM crumbs WHERE level >= 0 ORDER BY level, parent_id ASC"
+          )
+          unless(raw)
+            res = {}
+            cache = {}
+            q.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
 
       EOV
     end
@@ -143,45 +179,20 @@ module ActsAsSaneTree
     #         \_ subchild2
     # the resulting hash would look like:
     # 
-    # -> {child1 => 
-    #      {subchild1 => 
-    #        {subsubchild1 => {}},
-    #       subchild2 => {}}}
+    #  {child1 => 
+    #    {subchild1 => 
+    #      {subsubchild1 => {}},
+    #     subchild2 => {}}}
     #
     # This method will accept two parameters.
     #   * :raw -> Result is flat array. No Hash tree is built
     #   * {:depth => n} -> Will only search for descendents to the given depth of n
     def descendents(*args)
-      depth = args.detect{|x|x.is_a?(Hash) && x[:depth]}
-      depth = depth[:depth] if depth
-      raw = args.include?(:raw)
-      q = self.class.find_by_sql(
-        "WITH RECURSIVE crumbs AS (
-          SELECT #{self.class.table_name}.*, -1 AS level FROM #{self.class.table_name} WHERE id = #{id}
-          UNION ALL
-          SELECT alias1.*, crumbs.level + 1 FROM crumbs JOIN #{self.class.table_name} alias1 on alias1.parent_id = crumbs.id
-          #{depth ? "WHERE crumbs.level + 1 < #{depth.to_i}" : ''}
-        ) SELECT * FROM crumbs WHERE level >= 0 ORDER BY level, parent_id ASC"
-      )
-      unless(raw)
-        res = {}
-        cache = {}
-        q.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
+      args.delete_if{|x| !x.is_a?(Hash) && x != :raw}
+      self.class.nodes_and_descendents(:no_self, self, *args)
     end
     
-    # Returns the depth of the current node. 0 depth represents the root
-    # of the tree
+    # Returns the depth of the current node. 0 depth represents the root of the tree
     def depth
       res = self.class.connection.select_all(
         "WITH RECURSIVE crumbs AS (

data/lib/version.rb

@@ -1,3 +1,3 @@
 module ActsAsSaneTree
-  VERSION = '1.0'
+  VERSION = '1.1'
 end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_sane_tree
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 1
-  - 0
-  version: "1.0"
+  - 1
+  version: "1.1"
 platform: ruby
 authors: 
 - Chris Roberts
@@ -43,6 +43,7 @@ files:
 - acts_as_sane_tree.gemspec
 - init.rb
 - README.rdoc
+- CHANGELOG.rdoc
 - lib/acts_as_sane_tree.rb
 - lib/version.rb
 has_rdoc: true