closure_tree 3.10.2 → 4.0.0

data/README.md

@@ -444,6 +444,16 @@ Parallelism is not tested with Rails 3.0.x nor 3.1.x due to this
 
 ## Change log
 
+### 4.0.0
+
+* Moved all of closure_tree's implementation-detail methods into a ```ClosureTree::Support```
+  instance, which removes almost all of the namespace pollution in your models that wasn't
+  for normal consumption. If you were using any of these methods, they're now available through
+  the "_ct" class and instance member.
+
+  *This change may break consumers*, so I incremented the major version number, even though no new
+  functionality was released.
+
 ### 3.10.2
 
 * Prevent faulty SQL statement when ```#siblings``` is called on an unsaved records.

data/lib/closure_tree/acts_as_tree.rb

@@ -1,55 +1,26 @@
-require 'closure_tree/columns'
-require 'closure_tree/deterministic_ordering'
+require 'closure_tree/support'
 require 'closure_tree/model'
+require 'closure_tree/deterministic_ordering'
 require 'closure_tree/numeric_deterministic_ordering'
 require 'closure_tree/with_advisory_lock'
 
 module ClosureTree
   module ActsAsTree
     def acts_as_tree(options = {})
-
-      class_attribute :closure_tree_options
-
-      self.closure_tree_options = {
-        :ct_base_class => self,
-        :parent_column_name => 'parent_id',
-        :dependent => :nullify, # or :destroy or :delete_all -- see the README
-        :name_column => 'name',
-        :with_advisory_lock => true
-      }.merge(options)
-
-      raise IllegalArgumentException, "name_column can't be 'path'" if closure_tree_options[:name_column] == 'path'
-
-      include ClosureTree::Columns
-      extend ClosureTree::Columns
-
-      include ClosureTree::WithAdvisoryLock
-      extend ClosureTree::WithAdvisoryLock
+      class_attribute :_ct
+      self._ct = ClosureTree::Support.new(self, options)
 
       # Auto-inject the hierarchy table
       # See https://github.com/patshaughnessy/class_factory/blob/master/lib/class_factory/class_factory.rb
       class_attribute :hierarchy_class
-      self.hierarchy_class = ct_class.parent.const_set short_hierarchy_class_name, Class.new(ActiveRecord::Base)
-
-      self.hierarchy_class.class_eval <<-RUBY
-        belongs_to :ancestor, :class_name => "#{ct_class.to_s}"
-        belongs_to :descendant, :class_name => "#{ct_class.to_s}"
-        attr_accessible :ancestor, :descendant, :generations
-        def ==(other)
-          self.class == other.class && ancestor == other.ancestor && descendant == other.descendant
-        end
-        alias :eql? :==
-        def hash
-          ancestor_id.hash << 31 ^ descendant_id.hash
-        end
-      RUBY
-
-      self.hierarchy_class.table_name = hierarchy_table_name
+      self.hierarchy_class = _ct.hierarchy_class_for_model
 
       include ClosureTree::Model
-      unless order_option.nil?
+      include ClosureTree::WithAdvisoryLock
+
+      if _ct.order_option
         include ClosureTree::DeterministicOrdering
-        include ClosureTree::DeterministicNumericOrdering if order_is_numeric
+        include ClosureTree::DeterministicNumericOrdering if _ct.order_is_numeric?
       end
     end
   end

data/lib/closure_tree/deterministic_ordering.rb

@@ -1,49 +1,19 @@
 module ClosureTree
   module DeterministicOrdering
-    extend ActiveSupport::Concern
-
-    module ClassAndInstanceMethods
-      def order_column
-        o = order_option
-        o.split(' ', 2).first if o
-      end
-
-      def require_order_column
-        raise ":order value, '#{order_option}', isn't a column" if order_column.nil?
-      end
-
-      def order_column_sym
-        require_order_column
-        order_column.to_sym
-      end
-
-      def quoted_order_column(include_table_name = true)
-        require_order_column
-        prefix = include_table_name ? "#{quoted_table_name}." : ""
-        "#{prefix}#{connection.quote_column_name(order_column)}"
-      end
-    end
-
-    include ClassAndInstanceMethods
-
-    module ClassMethods
-      include ClassAndInstanceMethods
-    end
-
     def order_value
-      read_attribute(order_column_sym)
+      read_attribute(_ct.order_column_sym)
     end
 
     def order_value=(new_order_value)
-      write_attribute(order_column_sym, new_order_value)
+      write_attribute(_ct.order_column_sym, new_order_value)
     end
 
     def siblings_before
-      siblings.where(["#{quoted_order_column} < ?", order_value])
+      siblings.where(["#{_ct.quoted_order_column} < ?", order_value])
     end
 
     def siblings_after
