closure_tree 3.0.0 → 3.0.1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Matthew McEachen
+Copyright (c) 2012 Matthew McEachen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -2,7 +2,8 @@
 
 Closure Tree is a mostly-API-compatible replacement for the
 acts_as_tree and awesome_nested_set gems, but with much better
-mutation performance thanks to the Closure Tree storage algorithm.
+mutation performance thanks to the Closure Tree storage algorithm,
+as well as support for polymorphism within the hierarchy.
 
 See [Bill Karwin](http://karwin.blogspot.com/)'s excellent
 [Models for hierarchical data presentation](http://www.slideshare.net/billkarwin/models-for-hierarchical-data)
@@ -10,7 +11,7 @@ for a description of different tree storage algorithms.
 
 ## Setup
 
-Note that closure_tree is being developed for Rails 3.1.x
+Note that closure_tree supports Rails 3. Rails 2, not so much.
 
 1.  Add this to your Gemfile: ```gem 'closure_tree'```
 
@@ -22,35 +23,35 @@ Note that closure_tree is being developed for Rails 3.1.x
 
     Note that if the column is null, the tag will be considered a root node.
 
-      ```ruby
-      class AddParentIdToTag < ActiveRecord::Migration
-        def change
-          add_column :tag, :parent_id, :integer
-        end
+    ```ruby
+    class AddParentIdToTag < ActiveRecord::Migration
+      def change
+        add_column :tag, :parent_id, :integer
       end
-      ```
+    end
+    ```
 
 5.  Add a database migration to store the hierarchy for your model. By
     convention the table name will be the model's table name, followed by
     "_hierarchy". Note that by calling ```acts_as_tree```, a "virtual model" (in this case, ```TagsHierarchy```) will be added automatically, so you don't need to create it.
 
-      ```ruby
-      class CreateTagHierarchies < ActiveRecord::Migration
-        def change
-          create_table :tag_hierarchies, :id => false do |t|
-            t.integer  :ancestor_id, :null => false   # ID of the parent/grandparent/great-grandparent/... tag
-            t.integer  :descendant_id, :null => false # ID of the target tag
-            t.integer  :generations, :null => false   # Number of generations between the ancestor and the descendant. Parent/child = 1, for example.
-          end
+    ```ruby
+    class CreateTagHierarchies < ActiveRecord::Migration
+      def change
+        create_table :tag_hierarchies, :id => false do |t|
+          t.integer  :ancestor_id, :null => false   # ID of the parent/grandparent/great-grandparent/... tag
+          t.integer  :descendant_id, :null => false # ID of the target tag
+          t.integer  :generations, :null => false   # Number of generations between the ancestor and the descendant. Parent/child = 1, for example.
+        end
 
-          # For "all progeny of..." selects:
-          add_index :tag_hierarchies, [:ancestor_id, :descendant_id], :unique => true
+        # For "all progeny of..." selects:
+        add_index :tag_hierarchies, [:ancestor_id, :descendant_id], :unique => true
 
-          # For "all ancestors of..." selects
-          add_index :tag_hierarchies, [:descendant_id]
-        end
+        # For "all ancestors of..." selects
+        add_index :tag_hierarchies, [:descendant_id]
       end
-      ```
+    end
+    ```
 
 6.  Run ```rake db:migrate```
 
@@ -66,41 +67,41 @@ Note that closure_tree is being developed for Rails 3.1.x
 
 Create a root node:
 
-  ```ruby
-  grandparent = Tag.create(:name => 'Grandparent')
-  ```
+```ruby
+grandparent = Tag.create(:name => 'Grandparent')
+```
 
 Child nodes are created by appending to the children collection:
 
-  ```ruby
-  child = parent.children.create(:name => 'Child')
-  ```
+```ruby
+child = parent.children.create(:name => 'Child')
+```
 
 You can also append to the children collection:
 
-  ```ruby
-  child = Tag.create(:name => 'Child')
-  parent.children << child
-  ```
+```ruby
+child = Tag.create(:name => 'Child')
+parent.children << child
+```
 
 Or call the "add_child" method:
 
-  ```ruby
-  parent = Tag.create(:name => 'Parent')
-  grandparent.add_child parent
-  ```
+```ruby
+parent = Tag.create(:name => 'Parent')
+grandparent.add_child parent
+```
 
 Then:
 
-  ```ruby
-  puts grandparent.self_and_descendants.collect{ |t| t.name }.join(" > ")
-  "grandparent > parent > child"
+```ruby
+puts grandparent.self_and_descendants.collect{ |t| t.name }.join(" > ")
+"grandparent > parent > child"
 
-  child.ancestry_path
-  ["grandparent", "parent", "child"]
-  ```
+child.ancestry_path
+["grandparent", "parent", "child"]
+```
 
-### <code>find_or_create_by_path</code>
+### find_or_create_by_path
 
 We can do all the node creation and add_child calls from the prior section with one method call:
 
@@ -115,9 +116,9 @@ provided to ```acts_as_tree```.
 
 Note that any other AR fields can be set with the second, optional ```attributes``` argument.
 
-  ```ruby
-  child = Tag.find_or_create_by_path(%w{home chuck Photos"}, {:tag_type => "File"})
-  ```
+```ruby
+child = Tag.find_or_create_by_path(%w{home chuck Photos"}, {:tag_type => "File"})
+```
 This will pass the attribute hash of ```{:name => "home", :tag_type => "File"}``` to
 ```Tag.find_or_create_by_name``` if the root directory doesn't exist (and
 ```{:name => "chuck", :tag_type => "File"}``` if the second-level tag doesn't exist, and so on).
@@ -168,14 +169,14 @@ Polymorphic models are supported:
 1. Create a db migration that adds a String ```type``` column to your model
 2. Subclass the model class. You only need to add acts_as_tree to your base class.
 
-  ```ruby
-  class Tag < ActiveRecord::Base
-    acts_as_tree
-  end
-  class WhenTag < Tag ; end
-  class WhereTag < Tag ; end
-  class WhatTag < Tag ; end
-  ```
+```ruby
+class Tag < ActiveRecord::Base
+  acts_as_tree
+end
+class WhenTag < Tag ; end
+class WhereTag < Tag ; end
+class WhatTag < Tag ; end
+```
 
 ## Change log
 
@@ -192,6 +193,10 @@ Polymorphic models are supported:
 * ```find_by_path``` and ```find_or_create_by_path``` signatures changed to support constructor attributes
 * tested against Rails 3.1.3
 
+### 3.0.1
+
+* Support 3.2.0's fickle deprecation of InstanceMethods (Thanks, [jheiss](https://github.com/mceachen/closure_tree/pull/5))!
+
 ## Thanks to
 
 * https://github.com/collectiveidea/awesome_nested_set

data/Rakefile

@@ -4,13 +4,13 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
+Bundler::GemHelper.install_tasks
+
 require 'yard'
 YARD::Rake::YardocTask.new do |t|
   t.files = ['lib/**/*.rb', 'README.md']
 end
 
-Bundler::GemHelper.install_tasks
-
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 

data/lib/closure_tree/acts_as_tree.rb

@@ -66,162 +66,160 @@ module ClosureTree
 
   module Model
     extend ActiveSupport::Concern
-    module InstanceMethods
 
-      # Returns true if this node has no parents.
-      def root?
-        parent.nil?
-      end
+    # Returns true if this node has no parents.
+    def root?
+      parent.nil?
+    end
 
-      # Returns true if this node has a parent, and is not a root.
-      def child?
-        !parent.nil?
-      end
+    # Returns true if this node has a parent, and is not a root.
+    def child?
+      !parent.nil?
+    end
 
-      # Returns true if this node has no children.
-      def leaf?
-        children.empty?
-      end
+    # Returns true if this node has no children.
+    def leaf?
+      children.empty?
+    end
 
-      # Returns the farthest ancestor, or self if +root?+
-      def root
-        root? ? self : ancestors.last
-      end
+    # Returns the farthest ancestor, or self if +root?+
+    def root
+      root? ? self : ancestors.last
+    end
 
-      def leaves
-        return [self] if leaf?
-        self.class.leaves.where(<<-SQL
+    def leaves
+      return [self] if leaf?
+      self.class.leaves.where(<<-SQL
 #{quoted_table_name}.#{self.class.primary_key} IN (
-            SELECT descendant_id
-            FROM #{quoted_hierarchy_table_name}
-            WHERE ancestor_id = #{id})
-        SQL
-        )
-      end
-
-      def level
-        ancestors.size
-      end
+          SELECT descendant_id
+          FROM #{quoted_hierarchy_table_name}
+          WHERE ancestor_id = #{id})
+      SQL
+      )
+    end
 
-      def ancestors
-        without_self(self_and_ancestors)
-      end
+    def level
+      ancestors.size
+    end
 
-      # Returns an array, root first, of self_and_ancestors' values of the +to_s_column+, which defaults
-      # to the +name_column+.
-      # (so child.ancestry_path == +%w{grandparent parent child}+
-      def ancestry_path(to_s_column = name_column)
-        self_and_ancestors.reverse.collect { |n| n.send to_s_column.to_sym }
-      end
+    def ancestors
+      without_self(self_and_ancestors)
+    end
 
-      def descendants
-        without_self(self_and_descendants)
-      end
+    # Returns an array, root first, of self_and_ancestors' values of the +to_s_column+, which defaults
+    # to the +name_column+.
+    # (so child.ancestry_path == +%w{grandparent parent child}+
+    def ancestry_path(to_s_column = name_column)
+      self_and_ancestors.reverse.collect { |n| n.send to_s_column.to_sym }
+    end
 
-      def self_and_siblings
-        self.class.scoped.where(:parent => parent)
-      end
+    def descendants
+      without_self(self_and_descendants)
+    end
 
-      def siblings
-        without_self(self_and_siblings)
-      end
+    def self_and_siblings
+      self.class.scoped.where(:parent => parent)
+    end
 
-      # Alias for appending to the children collection.
-      # You can also add directly to the children collection, if you'd prefer.
-      def add_child(child_node)
-        children << child_node
-        child_node
-      end
+    def siblings
+      without_self(self_and_siblings)
+    end
 
-      # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+.
-      def find_by_path(path)
-        path = [path] unless path.is_a? Enumerable
-        node = self
-        while (!path.empty? && node)
-          node = node.children.send("find_by_#{name_column}", path.shift)
-        end
-        node
-      end
+    # Alias for appending to the children collection.
+    # You can also add directly to the children collection, if you'd prefer.
+    def add_child(child_node)
+      children << child_node
+      child_node
+    end
 
-      # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
-      def find_or_create_by_path(path, attributes = {})
-        path = [path] unless path.is_a? Enumerable
-        node = self
-        attrs = {}
-        attrs[:type] = self.type if ct_subclass? && ct_has_type?
-        path.each do |name|
-          attrs[name_sym] = name
-          child = node.children.where(attrs).first
-          unless child
-            child = self.class.new(attributes.merge attrs)
-            node.children << child
-          end
-          node = child
-        end
-        node
+    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+.
+    def find_by_path(path)
+      path = [path] unless path.is_a? Enumerable
+      node = self
+      while (!path.empty? && node)
+        node = node.children.send("find_by_#{name_column}", path.shift)
       end
+      node
+    end
 
-      protected
-
-      def acts_as_tree_before_save
-        @was_new_record = new_record?
-        if changes[parent_column_name] &&
-          parent.present? &&
-          parent.self_and_ancestors.include?(self)
-          # TODO: raise Ouroboros or Philip J. Fry error:
-          raise ActiveRecord::ActiveRecordError "You cannot add an ancestor as a descendant"
+    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
+    def find_or_create_by_path(path, attributes = {})
+      path = [path] unless path.is_a? Enumerable
+      node = self
+      attrs = {}
+      attrs[:type] = self.type if ct_subclass? && ct_has_type?
+      path.each do |name|
+        attrs[name_sym] = name
+        child = node.children.where(attrs).first
+        unless child
+          child = self.class.new(attributes.merge attrs)
+          node.children << child
         end
+        node = child
       end
+      node
+    end
 
-      def acts_as_tree_after_save
-        rebuild! if changes[parent_column_name] || @was_new_record
-      end
+    protected
 
-      def rebuild!
-        delete_hierarchy_references unless @was_new_record
-        hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
-        unless root?
-          connection.execute <<-SQL
-            INSERT INTO #{quoted_hierarchy_table_name}
-              (ancestor_id, descendant_id, generations)
-            SELECT x.ancestor_id, #{id}, x.generations + 1
-            FROM #{quoted_hierarchy_table_name} x
-            WHERE x.descendant_id = #{self._parent_id}
-          SQL
-        end
-        children.each { |c| c.rebuild! }
+    def acts_as_tree_before_save
+      @was_new_record = new_record?
+      if changes[parent_column_name] &&
+        parent.present? &&
+        parent.self_and_ancestors.include?(self)
+        # TODO: raise Ouroboros or Philip J. Fry error:
+        raise ActiveRecord::ActiveRecordError "You cannot add an ancestor as a descendant"
       end
+    end
 
-      def acts_as_tree_before_destroy
-        delete_hierarchy_references
-        if closure_tree_options[:dependent] == :nullify
-          children.each { |c| c.rebuild! }
-        end
-      end
+    def acts_as_tree_after_save
+      rebuild! if changes[parent_column_name] || @was_new_record
+    end
 
-      def delete_hierarchy_references
-        # The crazy double-wrapped sub-subselect works around MySQL's limitation of subselects on the same table that is being mutated.
-        # It shouldn't affect performance of postgresql.
-        # See http://dev.mysql.com/doc/refman/5.0/en/subquery-errors.html
+    def rebuild!
+      delete_hierarchy_references unless @was_new_record
+      hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
+      unless root?
         connection.execute <<-SQL
-          DELETE FROM #{quoted_hierarchy_table_name}
-          WHERE descendant_id IN (
-            SELECT DISTINCT descendant_id
-            FROM ( SELECT descendant_id
-              FROM #{quoted_hierarchy_table_name}
-              WHERE ancestor_id = #{id}
-            ) AS x )
-            OR descendant_id = #{id}
+          INSERT INTO #{quoted_hierarchy_table_name}
+            (ancestor_id, descendant_id, generations)
+          SELECT x.ancestor_id, #{id}, x.generations + 1
+          FROM #{quoted_hierarchy_table_name} x
+          WHERE x.descendant_id = #{self._parent_id}
         SQL
       end
+      children.each { |c| c.rebuild! }
+    end
 
-      def without_self(scope)
-        scope.where(["#{quoted_table_name}.#{self.class.primary_key} != ?", self])
+    def acts_as_tree_before_destroy
+      delete_hierarchy_references
+      if closure_tree_options[:dependent] == :nullify
+        children.each { |c| c.rebuild! }
       end
+    end
 
-      def _parent_id
-        send(parent_column_name)
-      end
+    def delete_hierarchy_references
+      # The crazy double-wrapped sub-subselect works around MySQL's limitation of subselects on the same table that is being mutated.
+      # It shouldn't affect performance of postgresql.
+      # See http://dev.mysql.com/doc/refman/5.0/en/subquery-errors.html
+      connection.execute <<-SQL
+        DELETE FROM #{quoted_hierarchy_table_name}
+        WHERE descendant_id IN (
+          SELECT DISTINCT descendant_id
+          FROM ( SELECT descendant_id
+            FROM #{quoted_hierarchy_table_name}
+            WHERE ancestor_id = #{id}
+          ) AS x )
+          OR descendant_id = #{id}
+      SQL
+    end
+
+    def without_self(scope)
+      scope.where(["#{quoted_table_name}.#{self.class.primary_key} != ?", self])
+    end
+
+    def _parent_id
+      send(parent_column_name)
     end
 
     module ClassMethods

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = "3.0.0" unless defined?(::ClosureTree::VERSION)
+  VERSION = "3.0.1" unless defined?(::ClosureTree::VERSION)
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: closure_tree
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 3
   - 0
-  - 0
-  version: 3.0.0
+  - 1
+  version: 3.0.1
 platform: ruby
 authors: 
 - Matthew McEachen
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-27 00:00:00 -08:00
-default_executable: 
+date: 2012-01-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
+  type: :runtime
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -31,7 +31,6 @@ dependencies:
         - 0
         - 0
         version: 3.0.0
-  type: :runtime
   name: activerecord
   version_requirements: *id001
 description: "    A mostly-API-compatible replacement for the acts_as_tree and awesome_nested_set gems,\n    but with much better mutation performance thanks to the Closure Tree storage algorithm\n"
@@ -59,7 +58,6 @@ files:
 - spec/support/models.rb
 - spec/tag_spec.rb
 - spec/user_spec.rb
-has_rdoc: true
 homepage: http://matthew.mceachen.us/closure_tree
 licenses: []
 
@@ -89,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Hierarchies for ActiveRecord models using a Closure Tree storage algorithm
@@ -102,3 +100,4 @@ test_files:
 - spec/support/models.rb
 - spec/tag_spec.rb
 - spec/user_spec.rb
+has_rdoc: