closure_tree 4.0.1 → 4.1.0

data/README.md

@@ -23,12 +23,14 @@ closure_tree has some great features:
 * __Best-in-class mutation performance__:
   * 2 SQL INSERTs on node creation
   * 3 SQL INSERT/UPDATEs on node reparenting
+* __Support for Rails 3.0, 3.1, 3.2, and 4.0.0.rc1__
 * Support for reparenting children (and all their progeny)
 * Support for [concurrency](#concurrency) (using [with_advisory_lock](https://github/mceachen/with_advisory_lock))
 * Support for polymorphism [STI](#sti) within the hierarchy
 * ```find_or_create_by_path``` for [building out hierarchies quickly and conveniently](#find_or_create_by_path)
 * Support for [deterministic ordering](#deterministic-ordering) of children
 * Support for [preordered](http://en.wikipedia.org/wiki/Tree_traversal#Pre-order) traversal of descendants
+* Support for rendering trees in [DOT format](http://en.wikipedia.org/wiki/DOT_(graph_description_language)), using [Graphviz](http://www.graphviz.org/)
 * Excellent [test coverage](#testing) in a variety of environments
 
 See [Bill Karwin](http://karwin.blogspot.com/)'s excellent
@@ -210,7 +212,25 @@ server may not be happy trying to do this.
 
 HT: [ancestry](https://github.com/stefankroes/ancestry#arrangement) and [elhoyos](https://github.com/mceachen/closure_tree/issues/11)
 
-### <a id="options"></a>Available options
+### Graph visualization
+
+```to_dot_digraph``` is suitable for passing into [Graphviz](http://www.graphviz.org/).
+
+For example, for the above tree, write out the DOT file with ruby:
+```ruby
+File.open("example.dot", "w") { |f| f.write(Tag.root.to_dot_digraph) }
+```
+Then, in a shell, ```dot -Tpng example.dot > example.png```, which produces:
+
+![Example tree](https://raw.github.com/mceachen/closure_tree/master/img/example.png)
+
+If you want to customize the label value, override the ```#to_digraph_label``` instance method in your model.
+
+Just for kicks, this is the test tree I used for proving that preordered tree traversal was correct:
+
+![Preordered test tree](https://raw.github.com/mceachen/closure_tree/master/img/preorder.png)
+
+### Available options
 
 When you include ```acts_as_tree``` in your model, you can provide a hash to override the following defaults:
 
@@ -433,10 +453,10 @@ rather than using fixtures? [Lots of people have written about this already](htt
 
 ## Testing
 
-Closure tree is [tested under every combination](http://travis-ci.org/#!/mceachen/closure_tree) of
+Closure tree is [tested under every valid combination](http://travis-ci.org/#!/mceachen/closure_tree) of
 
-* Ruby 1.8.7 and Ruby 1.9.3
-* The latest Rails 3.0, 3.1, and 3.2 branches, and
+* Ruby 1.8.7, Ruby 1.9.3, and Ruby 2.0.0
+* The latest Rails 3.0, 3.1, 3.2, and 4.0 branches, and
 * MySQL and PostgreSQL. SQLite works in a single-threaded environment.
 
 Assuming you're using [rbenv](https://github.com/sstephenson/rbenv), you can use ```tests.sh``` to
@@ -445,8 +465,14 @@ run the test matrix locally.
 Parallelism is not tested with Rails 3.0.x nor 3.1.x due to this
 [known issue](https://github.com/rails/rails/issues/7538).
 
+
 ## Change log
 
+### 4.1.0
+
+* Added support for Rails 4.0.0.rc1 and Ruby 2.0.0 (while maintaining backward compatibility with Rails 3, BOOYA)
+* Added ```#to_dot_digraph```, suitable for Graphviz rendering
+
 ### 4.0.1
 
 * Numeric, deterministically ordered siblings will always be [0..#{self_and_siblings.count}]

data/Rakefile

@@ -16,10 +16,14 @@ RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
-task :specs_with_db_ixes do
+task :all_spec_flavors do
   [["", ""], ["db_prefix_", ""], ["", "_db_suffix"], ["abc_", "_123"]].each do |prefix, suffix|
     fail unless system("rake spec DB_PREFIX=#{prefix} DB_SUFFIX=#{suffix}")
   end
+  require 'active_record/version'
+  if ActiveRecord::VERSION::MAJOR == 3
+    system("rake spec ATTR_ACCESSIBLE=1")
+  end
 end
 
 # Run the specs using all the different database engines:

data/lib/closure_tree/acts_as_tree.rb

@@ -18,7 +18,7 @@ module ClosureTree
       include ClosureTree::Model
       include ClosureTree::WithAdvisoryLock
 
-      if _ct.order_option
+      if _ct.order_option?
         include ClosureTree::DeterministicOrdering
         include ClosureTree::DeterministicNumericOrdering if _ct.order_is_numeric?
       end

data/lib/closure_tree/model.rb

@@ -5,50 +5,50 @@ module ClosureTree
     extend ActiveSupport::Concern
 
     included do
-      validate :ct_validate
-      before_save :ct_before_save
-      after_save :ct_after_save
-      before_destroy :ct_before_destroy
+      validate :_ct_validate
+      before_save :_ct_before_save
+      after_save :_ct_after_save
+      before_destroy :_ct_before_destroy
 
       belongs_to :parent,
         :class_name => _ct.model_class.to_s,
         :foreign_key => _ct.parent_column_name
 
-      unless defined?(ActiveModel::ForbiddenAttributesProtection) && ancestors.include?(ActiveModel::ForbiddenAttributesProtection)
-        attr_accessible :parent
-      end
+      attr_accessible :parent if _ct.use_attr_accessible?
+
+      order_by_generations = "#{_ct.quoted_hierarchy_table_name}.generations asc"
 
-      has_many :children, _ct.with_order_option(
+      has_many :children, *_ct.has_many_with_order_option(
         :class_name => _ct.model_class.to_s,
         :foreign_key => _ct.parent_column_name,
         :dependent => _ct.options[:dependent])
 
-      has_many :ancestor_hierarchies,
+      has_many :ancestor_hierarchies, *_ct.has_many_without_order_option(
         :class_name => _ct.hierarchy_class_name,
         :foreign_key => "descendant_id",
-        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc"
+        :order => order_by_generations)
 
-      has_many :self_and_ancestors,
+      has_many :self_and_ancestors, *_ct.has_many_without_order_option(
         :through => :ancestor_hierarchies,
         :source => :ancestor,
-        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc"
+        :order => order_by_generations)
 
-      has_many :descendant_hierarchies,
+      has_many :descendant_hierarchies, *_ct.has_many_without_order_option(
         :class_name => _ct.hierarchy_class_name,
         :foreign_key => "ancestor_id",
-        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc"
+        :order => order_by_generations)
 
       # TODO: FIXME: this collection currently ignores sort_order
       # (because the quoted_table_named would need to be joined in to get to the order column)
 
-      has_many :self_and_descendants, _ct.with_order_option(
+      has_many :self_and_descendants, *_ct.has_many_with_order_option(
         :through => :descendant_hierarchies,
         :source => :descendant,
-        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc")
+        :order => order_by_generations)
 
       scope :without, lambda { |instance|
         if instance.new_record?
-          scoped
+          all
         else
           where(["#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} != ?", instance.id])
         end
@@ -62,7 +62,7 @@ module ClosureTree
 
     # Returns true if this node has no parents.
     def root?
-      parent_id.nil?
+      _ct_parent_id.nil?
     end
 
     # Returns true if this node has a parent, and is not a root.
@@ -118,7 +118,7 @@ module ClosureTree
     end
 
     def self_and_siblings
-      _ct.scope_with_order(_ct.base_class.where(_ct.parent_column_sym => parent_id))
+      _ct.scope_with_order(_ct.base_class.where(_ct.parent_column_sym => _ct_parent_id))
     end
 
     def siblings
@@ -190,11 +190,20 @@ module ClosureTree
       self.class.build_hash_tree(hash_tree_scope(options[:limit_depth]))
     end
 
-    def parent_id
+    # override this method in your model class if you want a different digraph label.
+    def to_digraph_label
+      _ct.has_name? ? read_attribute(_ct.name_column) : to_s
+    end
+
+    def _ct_parent_id
       read_attribute(_ct.parent_column_sym)
     end
 
-    def ct_validate
+    def _ct_id
+      read_attribute(_ct.model_class.primary_key)
+    end
+
+    def _ct_validate
       if changes[_ct.parent_column_name] &&
         parent.present? &&
         parent.self_and_ancestors.include?(self)
@@ -202,12 +211,12 @@ module ClosureTree
       end
     end
 
-    def ct_before_save
+    def _ct_before_save
       @was_new_record = new_record?
       true # don't cancel the save
     end
 
-    def ct_after_save
+    def _ct_after_save
       rebuild! if changes[_ct.parent_column_name] || @was_new_record
       @was_new_record = false # we aren't new anymore.
       true # don't cancel anything.
@@ -221,17 +230,17 @@ module ClosureTree
           sql = <<-SQL
             INSERT INTO #{_ct.quoted_hierarchy_table_name}
               (ancestor_id, descendant_id, generations)
-            SELECT x.ancestor_id, #{_ct.quote(id)}, x.generations + 1
+            SELECT x.ancestor_id, #{_ct.quote(_ct_id)}, x.generations + 1
             FROM #{_ct.quoted_hierarchy_table_name} x
-            WHERE x.descendant_id = #{_ct.quote(self.parent_id)}
+            WHERE x.descendant_id = #{_ct.quote(_ct_parent_id)}
           SQL
-          connection.execute sql.strip
+          _ct.connection.execute sql.strip
         end
         children.each { |c| c.rebuild! }
       end
     end
 
-    def ct_before_destroy
+    def _ct_before_destroy
       delete_hierarchy_references
       if _ct.options[:dependent] == :nullify
         children.each { |c| c.rebuild! }
@@ -243,7 +252,7 @@ module ClosureTree
       # It shouldn't affect performance of postgresql.
       # See http://dev.mysql.com/doc/refman/5.0/en/subquery-errors.html
       # Also: PostgreSQL doesn't support INNER JOIN on DELETE, so we can't use that.
-      connection.execute <<-SQL
+      _ct.connection.execute <<-SQL
         DELETE FROM #{_ct.quoted_hierarchy_table_name}
         WHERE descendant_id IN (
           SELECT DISTINCT descendant_id
@@ -259,6 +268,10 @@ module ClosureTree
       scope.without(self)
     end
 
+    def to_dot_digraph
+      self.class.to_dot_digraph(self_and_descendants)
+    end
+
     module ClassMethods
       def roots
         _ct.scope_with_order(where(_ct.parent_column_name => nil))
@@ -284,7 +297,7 @@ module ClosureTree
             HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = 0
           ) AS leaves ON (#{_ct.quoted_table_name}.#{primary_key} = leaves.ancestor_id)
         SQL
-        _ct.scope_with_order(s)
+        _ct.scope_with_order(s.readonly(false))
       end
 
       # Rebuilds the hierarchy table based on the parent_id column in the database.
@@ -325,11 +338,12 @@ module ClosureTree
 
       def ct_scoped_to_path(path, parent_constraint)
         path = path.is_a?(Enumerable) ? path.dup : [path]
-        scope = scoped.where(_ct.name_sym => path.last).readonly(false)
+        scope = where(_ct.name_sym => path.last).readonly(false)
         path[0..-2].reverse.each_with_index do |ea, idx|
           subtable = idx == 0 ? _ct.quoted_table_name : "p#{idx - 1}"
           scope = scope.joins(<<-SQL)
-            INNER JOIN #{_ct.quoted_table_name} AS p#{idx} ON p#{idx}.id = #{subtable}.#{_ct.parent_column_name}
+            INNER JOIN #{_ct.quoted_table_name} AS p#{idx}
+              ON p#{idx}.#{_ct.quoted_id_column_name} = #{subtable}.#{_ct.parent_column_name}
           SQL
           scope = scope.where("p#{idx}.#{_ct.quoted_name_column} = #{_ct.quote(ea)}")
         end
@@ -355,12 +369,13 @@ module ClosureTree
       def hash_tree_scope(limit_depth = nil)
         # Deepest generation, within limit, for each descendant
         # NOTE: Postgres requires HAVING clauses to always contains aggregate functions (!!)
+        having_clause = limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ''
         generation_depth = <<-SQL
           INNER JOIN (
             SELECT descendant_id, MAX(generations) as depth
             FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY descendant_id
-            #{limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ""}
+            #{having_clause}
           ) AS generation_depth
             ON #{_ct.quoted_table_name}.#{primary_key} = generation_depth.descendant_id
         SQL
@@ -377,11 +392,26 @@ module ClosureTree
           if ea.root? || tree.empty? # We're at the top of the tree.
             tree[ea] = h
           else
-            id_to_hash[ea.parent_id][ea] = h
+            id_to_hash[ea._ct_parent_id][ea] = h
           end
         end
         tree
       end
+
+      # Renders the given scope as a DOT digraph, suitable for rendering by Graphviz
+      def to_dot_digraph(tree_scope)
+        id_to_instance = tree_scope.inject({}) { |h, ea| h[ea.id] = ea; h }
+        output = StringIO.new
+        output << "digraph G {\n"
+        tree_scope.each do |ea|
+          if id_to_instance.has_key? ea._ct_parent_id
+            output << "  #{ea._ct_parent_id} -> #{ea._ct_id}\n"
+          end
+          output << "  #{ea._ct_id} [label=\"#{ea.to_digraph_label}\"]\n"
+        end
+        output << "}\n"
+        output.string
+      end
     end
   end
 end

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -5,7 +5,7 @@ module ClosureTree
 
     def self_and_descendants_preordered
       # TODO: raise NotImplementedError if sort_order is not numeric and not null?
-      h = connection.select_one(<<-SQL)
+      h = _ct.connection.select_one(<<-SQL)
         SELECT
           count(*) as total_descendants,
           max(generations) as max_depth
@@ -28,7 +28,7 @@ module ClosureTree
 
     module ClassMethods
       def roots_and_descendants_preordered
-        h = connection.select_one(<<-SQL)
+        h = _ct.connection.select_one(<<-SQL)
           SELECT
             count(*) as total_descendants,
             max(generations) as max_depth

data/lib/closure_tree/support.rb

@@ -20,12 +20,27 @@ module ClosureTree
       model_class.connection
     end
 
+    def use_attr_accessible?
+      ActiveRecord::VERSION::MAJOR == 3 &&
+        defined?(ActiveModel::MassAssignmentSecurity) &&
+        model_class.ancestors.include?(ActiveModel::MassAssignmentSecurity)
+    end
+
+    def include_forbidden_attributes_protection?
+      ActiveRecord::VERSION::MAJOR == 3 &&
+        defined?(ActiveModel::ForbiddenAttributesProtection) &&
+        model_class.ancestors.include?(ActiveModel::ForbiddenAttributesProtection)
+    end
+
     def hierarchy_class_for_model
       hierarchy_class = model_class.parent.const_set(short_hierarchy_class_name, Class.new(ActiveRecord::Base))
+      use_attr_accessible = use_attr_accessible?
+      include_forbidden_attributes_protection = include_forbidden_attributes_protection?
       hierarchy_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        include ActiveModel::ForbiddenAttributesProtection if include_forbidden_attributes_protection
         belongs_to :ancestor, :class_name => "#{model_class}"
         belongs_to :descendant, :class_name => "#{model_class}"
-        attr_accessible :ancestor, :descendant, :generations
+        attr_accessible :ancestor, :descendant, :generations if use_attr_accessible
         def ==(other)
           self.class == other.class && ancestor_id == other.ancestor_id && descendant_id == other.descendant_id
         end
@@ -87,6 +102,10 @@ module ClosureTree
       connection.quote_table_name hierarchy_table_name
     end
 
+    def quoted_id_column_name
+      connection.quote_column_name model_class.primary_key
+    end
+
     def quoted_parent_column_name
       connection.quote_column_name parent_column_name
     end
@@ -103,38 +122,55 @@ module ClosureTree
       !options[:order].nil?
     end
 
-    def order_option
-      options[:order].to_s
+    def with_order_option(opts)
+      if order_option?
+        opts[:order] = [opts[:order], options[:order]].compact.join(",")
+      end
+      opts
     end
 
-    def with_order_option(options)
-      order_option? ? options.merge(:order => order_option) : options
+    def scope_with_order(scope, additional_order_by = nil)
+      order_option? ? scope.order(*([additional_order_by, options[:order]].compact)) : scope
     end
 
-    def scope_with_order(scope, additional_order_by = nil)
-      order_option? ? scope.order(*([additional_order_by, order_option].compact)) : scope
+    # lambda-ize the order, but don't apply the default order_option
+    def has_many_without_order_option(opts)
+      if ActiveRecord::VERSION::MAJOR > 3
+        [lambda { order(opts[:order]) }, opts.except(:order)]
+      else
+        [opts]
+      end
     end
 
-    def with_order_option(options)
-      if order_option?
-        options[:order] = [options[:order], order_option].compact.join(",")
+    def has_many_with_order_option(opts)
+      if ActiveRecord::VERSION::MAJOR > 3
+        order_options = [opts[:order], options[:order]].compact
+        [lambda { order(order_options) }, opts.except(:order)]
+      else
+        [with_order_option(opts)]
       end
-      options
     end
 
     def order_is_numeric?
       # The table might not exist yet (in the case of ActiveRecord::Observer use, see issue 32)
       return false if !order_option? || !model_class.table_exists?
-      c = model_class.columns_hash[order_option]
+      c = model_class.columns_hash[order_column]
       c && c.type == :integer
     end
 
     def order_column
-      order_option.split(' ', 2).first if order_option?
+      o = options[:order]
+      if o.nil?
+        nil
+      elsif o.is_a?(String)
+        o.split(' ', 2).first
+      else
+        o.to_s
+      end
     end
 
     def require_order_column
-      raise ":order value, '#{order_option}', isn't a column" if order_column.nil?
+      raise ":order value, '#{options[:order]}', isn't a column" if order_column.nil?
     end
 
     def order_column_sym
@@ -181,9 +217,9 @@ module ClosureTree
 
     def ids_from(scope)
       if scope.respond_to? :pluck
-        scope.pluck(:id)
+        scope.pluck(model_class.primary_key)
       else
-        scope.select(:id).collect(&:id)
+        scope.select(model_class.primary_key).map { |ea| ea._ct_id }
       end
     end
   end