-      siblings.where(["#{quoted_order_column} > ?", order_value])
+      siblings.where(["#{_ct.quoted_order_column} > ?", order_value])
     end
   end
-end
+end

data/lib/closure_tree/model.rb

@@ -11,45 +11,50 @@ module ClosureTree
       before_destroy :ct_before_destroy
 
       belongs_to :parent,
-        :class_name => ct_class.to_s,
-        :foreign_key => parent_column_name
+        :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
 
-      has_many :children, with_order_option(
-        :class_name => ct_class.to_s,
-        :foreign_key => parent_column_name,
-        :dependent => closure_tree_options[:dependent]
-      )
+      has_many :children, _ct.with_order_option(
+        :class_name => _ct.model_class.to_s,
+        :foreign_key => _ct.parent_column_name,
+        :dependent => _ct.options[:dependent])
 
       has_many :ancestor_hierarchies,
-        :class_name => hierarchy_class_name,
+        :class_name => _ct.hierarchy_class_name,
         :foreign_key => "descendant_id",
-        :order => "#{quoted_hierarchy_table_name}.generations asc"
+        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc"
 
       has_many :self_and_ancestors,
         :through => :ancestor_hierarchies,
         :source => :ancestor,
-        :order => "#{quoted_hierarchy_table_name}.generations asc"
+        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc"
 
       has_many :descendant_hierarchies,
-        :class_name => hierarchy_class_name,
+        :class_name => _ct.hierarchy_class_name,
         :foreign_key => "ancestor_id",
-        :order => "#{quoted_hierarchy_table_name}.generations asc"
+        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc"
+
       # 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,
+      has_many :self_and_descendants, _ct.with_order_option(
         :through => :descendant_hierarchies,
         :source => :descendant,
-        :order => append_order("#{quoted_hierarchy_table_name}.generations asc")
+        :order => "#{_ct.quoted_hierarchy_table_name}.generations asc")
+    end
+
+    # Delegate to the Support instance on the class:
+    def _ct
+      self.class._ct
     end
 
     # Returns true if this node has no parents.
     def root?
-      ct_parent_id.nil?
+      parent_id.nil?
     end
 
     # Returns true if this node has a parent, and is not a root.
@@ -64,7 +69,7 @@ module ClosureTree
 
     # Returns the farthest ancestor, or self if +root?+
     def root
-      self_and_ancestors.where(parent_column_name.to_sym => nil).first
+      self_and_ancestors.where(_ct.parent_column_name.to_sym => nil).first
     end
 
     def leaves
@@ -82,18 +87,18 @@ module ClosureTree
     end
 
     def ancestor_ids
-      ids_from(ancestors)
+      _ct.ids_from(ancestors)
     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)
+    def ancestry_path(to_s_column = _ct.name_column)
       self_and_ancestors.reverse.collect { |n| n.send to_s_column.to_sym }
     end
 
     def child_ids
-      ids_from(children)
+      _ct.ids_from(children)
     end
 
     def descendants
@@ -101,12 +106,12 @@ module ClosureTree
     end
 
     def descendant_ids
-      ids_from(descendants)
+      _ct.ids_from(descendants)
     end
 
     def self_and_siblings
-      s = ct_base_class.where(parent_column_sym => parent)
-      order_option.present? ? s.order(quoted_order_column) : s
+      s = _ct.base_class.where(_ct.parent_column_sym => parent)
+      _ct.order_option.present? ? s.order(_ct.quoted_order_column) : s
     end
 
     def siblings
@@ -114,7 +119,7 @@ module ClosureTree
     end
 
     def sibling_ids
-      ids_from(siblings)
+      _ct.ids_from(siblings)
     end
 
     # Alias for appending to the children collection.
@@ -127,8 +132,8 @@ module ClosureTree
     # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+.
     def find_by_path(path)
       return self if path.empty?
-      parent_constraint = "#{quoted_parent_column_name} = #{ct_quote(id)}"
-      ct_class.ct_scoped_to_path(path, parent_constraint).first
+      parent_constraint = "#{_ct.quoted_parent_column_name} = #{_ct.quote(id)}"
+      self.class.ct_scoped_to_path(path, parent_constraint).first
     end
 
     # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
@@ -139,8 +144,8 @@ module ClosureTree
           child_name = subpath.shift
           return self unless child_name
           child = transaction do
-            attrs = {name_sym => child_name}
-            attrs[:type] = self.type if ct_subclass? && ct_has_type?
+            attrs = {_ct.name_sym => child_name}
+            attrs[:type] = self.type if _ct.subclass? && _ct.has_type?
             self.children.where(attrs).first || begin
               child = self.class.new(attributes.merge(attrs))
               self.children << child
@@ -153,22 +158,22 @@ module ClosureTree
     end
 
     def find_all_by_generation(generation_level)
-      s = ct_base_class.joins(<<-SQL)
+      s = _ct.base_class.joins(<<-SQL)
         INNER JOIN (
           SELECT descendant_id
-          FROM #{quoted_hierarchy_table_name}
-          WHERE ancestor_id = #{ct_quote(self.id)}
+          FROM #{_ct.quoted_hierarchy_table_name}
+          WHERE ancestor_id = #{_ct.quote(self.id)}
           GROUP BY 1
-          HAVING MAX(#{quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
-        ) AS descendants ON (#{quoted_table_name}.#{ct_base_class.primary_key} = descendants.descendant_id)
+          HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
+        ) AS descendants ON (#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} = descendants.descendant_id)
       SQL
-      order_option ? s.order(order_option) : s
+      _ct.scope_with_order(s)
     end
 
     def hash_tree_scope(limit_depth = nil)
       scope = self_and_descendants
       if limit_depth
-        scope.where("#{quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}")
+        scope.where("#{_ct.quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}")
       else
         scope
       end
@@ -178,15 +183,15 @@ module ClosureTree
       self.class.build_hash_tree(hash_tree_scope(options[:limit_depth]))
     end
 
-    def ct_parent_id
-      read_attribute(parent_column_sym)
+    def parent_id
+      read_attribute(_ct.parent_column_sym)
     end
 
     def ct_validate
-      if changes[parent_column_name] &&
+      if changes[_ct.parent_column_name] &&
         parent.present? &&
         parent.self_and_ancestors.include?(self)
-        errors.add(parent_column_sym, "You cannot add an ancestor as a descendant")
+        errors.add(_ct.parent_column_sym, "You cannot add an ancestor as a descendant")
       end
     end
 
@@ -196,7 +201,7 @@ module ClosureTree
     end
 
     def ct_after_save
-      rebuild! if changes[parent_column_name] || @was_new_record
+      rebuild! if changes[_ct.parent_column_name] || @was_new_record
       @was_new_record = false # we aren't new anymore.
       true # don't cancel anything.
     end
@@ -207,11 +212,11 @@ module ClosureTree
         hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
         unless root?
           sql = <<-SQL
-            INSERT INTO #{quoted_hierarchy_table_name}
+            INSERT INTO #{_ct.quoted_hierarchy_table_name}
               (ancestor_id, descendant_id, generations)
-            SELECT x.ancestor_id, #{ct_quote(id)}, x.generations + 1
-            FROM #{quoted_hierarchy_table_name} x
-            WHERE x.descendant_id = #{ct_quote(self.ct_parent_id)}
+            SELECT x.ancestor_id, #{_ct.quote(id)}, x.generations + 1
+            FROM #{_ct.quoted_hierarchy_table_name} x
+            WHERE x.descendant_id = #{_ct.quote(self.parent_id)}
           SQL
           connection.execute sql.strip
         end
@@ -221,7 +226,7 @@ module ClosureTree
 
     def ct_before_destroy
       delete_hierarchy_references
-      if closure_tree_options[:dependent] == :nullify
+      if _ct.options[:dependent] == :nullify
         children.each { |c| c.rebuild! }
       end
     end
@@ -232,36 +237,25 @@ module ClosureTree
       # 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
-        DELETE FROM #{quoted_hierarchy_table_name}
+        DELETE FROM #{_ct.quoted_hierarchy_table_name}
         WHERE descendant_id IN (
           SELECT DISTINCT descendant_id
-          FROM ( SELECT descendant_id
-            FROM #{quoted_hierarchy_table_name}
-            WHERE ancestor_id = #{ct_quote(id)}
+          FROM (SELECT descendant_id
+            FROM #{_ct.quoted_hierarchy_table_name}
+            WHERE ancestor_id = #{_ct.quote(id)}
           ) AS x )
-          OR descendant_id = #{ct_quote(id)}
+          OR descendant_id = #{_ct.quote(id)}
       SQL
     end
 
     def without_self(scope)
       return scope if self.new_record?
-      scope.where(["#{quoted_table_name}.#{ct_base_class.primary_key} != ?", self])
-    end
-
-    def ids_from(scope)
-      if scope.respond_to? :pluck
-        scope.pluck(:id)
-      else
-        scope.select(:id).collect(&:id)
-      end
+      scope.where(["#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} != ?", self])
     end
 
-    # TODO: _parent_id will be removed in the next major version
-    alias :_parent_id :ct_parent_id
-
     module ClassMethods
       def roots
-        scope_with_order(where(parent_column_name => nil))
+        _ct.scope_with_order(where(_ct.parent_column_name => nil))
       end
 
       # Returns an arbitrary node that has no parents.
@@ -279,12 +273,12 @@ module ClosureTree
         s = joins(<<-SQL)
           INNER JOIN (
             SELECT ancestor_id
-            FROM #{quoted_hierarchy_table_name}
+            FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY 1
-            HAVING MAX(#{quoted_hierarchy_table_name}.generations) = 0
-          ) AS leaves ON (#{quoted_table_name}.#{primary_key} = leaves.ancestor_id)
+            HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = 0
+          ) AS leaves ON (#{_ct.quoted_table_name}.#{primary_key} = leaves.ancestor_id)
         SQL
-        order_option ? s.order(order_option) : s
+        _ct.scope_with_order(s)
       end
 
       # Rebuilds the hierarchy table based on the parent_id column in the database.
@@ -301,39 +295,39 @@ module ClosureTree
         s = joins(<<-SQL)
           INNER JOIN (
             SELECT #{primary_key} as root_id
-            FROM #{quoted_table_name}
-            WHERE #{quoted_parent_column_name} IS NULL
+            FROM #{_ct.quoted_table_name}
+            WHERE #{_ct.quoted_parent_column_name} IS NULL
           ) AS roots ON (1 = 1)
           INNER JOIN (
             SELECT ancestor_id, descendant_id
-            FROM #{quoted_hierarchy_table_name}
+            FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY 1, 2
             HAVING MAX(generations) = #{generation_level.to_i}
           ) AS descendants ON (
-            #{quoted_table_name}.#{primary_key} = descendants.descendant_id
+            #{_ct.quoted_table_name}.#{primary_key} = descendants.descendant_id
             AND roots.root_id = descendants.ancestor_id
           )
         SQL
-        order_option ? s.order(order_option) : s
+        _ct.scope_with_order(s)
       end
 
       # Find the node whose +ancestry_path+ is +path+
       def find_by_path(path)
-        parent_constraint = "#{quoted_parent_column_name} IS NULL"
+        parent_constraint = "#{_ct.quoted_parent_column_name} IS NULL"
         ct_scoped_to_path(path, parent_constraint).first
       end
 
       def ct_scoped_to_path(path, parent_constraint)
         path = path.is_a?(Enumerable) ? path.dup : [path]
-        scope = scoped.where(name_sym => path.last).readonly(false)
+        scope = scoped.where(_ct.name_sym => path.last).readonly(false)
         path[0..-2].reverse.each_with_index do |ea, idx|
-          subtable = idx == 0 ? quoted_table_name : "p#{idx - 1}"
+          subtable = idx == 0 ? _ct.quoted_table_name : "p#{idx - 1}"
           scope = scope.joins(<<-SQL)
-            INNER JOIN #{quoted_table_name} AS p#{idx} ON p#{idx}.id = #{subtable}.#{parent_column_name}
+            INNER JOIN #{_ct.quoted_table_name} AS p#{idx} ON p#{idx}.id = #{subtable}.#{_ct.parent_column_name}
           SQL
-          scope = scope.where("p#{idx}.#{quoted_name_column} = #{ct_quote(ea)}")
+          scope = scope.where("p#{idx}.#{_ct.quoted_name_column} = #{_ct.quote(ea)}")
         end
-        root_table_name = path.size > 1 ? "p#{path.size - 2}" : quoted_table_name
+        root_table_name = path.size > 1 ? "p#{path.size - 2}" : _ct.quoted_table_name
         scope.where("#{root_table_name}.#{parent_constraint}")
       end
 
@@ -345,8 +339,8 @@ module ClosureTree
           ct_with_advisory_lock do
             # shenanigans because find_or_create can't infer we want the same class as this:
             # Note that roots will already be constrained to this subclass (in the case of polymorphism):
-            root = roots.where(name_sym => root_name).first
-            root ||= create!(attributes.merge(name_sym => root_name))
+            root = roots.where(_ct.name_sym => root_name).first
+            root ||= create!(attributes.merge(_ct.name_sym => root_name))
             root.find_or_create_by_path(subpath, attributes)
           end
         end
@@ -358,13 +352,13 @@ module ClosureTree
         generation_depth = <<-SQL
           INNER JOIN (
             SELECT descendant_id, MAX(generations) as depth
-            FROM #{quoted_hierarchy_table_name}
+            FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY descendant_id
             #{limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ""}
           ) AS generation_depth
-            ON #{quoted_table_name}.#{primary_key} = generation_depth.descendant_id
+            ON #{_ct.quoted_table_name}.#{primary_key} = generation_depth.descendant_id
         SQL
-        scoped.joins(generation_depth).order(append_order("generation_depth.depth"))
+        _ct.scope_with_order(joins(generation_depth), "generation_depth.depth")
       end
 
       # Builds nested hash structure using the scope returned from the passed in scope
@@ -377,7 +371,7 @@ module ClosureTree
           if ea.root? || tree.empty? # We're at the top of the tree.
             tree[ea] = h
           else
-            id_to_hash[ea.ct_parent_id][ea] = h
+            id_to_hash[ea.parent_id][ea] = h
           end
         end
         tree

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -9,21 +9,21 @@ module ClosureTree
         SELECT
           count(*) as total_descendants,
           max(generations) as max_depth
-        FROM #{quoted_hierarchy_table_name}
-        WHERE ancestor_id = #{ct_quote(self.id)}
+        FROM #{_ct.quoted_hierarchy_table_name}
+        WHERE ancestor_id = #{_ct.quote(self.id)}
       SQL
       join_sql = <<-SQL
-        JOIN #{quoted_hierarchy_table_name} anc_hier
-          ON anc_hier.descendant_id = #{quoted_hierarchy_table_name}.descendant_id
-        JOIN #{quoted_table_name} anc
+        JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
+          ON anc_hier.descendant_id = #{_ct.quoted_hierarchy_table_name}.descendant_id
+        JOIN #{_ct.quoted_table_name} anc
           ON anc.id = anc_hier.ancestor_id
-        JOIN #{quoted_hierarchy_table_name} depths
-          ON depths.ancestor_id = #{ct_quote(self.id)} AND depths.descendant_id = anc.id
+        JOIN #{_ct.quoted_hierarchy_table_name} depths
+          ON depths.ancestor_id = #{_ct.quote(self.id)} AND depths.descendant_id = anc.id
       SQL
-      node_score = "(1 + anc.#{quoted_order_column(false)}) * " +
+      node_score = "(1 + anc.#{_ct.quoted_order_column(false)}) * " +
         "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - depths.generations)"
       order_by = "sum(#{node_score})"
-      self_and_descendants.joins(join_sql).group("#{quoted_table_name}.id").reorder(order_by)
+      self_and_descendants.joins(join_sql).group("#{_ct.quoted_table_name}.id").reorder(order_by)
     end
 
     module ClassMethods
@@ -32,23 +32,23 @@ module ClosureTree
           SELECT
             count(*) as total_descendants,
             max(generations) as max_depth
-          FROM #{quoted_hierarchy_table_name}
+          FROM #{_ct.quoted_hierarchy_table_name}
         SQL
         join_sql = <<-SQL
-          JOIN #{quoted_hierarchy_table_name} anc_hier
-            ON anc_hier.descendant_id = #{quoted_table_name}.id
-          JOIN #{quoted_table_name} anc
+          JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
+            ON anc_hier.descendant_id = #{_ct.quoted_table_name}.id
+          JOIN #{_ct.quoted_table_name} anc
             ON anc.id = anc_hier.ancestor_id
           JOIN (
             SELECT descendant_id, max(generations) AS max_depth
-            FROM #{quoted_hierarchy_table_name}
+            FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY 1
           ) AS depths ON depths.descendant_id = anc.id
         SQL
-        node_score = "(1 + anc.#{quoted_order_column(false)}) * " +
+        node_score = "(1 + anc.#{_ct.quoted_order_column(false)}) * " +
           "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - depths.max_depth)"
         order_by = "sum(#{node_score})"
-        joins(join_sql).group("#{quoted_table_name}.id").reorder(order_by)
+        joins(join_sql).group("#{_ct.quoted_table_name}.id").reorder(order_by)
       end
     end
 
@@ -69,12 +69,12 @@ module ClosureTree
         sibling_node.order_value = self.order_value.to_i + (add_after ? 1 : -1)
         # We need to incr the before_siblings to make room for sibling_node:
         if use_update_all
-          col = quoted_order_column(false)
+          col = _ct.quoted_order_column(false)
           # issue 21: we have to use the base class, so STI doesn't get in the way of only updating the child class instances:
-          ct_base_class.update_all(
+          _ct.base_class.update_all(
             ["#{col} = #{col} #{add_after ? '+' : '-'} 1", "updated_at = now()"],
-            ["#{quoted_parent_column_name} = ? AND #{col} #{add_after ? '>=' : '<='} ?",
-              ct_parent_id,
+            ["#{_ct.quoted_parent_column_name} = ? AND #{col} #{add_after ? '>=' : '<='} ?",
+              parent_id,
               sibling_node.order_value])
         else
           last_value = sibling_node.order_value.to_i
@@ -90,4 +90,4 @@ module ClosureTree
       end
     end
   end
-end
+end

data/lib/closure_tree/support.rb

@@ -0,0 +1,193 @@
+module ClosureTree
+  class Support
+
+    attr_reader :model_class
+    attr_reader :options
+
+    def initialize(model_class, options)
+      @model_class = model_class
+      @options = {
+        :base_class => model_class,
+        :parent_column_name => 'parent_id',
+        :dependent => :nullify, # or :destroy or :delete_all -- see the README
+        :name_column => 'name',
+        :with_advisory_lock => true
+      }.merge(options)
+
+      raise IllegalArgumentException, "name_column can't be 'path'" if options[:name_column] == 'path'
+
+    end
+
+    def connection
+      model_class.connection
+    end
+
+    def hierarchy_class_for_model
+      hierarchy_class = model_class.parent.const_set(short_hierarchy_class_name, Class.new(ActiveRecord::Base))
+      hierarchy_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        belongs_to :ancestor, :class_name => "#{model_class}"
+        belongs_to :descendant, :class_name => "#{model_class}"
+        attr_accessible :ancestor, :descendant, :generations
+        def ==(other)
+          self.class == other.class && ancestor_id == other.ancestor_id && descendant_id == other.descendant_id
+        end
+        alias :eql? :==
+        def hash
+          ancestor_id.hash << 31 ^ descendant_id.hash
+        end
+      RUBY
+      hierarchy_class.table_name = hierarchy_table_name
+      hierarchy_class
+    end
+
+    def parent_column_name
+      options[:parent_column_name]
+    end
+
+    def parent_column_sym
+      parent_column_name.to_sym
+    end
+
+    def has_name?
+      model_class.new.attributes.include? options[:name_column]
+    end
+
+    def name_column
+      options[:name_column]
+    end
+
+    def name_sym
+      name_column.to_sym
+    end
+
+    def hierarchy_table_name
+      # We need to use the table_name, not something like ct_class.to_s.demodulize + "_hierarchies",
+      # because they may have overridden the table name, which is what we want to be consistent with
+      # in order for the schema to make sense.
+      tablename = options[:hierarchy_table_name] ||
+        remove_prefix_and_suffix(table_name).singularize + "_hierarchies"
+
+      ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
+    end
+
+    def hierarchy_class_name
+      options[:hierarchy_class_name] || model_class.to_s + "Hierarchy"
+    end
+
+    # Returns the constant name of the hierarchy_class
+    #
+    # @return [String] the constant name
+    #
+    # @example
+    #   Namespace::Model.hierarchy_class_name # => "Namespace::ModelHierarchy"
+    #   Namespace::Model.short_hierarchy_class_name # => "ModelHierarchy"
+    def short_hierarchy_class_name
+      hierarchy_class_name.split('::').last
+    end
+
+    def quoted_hierarchy_table_name
+      connection.quote_table_name hierarchy_table_name
+    end
+
+    def quoted_parent_column_name
+      connection.quote_column_name parent_column_name
+    end
+
+    def quoted_name_column
+      connection.quote_column_name name_column
+    end
+
+    def quote(field)
+      connection.quote(field)
+    end
+
+    def order_option
+      options[:order]
+    end
+
+    def with_order_option(options)
+      order_option ? options.merge(:order => order_option) : options
+    end
+
+    def scope_with_order(scope, additional_order_by = nil)
+      if order_option
+        scope.order(*([additional_order_by, order_option].compact))
+      else
+        scope
+      end
+    end
+
+    def with_order_option(options)
+      if order_option
+        options[:order] = [options[:order], order_option].compact.join(",")
+      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.nil? || !model_class.table_exists?
+      c = model_class.columns_hash[order_option]
+      c && c.type == :integer
+    end
+
+    def order_column
+      o = order_option
+      o.split(' ', 2).first if o
+    end
+
+    def require_order_column
+      raise ":order value, '#{order_option}', isn't a column" if order_column.nil?
+    end
+
+    def order_column_sym
+      require_order_column
+      order_column.to_sym
+    end
+
+    def quoted_order_column(include_table_name = true)
+      require_order_column
+      prefix = include_table_name ? "#{quoted_table_name}." : ""
+      "#{prefix}#{connection.quote_column_name(order_column)}"
+    end
+
+    # This is the "topmost" class. This will only potentially not be ct_class if you are using STI.
+    def base_class
+      options[:base_class]
+    end
+
+    def subclass?
+      model_class != model_class.base_class
+    end
+
+    def attribute_names
+      @attribute_names ||= model_class.new.attributes.keys - model_class.protected_attributes.to_a
+    end
+
+    def has_type?
+      attribute_names.include? 'type'
+    end
+
+    def table_name
+      model_class.table_name
+    end
+
+    def quoted_table_name
+      connection.quote_table_name table_name
+    end
+
+    def remove_prefix_and_suffix(table_name)
+      prefix = Regexp.escape(ActiveRecord::Base.table_name_prefix)
+      suffix = Regexp.escape(ActiveRecord::Base.table_name_suffix)
+      table_name.gsub(/^#{prefix}(.+)#{suffix}$/, "\\1")
+    end
+
+    def ids_from(scope)
+      if scope.respond_to? :pluck
+        scope.pluck(:id)
+      else
+        scope.select(:id).collect(&:id)
+      end
+    end
+  end
+end

data/lib/closure_tree/version.rb

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

data/lib/closure_tree/with_advisory_lock.rb

@@ -1,18 +1,28 @@
 require 'with_advisory_lock'
+require 'active_support/concern'
 
 module ClosureTree
   module WithAdvisoryLock
+    extend ActiveSupport::Concern
+
     def ct_with_advisory_lock(&block)
-      if closure_tree_options[:with_advisory_lock]
-        with_advisory_lock("closure_tree") do
-          transaction do
+      self.class.ct_with_advisory_lock(&block)
+    end
+
+    included do
+      class_eval do
+        def self.ct_with_advisory_lock(&block)
+          if _ct.options[:with_advisory_lock]
+            with_advisory_lock("closure_tree") do
+              transaction do
+                yield
+              end
+            end
+          else
             yield
           end
         end
-      else
-        yield
       end
     end
   end
 end
-

data/spec/namespace_type_spec.rb

@@ -5,8 +5,8 @@ describe Namespace::Type do
   context "class injection" do
     it "should build hierarchy classname correctly" do
       Namespace::Type.hierarchy_class.to_s.should == "Namespace::TypeHierarchy"
-      Namespace::Type.hierarchy_class_name.should == "Namespace::TypeHierarchy"
-      Namespace::Type.short_hierarchy_class_name.should == "TypeHierarchy"
+      Namespace::Type._ct.hierarchy_class_name.should == "Namespace::TypeHierarchy"
+      Namespace::Type._ct.short_hierarchy_class_name.should == "TypeHierarchy"
     end
   end
 

data/spec/parallel_spec.rb

@@ -6,7 +6,7 @@ describe "threadhot" do
     TagHierarchy.delete_all
     Tag.delete_all
     @iterations = 5
-    @workers = 8
+    @workers = 6 # Travis CI workers can't reliably handle larger numbers
     @parent = nil
   end
 

data/spec/spec_helper.rb

@@ -54,4 +54,4 @@ RSpec.configure do |config|
   config.after(:all) do
     FileUtils.remove_entry_secure ENV['FLOCK_DIR']
   end
-end
+end

data/spec/tag_spec.rb

@@ -259,12 +259,12 @@ shared_examples_for "Tag (2)" do
     context "class injection" do
       it "should build hierarchy classname correctly" do
         Tag.hierarchy_class.to_s.should == "TagHierarchy"
-        Tag.hierarchy_class_name.should == "TagHierarchy"
-        Tag.short_hierarchy_class_name.should == "TagHierarchy"
+        Tag._ct.hierarchy_class_name.should == "TagHierarchy"
+        Tag._ct.short_hierarchy_class_name.should == "TagHierarchy"
       end
 
       it "should have a correct parent column name" do
-        Tag.parent_column_name.should == "parent_id"
+        Tag._ct.parent_column_name.should == "parent_id"
       end
     end
 
@@ -469,7 +469,7 @@ describe "Tag with UUID" do
     TagHierarchy.reset_column_information
 
     # We have to reset a few other caches
-    Tag.closure_tree_options[:hierarchy_table_name] = 'tag_hierarchies_uuid'
+    Tag._ct.options[:hierarchy_table_name] = 'tag_hierarchies_uuid'
     Tag.reflections.each do |key, ref|
       ref.instance_variable_set('@table_name', nil)
       ref.instance_variable_set('@quoted_table_name', nil)

data/spec/user_spec.rb

@@ -116,7 +116,7 @@ describe "empty db" do
   end
 
   it "supports siblings" do
-    User.order_option.should be_nil
+    User._ct.order_option.should be_nil
     a = User.create(:email => "a")
     b1 = a.children.create(:email => "b1")
     b2 = a.children.create(:email => "b2")
@@ -127,7 +127,7 @@ describe "empty db" do
 
   context "when a user is not yet saved" do
     it "supports siblings" do
-      User.order_option.should be_nil
+      User._ct.order_option.should be_nil
       a = User.create(:email => "a")
       b1 = a.children.new(:email => "b1")
       b2 = a.children.create(:email => "b2")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: closure_tree
 version: !ruby/object:Gem::Version 
-  hash: 43
+  hash: 63
   prerelease: 
   segments: 
-  - 3
-  - 10
-  - 2
-  version: 3.10.2
+  - 4
+  - 0
+  - 0
+  version: 4.0.0
 platform: ruby
 authors: 
 - Matthew McEachen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-04-16 00:00:00 -07:00
+date: 2013-05-18 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -201,10 +201,10 @@ extra_rdoc_files: []
 
 files: 
 - lib/closure_tree/acts_as_tree.rb
-- lib/closure_tree/columns.rb
 - lib/closure_tree/deterministic_ordering.rb
 - lib/closure_tree/model.rb
 - lib/closure_tree/numeric_deterministic_ordering.rb
+- lib/closure_tree/support.rb
 - lib/closure_tree/version.rb
 - lib/closure_tree/with_advisory_lock.rb
 - lib/closure_tree.rb

data/lib/closure_tree/columns.rb

@@ -1,127 +0,0 @@
-module ClosureTree
-
-  # Mixed into both classes and instances to provide easy access to the column names
-  module Columns
-
-    def parent_column_name
-      closure_tree_options[:parent_column_name]
-    end
-
-    def parent_column_sym
-      parent_column_name.to_sym
-    end
-
-    def has_name?
-      ct_class.new.attributes.include? closure_tree_options[:name_column]
-    end
-
-    def name_column
-      closure_tree_options[:name_column]
-    end
-
-    def name_sym
-      name_column.to_sym
-    end
-
-    def hierarchy_table_name
-      # We need to use the table_name, not something like ct_class.to_s.demodulize + "_hierarchies",
-      # because they may have overridden the table name, which is what we want to be consistent with
-      # in order for the schema to make sense.
-      tablename = closure_tree_options[:hierarchy_table_name] ||
-        remove_prefix_and_suffix(ct_table_name).singularize + "_hierarchies"
-
-      ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
-    end
-
-    def hierarchy_class_name
-      closure_tree_options[:hierarchy_class_name] || ct_class.to_s + "Hierarchy"
-    end
-
-
-    #
-    # Returns the constant name of the hierarchy_class
-    #
-    # @return [String] the constant name
-    #
-    # @example
-    #   Namespace::Model.hierarchy_class_name # => "Namespace::ModelHierarchy"
-    #   Namespace::Model.short_hierarchy_class_name # => "ModelHierarchy"
-    def short_hierarchy_class_name
-      hierarchy_class_name.split('::').last
-    end
-
-    def quoted_hierarchy_table_name
-      connection.quote_table_name hierarchy_table_name
-    end
-
-    def quoted_parent_column_name
-      connection.quote_column_name parent_column_name
-    end
-
-    def quoted_name_column
-      connection.quote_column_name name_column
-    end
-
-    def ct_quote(field)
-      connection.quote(field)
-    end
-
-    def order_option
-      closure_tree_options[:order]
-    end
-
-    def with_order_option(options)
-      order_option ? options.merge(:order => order_option) : options
-    end
-
-    def scope_with_order(scope)
-      order_option ? scope.order(order_option) : scope
-    end
-
-    def append_order(order_by)
-      order_option ? "#{order_by}, #{order_option}" : order_by
-    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.nil? || !self.table_exists?
-      c = ct_class.columns_hash[order_option]
-      c && c.type == :integer
-    end
-
-    def ct_class
-      (self.is_a?(Class) ? self : self.class)
-    end
-
-    # This is the "topmost" class. This will only potentially not be ct_class if you are using STI.
-    def ct_base_class
-      ct_class.closure_tree_options[:ct_base_class]
-    end
-
-    def ct_subclass?
-      ct_class != ct_class.base_class
-    end
-
-    def ct_attribute_names
-      @ct_attr_names ||= ct_class.new.attributes.keys - ct_class.protected_attributes.to_a
-    end
-
-    def ct_has_type?
-      ct_attribute_names.include? 'type'
-    end
-
-    def ct_table_name
-      ct_class.table_name
-    end
-
-    def quoted_table_name
-      connection.quote_table_name ct_table_name
-    end
-
-    def remove_prefix_and_suffix(table_name)
-      prefix = Regexp.escape(ActiveRecord::Base.table_name_prefix)
-      suffix = Regexp.escape(ActiveRecord::Base.table_name_suffix)
-      table_name.gsub(/^#{prefix}(.+)#{suffix}$/, "\\1")
-    end
-  end
-end