ancestry 2.2.2 → 3.0.0

data/lib/ancestry.rb

@@ -2,7 +2,8 @@ require_relative 'ancestry/class_methods'
 require_relative 'ancestry/instance_methods'
 require_relative 'ancestry/exceptions'
 require_relative 'ancestry/has_ancestry'
+require_relative 'ancestry/materialized_path'
 
 module Ancestry
   ANCESTRY_PATTERN = /\A[0-9]+(\/[0-9]+)*\Z/
-end
+end

data/lib/ancestry/class_methods.rb

@@ -29,14 +29,8 @@ module Ancestry
 
     # Arrangement
     def arrange options = {}
-      scope =
-        if options[:order].nil?
-          self.ancestry_base_class.ordered_by_ancestry
-        else
-          self.ancestry_base_class.ordered_by_ancestry_and options.delete(:order)
-        end
       # Get all nodes ordered by ancestry and start sorting them into an empty hash
-      arrange_nodes scope.where(options)
+      arrange_nodes self.ancestry_base_class.reorder(options.delete(:order)).where(options)
     end
 
     # Arrange array of nodes into a nested hash of the form

data/lib/ancestry/has_ancestry.rb

@@ -1,104 +1,105 @@
-class << ActiveRecord::Base
-  def has_ancestry options = {}
-    # Check options
-    raise Ancestry::AncestryException.new("Options for has_ancestry must be in a hash.") unless options.is_a? Hash
-    options.each do |key, value|
-      unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch].include? key
-        raise Ancestry::AncestryException.new("Unknown option for has_ancestry: #{key.inspect} => #{value.inspect}.")
+module Ancestry
+  module HasAncestry
+    def has_ancestry options = {}
+      # Check options
+      raise Ancestry::AncestryException.new("Options for has_ancestry must be in a hash.") unless options.is_a? Hash
+      options.each do |key, value|
+        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch].include? key
+          raise Ancestry::AncestryException.new("Unknown option for has_ancestry: #{key.inspect} => #{value.inspect}.")
+        end
       end
-    end
 
-    # Include instance methods
-    include Ancestry::InstanceMethods
-
-    # Include dynamic class methods
-    extend Ancestry::ClassMethods
-
-    # Create ancestry column accessor and set to option or default
-    cattr_accessor :ancestry_column
-    self.ancestry_column = options[:ancestry_column] || :ancestry
-
-    # Create orphan strategy accessor and set to option or default (writer comes from DynamicClassMethods)
-    cattr_reader :orphan_strategy
-    self.orphan_strategy = options[:orphan_strategy] || :destroy
-
-    # Save self as base class (for STI)
-    cattr_accessor :ancestry_base_class
-    self.ancestry_base_class = self
-
-    # Touch ancestors after updating
-    cattr_accessor :touch_ancestors
-    self.touch_ancestors = options[:touch] || false
-
-    # Validate format of ancestry column value
-    validates_format_of ancestry_column, :with => Ancestry::ANCESTRY_PATTERN, :allow_nil => true
-
-    # Validate that the ancestor ids don't include own id
-    validate :ancestry_exclude_self
-
-    # Named scopes
-    scope :roots, lambda { where(ancestry_column => nil) }
-    scope :ancestors_of, lambda { |object| where(to_node(object).ancestor_conditions) }
-    scope :children_of, lambda { |object| where(to_node(object).child_conditions) }
-    scope :descendants_of, lambda { |object| where(to_node(object).descendant_conditions) }
-    scope :subtree_of, lambda { |object| where(to_node(object).subtree_conditions) }
-    scope :siblings_of, lambda { |object| where(to_node(object).sibling_conditions) }
-    scope :ordered_by_ancestry, lambda {
-      if %w(mysql mysql2 sqlite postgresql).include?(connection.adapter_name.downcase) &&
-        defined?(ActiveRecord.version) && ActiveRecord.version.to_s >= "5"
-        reorder("coalesce(#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}, '')")
-      else
-        reorder("(CASE WHEN #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)} IS NULL THEN 0 ELSE 1 END), #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}")
-      end
-    }
-    scope :ordered_by_ancestry_and, lambda { |order|
-      if %w(mysql mysql2 sqlite postgresql).include?(connection.adapter_name.downcase) &&
-        defined?(ActiveRecord.version) && ActiveRecord.version.to_s >= "5"
-        reorder("coalesce(#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}, ''), #{order}")
-      else
-        reorder("(CASE WHEN #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)} IS NULL THEN 0 ELSE 1 END), #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}, #{order}")
-      end
-    }
-    scope :path_of, lambda { |object| to_node(object).path }
 
-    # Update descendants with new ancestry before save
-    before_save :update_descendants_with_new_ancestry
+      # Create ancestry column accessor and set to option or default
+      cattr_accessor :ancestry_column
+      self.ancestry_column = options[:ancestry_column] || :ancestry
 
-    # Apply orphan strategy before destroy
-    before_destroy :apply_orphan_strategy
+      # Save self as base class (for STI)
+      cattr_accessor :ancestry_base_class
+      self.ancestry_base_class = self
 
-    # Create ancestry column accessor and set to option or default
-    if options[:cache_depth]
-      # Create accessor for column name and set to option or default
-      self.cattr_accessor :depth_cache_column
-      self.depth_cache_column = options[:depth_cache_column] || :ancestry_depth
+      # Touch ancestors after updating
+      cattr_accessor :touch_ancestors
+      self.touch_ancestors = options[:touch] || false
 
-      # Cache depth in depth cache column before save
-      before_validation :cache_depth
-      before_save :cache_depth
+      # Include instance methods
+      include Ancestry::InstanceMethods
 
-      # Validate depth column
-      validates_numericality_of depth_cache_column, :greater_than_or_equal_to => 0, :only_integer => true, :allow_nil => false
-    end
+      # Include dynamic class methods
+      extend Ancestry::ClassMethods
 
-    # Create named scopes for depth
-    {:before_depth => '<', :to_depth => '<=', :at_depth => '=', :from_depth => '>=', :after_depth => '>'}.each do |scope_name, operator|
-      scope scope_name, lambda { |depth|
-        raise Ancestry::AncestryException.new("Named scope '#{scope_name}' is only available when depth caching is enabled.") unless options[:cache_depth]
-        where("#{depth_cache_column} #{operator} ?", depth)
+      extend Ancestry::MaterializedPath
+
+      # Create orphan strategy accessor and set to option or default (writer comes from DynamicClassMethods)
+      cattr_reader :orphan_strategy
+      self.orphan_strategy = options[:orphan_strategy] || :destroy
+
+      # Validate that the ancestor ids don't include own id
+      validate :ancestry_exclude_self
+
+      # Named scopes
+      scope :roots, lambda { where(root_conditions) }
+      scope :ancestors_of, lambda { |object| where(ancestor_conditions(object)) }
+      scope :path_of, lambda { |object| where(path_conditions(object)) }
+      scope :children_of, lambda { |object| where(child_conditions(object)) }
+      scope :descendants_of, lambda { |object| where(descendant_conditions(object)) }
+      scope :subtree_of, lambda { |object| where(subtree_conditions(object)) }
+      scope :siblings_of, lambda { |object| where(sibling_conditions(object)) }
+      scope :ordered_by_ancestry, Proc.new { |order|
+        if %w(mysql mysql2 sqlite sqlite3 postgresql).include?(connection.adapter_name.downcase) && ActiveRecord::VERSION::MAJOR >= 5
+          reorder("coalesce(#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}, '')", order)
+        else
+          reorder("(CASE WHEN #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)} IS NULL THEN 0 ELSE 1 END), #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}", order)
+        end
       }
+      scope :ordered_by_ancestry_and, Proc.new { |order| ordered_by_ancestry_and(order) }
+      scope :path_of, lambda { |object| to_node(object).path }
+
+      # Update descendants with new ancestry before save
+      before_save :update_descendants_with_new_ancestry
+
+      # Apply orphan strategy before destroy
+      before_destroy :apply_orphan_strategy
+
+      # Create ancestry column accessor and set to option or default
+      if options[:cache_depth]
+        # Create accessor for column name and set to option or default
+        self.cattr_accessor :depth_cache_column
+        self.depth_cache_column = options[:depth_cache_column] || :ancestry_depth
+
+        # Cache depth in depth cache column before save
+        before_validation :cache_depth
+        before_save :cache_depth
+
+        # Validate depth column
+        validates_numericality_of depth_cache_column, :greater_than_or_equal_to => 0, :only_integer => true, :allow_nil => false
+      end
+
+      # Create named scopes for depth
+      {:before_depth => '<', :to_depth => '<=', :at_depth => '=', :from_depth => '>=', :after_depth => '>'}.each do |scope_name, operator|
+        scope scope_name, lambda { |depth|
+          raise Ancestry::AncestryException.new("Named scope '#{scope_name}' is only available when depth caching is enabled.") unless options[:cache_depth]
+          where("#{depth_cache_column} #{operator} ?", depth)
+        }
+      end
+
+      after_touch :touch_ancestors_callback
+      after_destroy :touch_ancestors_callback
+
+      if ActiveRecord::VERSION::STRING >= '5.1.0'
+        after_save :touch_ancestors_callback, if: :saved_changes?
+      else
+        after_save :touch_ancestors_callback, if: :changed?
+      end
     end
 
-    after_touch :touch_ancestors_callback
-    after_destroy :touch_ancestors_callback
-    after_save :touch_ancestors_callback, if: :changed?
+    def acts_as_tree(*args)
+      return super if defined?(super)
+      has_ancestry(*args)
+    end
   end
 end
 
 ActiveSupport.on_load :active_record do
-  if not(ActiveRecord::Base.respond_to?(:acts_as_tree))
-    class << ActiveRecord::Base
-      alias_method :acts_as_tree, :has_ancestry
-    end
-  end
+  send :extend, Ancestry::HasAncestry
 end

data/lib/ancestry/instance_methods.rb

@@ -7,22 +7,19 @@ module Ancestry
 
     # Update descendants with new ancestry
     def update_descendants_with_new_ancestry
-      # Skip this if callbacks are disabled
-      unless ancestry_callbacks_disabled?
-        # If node is not a new record and ancestry was updated and the new ancestry is sane ...
-        if ancestry_changed? && !new_record? && sane_ancestry?
-          # ... for each descendant ...
-          unscoped_descendants.each do |descendant|
-            # ... replace old ancestry with new ancestry
-            descendant.without_ancestry_callbacks do
-              descendant.update_attribute(
-                self.ancestry_base_class.ancestry_column,
-                descendant.read_attribute(descendant.class.ancestry_column).gsub(
-                  /^#{self.child_ancestry}/,
-                  if read_attribute(self.class.ancestry_column).blank? then id.to_s else "#{read_attribute self.class.ancestry_column }/#{id}" end
-                )
+      # If enabled and node is existing and ancestry was updated and the new ancestry is sane ...
+      if !ancestry_callbacks_disabled? && !new_record? && ancestry_changed? && sane_ancestry?
+        # ... for each descendant ...
+        unscoped_descendants.each do |descendant|
+          # ... replace old ancestry with new ancestry
+          descendant.without_ancestry_callbacks do
+            descendant.update_attribute(
+              self.ancestry_base_class.ancestry_column,
+              descendant.read_attribute(descendant.class.ancestry_column).gsub(
+                /^#{self.child_ancestry}/,
+                if ancestors? then "#{read_attribute self.class.ancestry_column }/#{id}" else id.to_s end
               )
-            end
+            )
           end
         end
       end
@@ -30,56 +27,47 @@ module Ancestry
 
     # Apply orphan strategy
     def apply_orphan_strategy
-      # Skip this if callbacks are disabled
-      unless ancestry_callbacks_disabled?
-        # If this isn't a new record ...
-        unless new_record?
-          # ... make all children root if orphan strategy is rootify
-          if self.ancestry_base_class.orphan_strategy == :rootify
-            unscoped_descendants.each do |descendant|
-              descendant.without_ancestry_callbacks do
-                descendant.update_attribute descendant.class.ancestry_column, (if descendant.ancestry == child_ancestry then nil else descendant.ancestry.gsub(/^#{child_ancestry}\//, '') end)
+      if !ancestry_callbacks_disabled? && !new_record?
+        case self.ancestry_base_class.orphan_strategy
+        when :rootify # make all children root if orphan strategy is rootify
+          unscoped_descendants.each do |descendant|
+            descendant.without_ancestry_callbacks do
+              new_ancestry = if descendant.ancestry == child_ancestry
+                nil
+              else
+                descendant.ancestry.gsub(/^#{child_ancestry}\//, '')
               end
+              descendant.update_attribute descendant.class.ancestry_column, new_ancestry
             end
-          # ... destroy all descendants if orphan strategy is destroy
-          elsif self.ancestry_base_class.orphan_strategy == :destroy
-            unscoped_descendants.each do |descendant|
-              descendant.without_ancestry_callbacks do
-                descendant.destroy
-              end
+          end
+        when :destroy # destroy all descendants if orphan strategy is destroy
+          unscoped_descendants.each do |descendant|
+            descendant.without_ancestry_callbacks do
+              descendant.destroy
             end
-          # ... make child elements of this node, child of its parent if orphan strategy is adopt
-          elsif self.ancestry_base_class.orphan_strategy == :adopt
-            descendants.each do |descendant|
-              descendant.without_ancestry_callbacks do
-                new_ancestry = descendant.ancestor_ids.delete_if { |x| x == self.id }.join("/")
-                # check for empty string if it's then set to nil
-                new_ancestry = nil if new_ancestry.empty?
-                descendant.update_attribute descendant.class.ancestry_column, new_ancestry || nil
-              end
+          end
+        when :adopt # make child elements of this node, child of its parent
+          descendants.each do |descendant|
+            descendant.without_ancestry_callbacks do
+              new_ancestry = descendant.ancestor_ids.delete_if { |x| x == self.id }.join("/")
+              # check for empty string if it's then set to nil
+              new_ancestry = nil if new_ancestry.empty?
+              descendant.update_attribute descendant.class.ancestry_column, new_ancestry || nil
             end
-          # ... throw an exception if it has children and orphan strategy is restrict
-          elsif self.ancestry_base_class.orphan_strategy == :restrict
-            raise Ancestry::AncestryException.new('Cannot delete record because it has descendants.') unless is_childless?
           end
+        when :restrict # throw an exception if it has children
+          raise Ancestry::AncestryException.new('Cannot delete record because it has descendants.') unless is_childless?
         end
       end
     end
 
     # Touch each of this record's ancestors
     def touch_ancestors_callback
-
-      # Skip this if callbacks are disabled
-      unless ancestry_callbacks_disabled?
-
-        # Only touch if the option is enabled
-        if self.ancestry_base_class.touch_ancestors
-
-          # Touch each of the old *and* new ancestors
-          self.class.where(id: (ancestor_ids + ancestor_ids_was).uniq).each do |ancestor|
-            ancestor.without_ancestry_callbacks do
-              ancestor.touch
-            end
+      if !ancestry_callbacks_disabled? && self.ancestry_base_class.touch_ancestors
+        # Touch each of the old *and* new ancestors
+        unscoped_current_and_previous_ancestors.each do |ancestor|
+          ancestor.without_ancestry_callbacks do
+            ancestor.touch
           end
         end
       end
@@ -95,6 +83,11 @@ module Ancestry
 
     # Ancestors
 
+    def ancestors?
+      # ancestor_ids.present?
+      read_attribute(self.ancestry_base_class.ancestry_column).present?
+    end
+
     def ancestry_changed?
       changed.include?(self.ancestry_base_class.ancestry_column.to_s)
     end
@@ -108,8 +101,7 @@ module Ancestry
     end
 
     def ancestor_conditions
-      t = get_arel_table
-      t[get_primary_key_column].in(ancestor_ids)
+      self.ancestry_base_class.ancestor_conditions(self)
     end
 
     def ancestors depth_options = {}
@@ -121,7 +113,13 @@ module Ancestry
     end
 
     def ancestor_ids_was
-      parse_ancestry_column(changed_attributes[self.ancestry_base_class.ancestry_column.to_s])
+      relevant_attributes = if ActiveRecord::VERSION::STRING >= '5.1.0'
+        saved_changes.transform_values(&:first)
+      else
+        changed_attributes
+      end
+
+      parse_ancestry_column(relevant_attributes[self.ancestry_base_class.ancestry_column.to_s])
     end
 
     def path_ids
@@ -129,8 +127,7 @@ module Ancestry
     end
 
     def path_conditions
-      t = get_arel_table
-      t[get_primary_key_column].in(path_ids)
+      self.ancestry_base_class.path_conditions(self)
     end
 
     def path depth_options = {}
@@ -155,20 +152,20 @@ module Ancestry
       write_attribute(self.ancestry_base_class.ancestry_column, if parent.nil? then nil else parent.child_ancestry end)
     end
 
-    def parent_id= parent_id
-      self.parent = if parent_id.blank? then nil else unscoped_find(parent_id) end
+    def parent_id= new_parent_id
+      self.parent = new_parent_id.present? ? unscoped_find(new_parent_id) : nil
     end
 
     def parent_id
-      if ancestor_ids.empty? then nil else ancestor_ids.last end
+      ancestor_ids.last if ancestors?
     end
 
     def parent
-      if parent_id.blank? then nil else unscoped_find(parent_id) end
+      unscoped_find(parent_id) if ancestors?
     end
 
     def parent_id?
-      parent_id.present?
+      ancestors?
     end
 
     def parent_of?(node)
@@ -178,11 +175,11 @@ module Ancestry
     # Root
 
     def root_id
-      if ancestor_ids.empty? then id else ancestor_ids.first end
+      ancestors? ? ancestor_ids.first : id
     end
 
     def root
-      if root_id == id then self else unscoped_find(root_id) end
+      ancestors? ? unscoped_find(root_id) : self
     end
 
     def is_root?
@@ -197,8 +194,7 @@ module Ancestry
     # Children
 
     def child_conditions
-      t = get_arel_table
-      t[get_ancestry_column].eq(child_ancestry)
+      self.ancestry_base_class.child_conditions(self)
     end
 
     def children
@@ -206,11 +202,11 @@ module Ancestry
     end
 
     def child_ids
-      children.select(self.ancestry_base_class.primary_key).map(&self.ancestry_base_class.primary_key.to_sym)
+      children.pluck(self.ancestry_base_class.primary_key)
     end
 
     def has_children?
-      self.children.exists?({})
+      self.children.exists?
     end
     alias_method :children?, :has_children?
 
@@ -226,8 +222,7 @@ module Ancestry
     # Siblings
 
     def sibling_conditions
-      t = get_arel_table
-      t[get_ancestry_column].eq(read_attribute(self.ancestry_base_class.ancestry_column))
+      self.ancestry_base_class.sibling_conditions(self)
     end
 
     def siblings
@@ -235,7 +230,7 @@ module Ancestry
     end
 
     def sibling_ids
-      siblings.select(self.ancestry_base_class.primary_key).collect(&self.ancestry_base_class.primary_key.to_sym)
+      siblings.pluck(self.ancestry_base_class.primary_key)
     end
 
     def has_siblings?
@@ -255,13 +250,7 @@ module Ancestry
     # Descendants
 
     def descendant_conditions
-      t = get_arel_table
-      # rails has case sensitive matching.
-      if defined?(ActiveRecord.version) && ActiveRecord.version.to_s >= "5"
-        t[get_ancestry_column].matches("#{child_ancestry}/%", nil, true).or(t[get_ancestry_column].eq(child_ancestry))
-      else
-        t[get_ancestry_column].matches("#{child_ancestry}/%").or(t[get_ancestry_column].eq(child_ancestry))
-      end
+      self.ancestry_base_class.descendant_conditions(self)
     end
 
     def descendants depth_options = {}
@@ -269,7 +258,7 @@ module Ancestry
     end
 
     def descendant_ids depth_options = {}
-      descendants(depth_options).select(self.ancestry_base_class.primary_key).collect(&self.ancestry_base_class.primary_key.to_sym)
+      descendants(depth_options).pluck(self.ancestry_base_class.primary_key)
     end
 
     def descendant_of?(node)
@@ -279,8 +268,7 @@ module Ancestry
     # Subtree
 
     def subtree_conditions
-      t = get_arel_table
-      descendant_conditions.or(t[get_primary_key_column].eq(self.id))
+      self.ancestry_base_class.subtree_conditions(self)
     end
 
     def subtree depth_options = {}
@@ -288,7 +276,7 @@ module Ancestry
     end
 
     def subtree_ids depth_options = {}
-      subtree(depth_options).select(self.ancestry_base_class.primary_key).collect(&self.ancestry_base_class.primary_key.to_sym)
+      subtree(depth_options).pluck(self.ancestry_base_class.primary_key)
     end
 
     # Callback disabling
@@ -323,26 +311,14 @@ module Ancestry
       end
     end
 
-    # Validates the ancestry, but can also be applied if validation is bypassed to determine if children should be affected
-    def sane_ancestry?
-      ancestry_value = read_attribute(self.ancestry_base_class.ancestry_column)
-      ancestry_value.nil? || (ancestry_value.to_s =~ Ancestry::ANCESTRY_PATTERN && !ancestor_ids.include?(self.id))
+    def unscoped_current_and_previous_ancestors
+      self.ancestry_base_class.unscoped do
+        self.ancestry_base_class.where id: (ancestor_ids + ancestor_ids_was).uniq
+      end
     end
 
     def unscoped_find id
       self.ancestry_base_class.unscoped { self.ancestry_base_class.find(id) }
     end
-
-    def get_arel_table
-      self.ancestry_base_class.arel_table
-    end
-
-    def get_primary_key_column
-      self.ancestry_base_class.primary_key.to_sym
-    end
-
-    def get_ancestry_column
-      self.ancestry_base_class.ancestry_column.to_sym
-    end
   end
 end