ActsAsFastNestedSet 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 / 2006-11-13
+
+* First release
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/acts_as_fast_nested_set.rb
+lib/counter_string.rb
+test/test_acts_as_fast_nested_set.rb

data/README.txt

@@ -0,0 +1,48 @@
+ActsAsFastNestedSet
+    by Adocca AB
+    http://www.adocca.com
+
+== DESCRIPTION:
+  
+Fast nested set implementation
+
+== FEATURES/PROBLEMS:
+  
+None!
+
+== SYNOPSYS:
+
+Just add acts_as_fast_nested_set in your AR::Base descendant model class
+
+== REQUIREMENTS:
+
+* Rails 1.1.6
+
+== INSTALL:
+
+* gem install acts_as_fast_nested_set
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006 Adocca AB
+
+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/Rakefile

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/counter_string.rb'
+require './lib/acts_as_fast_nested_set.rb'
+
+Hoe.new('ActsAsFastNestedSet', Adocca::Acts::ActsAsFastNestedSet::VERSION) do |p|
+  p.rubyforge_name = 'adocca_plugins'
+  p.summary = 'Fast nested set, really fast!'
+  # p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  # p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/acts_as_fast_nested_set.rb

@@ -0,0 +1,217 @@
+require 'counter_string'
+require 'active_record'
+
+#
+# Defines an act that behaves a bit like nested_set or tree, but is hopefully much faster.
+#
+# Like the nested_set it is much faster than tree when selecting subtrees, but unlike nested_set
+# it wont have to rewrite the entire tree for each insertion or deletion.
+#
+# Each node is connected to a parent, and each node has a node_id.
+#
+# The node_id is created by concatenating a new identifier to the parents node_id, or just creating
+# a brand new identifier if no parent is present, and appending a dot.
+#
+# An identifier is alphabetical, and the newest identifier is always alphabetically greater than
+# the identifiers of its siblings.
+#
+# An example list of valid node_ids:
+# AAAA. <- a top level node, with only one trailing dot
+# AAAA.AAAA. <- a child of the node above
+# AAAA.AAAB. <- sibling nr one
+# AAAA.AAAB.AAAA. <- a child of sibling nr one
+# AAAA.AAAC. <- sibling nr two
+# AAAB. <- top level node two
+# AAAC. <- top level node three
+# AAAC.AAAA. <- child of top level node three
+# AAAD. <- top level node four
+#
+# This structure makes it easy to find all children of a node:
+# SELECT * FROM table WHERE node_id LIKE 'AAAA.%' <- selects top level node one and all its children
+# SELECT * FROM table WHERE node_id LIKE 'AAAA.AAAB.%' <- selects sibling nr two and all its children
+#
+# Deleting is naturally equally easy.
+#
+# The tricky bit is generating node_ids - for that we use the counter_string, which increments like:
+# "aaaa".next == "aaab"
+# "ZZZZ".next == "ZZZa"
+# "zzzz".next == "zzzzAAAA"
+#
+# This keeps the relation between node_ids within the tree intact, as well as provides a big (140000 entries)
+# namespace for each level of the tree using only 5 chars in the node_id column, and providing an even bigger
+# (basically unlimited) namespace with more than 5 chars in the node_id column (it will provide 140000 more entries
+# for each extra 4 chars after the first 5)
+#
+# If you want to have several trees with different sets of node_ids (for example, several comment-trees connected
+# to different models in the system), you can add :uniqueness_scope as a param to the acts_as_fast_nested_set
+# method.
+#
+# Example:
+# acts_as_fast_nested_set :uniqueness_scope => [:forum_id, :forum_class] <- Will have a separate tree of node_ids 
+#                                                                           for each unique combination of forum_id 
+#                                                                           and forum_class in the model.
+#
+module Adocca
+  module Acts
+    module ActsAsFastNestedSet
+      VERSION = "0.0.1"
+
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        #
+        # Makes this model act as a fast_nested_set. It needs to
+        # have parent_id, node_id and naturally id among its attributes.
+        #
+        # If you want to create different trees (with colliding node_ids, use
+        # the :uniqueness_scope param.
+        #
+        # Example:
+        # acts_as_fast_nested_set :uniqueness_scope => [:forum_id, :forum_class] <- Will have a separate tree of node_ids 
+        #                                                                           for each unique combination of forum_id 
+        #                                                                           and forum_class in the model.
+        #
+        def acts_as_fast_nested_set(options = {})
+          belongs_to :parent, :class_name => self.name, :foreign_key => 'parent_id'
+          has_many :children, :class_name => self.name, :foreign_key => 'parent_id'
+          attr_protected :node_id, :parent_id
+          if options[:uniqueness_scope]
+            validates_uniqueness_of :node_id, :scope => options[:uniqueness_scope]
+          else
+            validates_uniqueness_of :node_id
+          end
+          validate :ensure_node_id
+          class_eval do
+            extend Adocca::Acts::ActsAsFastNestedSet::SingletonMethods
+          end
+          set_options(options)
+          include Adocca::Acts::ActsAsFastNestedSet::InstanceMethods
+        end
+      end
+      module SingletonMethods
+        def set_options(options)
+          @@options = options
+        end
+        def get_options
+          @@options
+        end
+      end
+      module InstanceMethods
+        #
+        # Returns the entire thread
+        #
+        def kin
+          self.class.find(:all, :conditions => ["node_id LIKE ?#{unique_with_and}", 
+                                                "#{root_id}.%"] + 
+                                                unique_params)
+        end
+        #
+        # Destroys all children and their children etc
+        #
+        def destroy_descendants
+          self.class.connection.delete(
+              self.class.sanitizeSQL(
+                  ["DELETE FROM comments WHERE node_id LIKE ? AND id != ?#{unique_with_and}", 
+                   "#{self.node_id}%", self.id] + unique_params))
+        end
+        #
+        # All nodes with the same parent
+        #
+        def siblings
+          self.class.find_all_by_parent_id(self.parent_id)
+        end
+        #
+        # All our children and their children etc
+        #
+        def descendants
+          self.class.find(:all, 
+                          :conditions => ["node_id LIKE ? AND id != ?#{unique_with_and}", 
+                                          "#{self.node_id}%", self.id] + unique_params)
+        end
+
+		def level
+		  if self.node_id.nil?
+		    1
+		  else
+			self.node_id.count "."
+		  end
+		end
+
+        private
+
+        def unique_statement
+          self.class.get_options[:uniqueness_scope].nil? ? "" : "#{self.class.get_options[:uniqueness_scope].join(" = ? AND ")} = ?"
+        end
+        def unique_with_where
+          " WHERE #{unique_statement}"
+        end
+        def unique_with_and
+          " AND #{unique_statement}"
+        end
+
+        def unique_params
+          self.class.get_options[:uniqueness_scope].map do |att| self.send(att) end
+        end
+
+        def ensure_node_id
+          if self.node_id.nil? || self.node_id.empty?
+            if self.parent
+              self.node_id = "#{self.parent.node_id}#{next_node_id(self.parent.node_id)}."
+            else
+              self.node_id = "#{next_node_id}."
+            end
+          end
+          true
+        end
+
+        def root_id
+          if self.node_id.nil?
+            nil
+          else
+            if (match = self.node_id.match(/^([[:alpha:]]+)\..*$/))
+              match[1]
+            else
+              raise "My node_id '#{self.node_id}' is illegal!"
+            end
+          end
+        end
+
+        def next_node_id(parentNodeId = nil)
+          if parentNodeId.nil?
+            maxId = self.class.connection.select_value(self.class.sanitizeSQL(["SELECT MAX(node_id) FROM comments#{unique_with_where}"] + unique_params))
+            if maxId.nil?                                                                                                  # there are no other root nodes
+              "AAAA"
+            else                                                                                                           # there are other root nodes
+              if (match = maxId.match(/^([[:alpha:]]+)\..*$/))                                                                      # the latest root-node is properly formed
+                CounterString.new(match[1]).next
+              else                                                                                                         # its not properly formed
+                raise "node_id '#{maxId}' is not a legal node_id!"
+              end
+            end
+          else                                                                                                             # this is not a root node
+            maxId = self.class.connection.select_value(self.class.sanitizeSQL(["SELECT MAX(node_id) FROM comments WHERE node_id LIKE ?#{unique_with_and}", "#{parentNodeId}%"] + unique_params))
+            if maxId.nil?                                                                                                  # there are no nodes like the parent
+              raise "Cant find parent, no node with id '#{parentNodeId}'!"
+            else                                                                                                           # there are nodes like the parent
+              restPart = maxId[(parentNodeId.size)..-1]
+              if restPart.empty?                                                                                           # but no children of the parent
+                "AAAA"
+              else                                                                                                         # there are children of the parent
+                if (match = restPart.match(/^([[:alpha:]]+)\..*$/))                                                                 # and they are properly formed
+                  CounterString.new(match[1]).next
+                else                                                                                                       # but not properly formed
+                  raise "node_id '#{maxId}' is not a legal descendant of '#{parentNodeId}'!"
+                end
+              end 
+            end
+          end
+        end # of def next_node_id
+      end # of module InstanceMethods
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Adocca::Acts::ActsAsFastNestedSet)

data/lib/counter_string.rb

@@ -0,0 +1,27 @@
+class CounterString < String
+
+  def next
+    (self.size - 1).downto(0) do |index|
+      this_ord = self[index]
+      if new_ord = next_ord(this_ord)
+        return CounterString.new("#{self[0...index]}#{new_ord.chr}".ljust(self.size, "a"))
+      end
+    end
+    CounterString.new(self.ljust(self.size + 4, "a"))
+  end
+
+  private
+
+  def next_ord(ord)
+    if ord < 90
+      ord + 1
+    elsif ord == 90
+      97
+    elsif ord < 122
+      ord + 1
+    else
+      false
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ActsAsFastNestedSet
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-11-13 00:00:00 +01:00
+summary: Fast nested set, really fast!
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: http://www.zenspider.com/ZSS/Products/ActsAsFastNestedSet/
+rubyforge_project: adocca_plugins
+description: Ryan Davis is too lazy to write a description
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/acts_as_fast_nested_set.rb
+- lib/counter_string.rb
+- test/test_acts_as_fast_nested_set.rb
+test_files: 
+- test/test_acts_as_fast_nested_set.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.4
+    version: