closure_tree 7.4.0 → 8.0.0

data/lib/closure_tree/model.rb

@@ -6,12 +6,12 @@ module ClosureTree
 
     included do
 
-      belongs_to :parent, nil, **_ct.belongs_to_with_optional_option(
+      belongs_to :parent, nil,
         class_name: _ct.model_class.to_s,
         foreign_key: _ct.parent_column_name,
         inverse_of: :children,
         touch: _ct.options[:touch],
-        optional: true)
+        optional: true
 
       order_by_generations = -> { Arel.sql("#{_ct.quoted_hierarchy_table_name}.generations ASC") }
 
@@ -77,7 +77,7 @@ module ClosureTree
     end
 
     def depth
-      ancestors.size
+      ancestor_hierarchies.size - 1
     end
 
     alias_method :level, :depth

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -10,13 +10,8 @@ module ClosureTree
     end
 
     def _ct_reorder_prior_siblings_if_parent_changed
-      as_5_1 = ActiveSupport.version >= Gem::Version.new('5.1.0')
-      change_method = as_5_1 ? :saved_change_to_attribute? : :attribute_changed?
-
-      if public_send(change_method, _ct.parent_column_name) && !@was_new_record
-        attribute_method = as_5_1 ? :attribute_before_last_save : :attribute_was
-
-        was_parent_id = public_send(attribute_method, _ct.parent_column_name)
+      if public_send(:saved_change_to_attribute?, _ct.parent_column_name) && !@was_new_record
+        was_parent_id = public_send(:attribute_before_last_save, _ct.parent_column_name)
         _ct.reorder_with_parent_id(was_parent_id)
       end
     end
@@ -47,7 +42,7 @@ module ClosureTree
         .reorder(self.class._ct_sum_order_by(self))
     end
 
-    module ClassMethods
+    class_methods do
 
       # If node is nil, order the whole tree.
       def _ct_sum_order_by(node = nil)

data/lib/closure_tree/support.rb

@@ -32,7 +32,7 @@ module ClosureTree
     end
 
     def hierarchy_class_for_model
-      parent_class = ActiveSupport::VERSION::MAJOR >= 6 ? model_class.module_parent : model_class.parent
+      parent_class = model_class.module_parent
       hierarchy_class = parent_class.const_set(short_hierarchy_class_name, Class.new(model_class.superclass))
       use_attr_accessible = use_attr_accessible?
       include_forbidden_attributes_protection = include_forbidden_attributes_protection?
@@ -59,9 +59,9 @@ module ClosureTree
       # 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"
+        remove_prefix_and_suffix(table_name, model_class).singularize + "_hierarchies"
 
-      ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
+      [model_class.table_name_prefix, tablename, model_class.table_name_suffix].join
     end
 
     def with_order_option(opts)
@@ -79,10 +79,6 @@ module ClosureTree
       end
     end
 
-    def belongs_to_with_optional_option(opts)
-      ActiveRecord::VERSION::MAJOR < 5 ? opts.except(:optional) : opts
-    end
-
     # lambda-ize the order, but don't apply the default order_option
     def has_many_order_without_option(order_by_opt)
       [lambda { order(order_by_opt.call) }]

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = Gem::Version.new('7.4.0')
+  VERSION = Gem::Version.new('8.0.0')
 end

data/lib/generators/closure_tree/migration_generator.rb

@@ -43,10 +43,7 @@ module ClosureTree
       end
 
       def migration_version
-        major = ActiveRecord::VERSION::MAJOR
-        if major >= 5
-          "[#{major}.#{ActiveRecord::VERSION::MINOR}]"
-        end
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
       end
 
       def self.next_migration_number(dirname)

data/release-please-config.json

@@ -0,0 +1,4 @@
+{
+  "release-type": "ruby",
+  "package-name": "closure_tree"
+}

data/test/closure_tree/cache_invalidation_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class CacheInvalidationTest < ActiveSupport::TestCase
+  def setup
+    Timecop.travel(10.seconds.ago) do
+      #create a long tree with 2 branch
+      @root = MenuItem.create(
+        name: SecureRandom.hex(10)
+      )
+      2.times do
+        parent = @root
+        10.times do
+          parent = parent.children.create(
+            name: SecureRandom.hex(10)
+          )
+        end
+      end
+      @first_leaf = MenuItem.leaves.first
+      @second_leaf = MenuItem.leaves.last
+    end
+  end
+
+  test "touch option should invalidate cache for all it ancestors" do
+    old_time_stamp = @first_leaf.ancestors.pluck(:updated_at)
+    @first_leaf.touch
+    new_time_stamp = @first_leaf.ancestors.pluck(:updated_at)
+    assert_not_equal old_time_stamp, new_time_stamp, 'Cache not invalidated for all ancestors'
+  end
+
+  test "touch option should not invalidate cache for another branch" do
+    old_time_stamp = @second_leaf.updated_at
+    @first_leaf.touch
+    new_time_stamp = @second_leaf.updated_at
+    assert_equal old_time_stamp, new_time_stamp, 'Cache incorrectly invalidated for another branch'
+  end
+end

data/test/closure_tree/cuisine_type_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+def assert_lineage(e, m)
+  assert_equal e, m.parent
+  assert_equal [m, e], m.self_and_ancestors
+
+  # make sure reloading doesn't affect the self_and_ancestors:
+  m.reload
+  assert_equal [m, e], m.self_and_ancestors
+end
+
+describe CuisineType do
+  it 'finds self and parents when children << is used' do
+    e = CuisineType.new(name: 'e')
+    m = CuisineType.new(name: 'm')
+    e.children << m
+    e.save
+    assert_lineage(e, m)
+  end
+
+  it 'finds self and parents properly if the constructor is used' do
+    e = CuisineType.create(name: 'e')
+    m = CuisineType.create(name: 'm', parent: e)
+    assert_lineage(e, m)
+  end
+
+  it 'sets the table_name of the hierarchy class properly' do
+    assert_equal(
+      "#{ActiveRecord::Base.table_name_prefix}cuisine_type_hierarchies#{ActiveRecord::Base.table_name_suffix}", CuisineTypeHierarchy.table_name
+    )
+  end
+
+  it 'fixes self_and_ancestors properly on reparenting' do
+    a = CuisineType.create! name: 'a'
+    b = CuisineType.create! name: 'b'
+    assert_equal([b], b.self_and_ancestors.to_a)
+    a.children << b
+    assert_equal([b, a], b.self_and_ancestors.to_a)
+  end
+end

data/test/closure_tree/generator_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'generators/closure_tree/migration_generator'
+
+module ClosureTree
+  module Generators
+    class MigrationGeneratorTest < Rails::Generators::TestCase
+      tests MigrationGenerator
+      destination File.expand_path('../tmp', __dir__)
+      setup :prepare_destination
+
+      def test_generator_output
+        run_generator %w[tag]
+        migration_file = migration_file_name('db/migrate/create_tag_hierarchies.rb')
+        content = File.read(migration_file)
+        assert_match(/t.integer :ancestor_id, null: false/, content)
+        assert_match(/t.integer :descendant_id, null: false/, content)
+        assert_match(/t.integer :generations, null: false/, content)
+        assert_match(/add_index :tag_hierarchies/, content)
+      end
+
+      def test_generator_output_with_namespaced_model
+        run_generator %w[Namespace::Type]
+        migration_file = migration_file_name('db/migrate/create_namespace_type_hierarchies.rb')
+        content = File.read(migration_file)
+        assert_match(/t.integer :ancestor_id, null: false/, content)
+        assert_match(/t.integer :descendant_id, null: false/, content)
+        assert_match(/t.integer :generations, null: false/, content)
+        assert_match(/add_index :namespace_type_hierarchies/, content)
+      end
+
+      def test_generator_output_with_namespaced_model_with_slash
+        run_generator %w[namespace/type]
+        migration_file = migration_file_name('db/migrate/create_namespace_type_hierarchies.rb')
+        content = File.read(migration_file)
+        assert_match(/t.integer :ancestor_id, null: false/, content)
+        assert_match(/t.integer :descendant_id, null: false/, content)
+        assert_match(/t.integer :generations, null: false/, content)
+        assert_match(/add_index :namespace_type_hierarchies/, content)
+      end
+
+      def test_should_run_all_tasks_in_generator_without_errors
+        gen = generator %w[tag]
+        capture_io { gen.invoke_all }
+      end
+    end
+  end
+end

data/test/closure_tree/has_closure_tree_root_test.rb

@@ -0,0 +1,80 @@
+require "test_helper"
+
+class HasClosureTreeRootTest < ActiveSupport::TestCase
+  setup do
+    ENV['FLOCK_DIR'] = Dir.mktmpdir
+  end
+
+  teardown do
+    FileUtils.remove_entry_secure ENV['FLOCK_DIR']
+  end
+  def create_tree(group)
+    @ct1 = ContractType.create!(name: "Type1")
+    @ct2 = ContractType.create!(name: "Type2")
+    @user1 = User.create!(email: "1@example.com", group_id: group.id)
+    @user2 = User.create!(email: "2@example.com", group_id: group.id)
+    @user3 = User.create!(email: "3@example.com", group_id: group.id)
+    @user4 = User.create!(email: "4@example.com", group_id: group.id)
+    @user5 = User.create!(email: "5@example.com", group_id: group.id)
+    @user6 = User.create!(email: "6@example.com", group_id: group.id)
+
+    # The tree (contract types in parens)
+    #
+    #                   U1(1)
+    #                  /    \
+    #              U2(1)   U3(1&2)
+    #             /        /     \
+    #         U4(2)      U5(1)   U6(2)
+
+    @user1.children << @user2
+    @user1.children << @user3
+    @user2.children << @user4
+    @user3.children << @user5
+    @user3.children << @user6
+
+    @user1.contracts.create!(title: "Contract 1", contract_type: @ct1)
+    @user2.contracts.create!(title: "Contract 2", contract_type: @ct1)
+    @user3.contracts.create!(title: "Contract 3", contract_type: @ct1)
+    @user3.contracts.create!(title: "Contract 4", contract_type: @ct2)
+    @user4.contracts.create!(title: "Contract 5", contract_type: @ct2)
+    @user5.contracts.create!(title: "Contract 6", contract_type: @ct1)
+    @user6.contracts.create!(title: "Contract 7", contract_type: @ct2)
+  end
+
+  test "loads all nodes in a constant number of queries" do
+    group = Group.create!(name: "TheGrouping")
+    create_tree(group)
+    reloaded_group = group.reload
+    exceed_query_limit(2) do
+      root = reloaded_group.root_user_including_tree
+      assert_equal "2@example.com", root.children[0].email
+      assert_equal "3@example.com", root.children[0].parent.children[1].email
+    end
+  end
+
+  test "loads all nodes plus single association in a constant number of queries" do
+    group = Group.create!(name: "TheGrouping")
+    create_tree(group)
+    reloaded_group = group.reload
+    exceed_query_limit(3) do
+      root = reloaded_group.root_user_including_tree(:contracts)
+      assert_equal "2@example.com", root.children[0].email
+      assert_equal "3@example.com", root.children[0].parent.children[1].email
+      assert_equal "Contract 7", root.children[0].children[0].contracts[0].user.parent.parent.children[1].children[1].contracts[0].title
+    end
+  end
+
+  test "loads all nodes and associations in a constant number of queries" do
+    group = Group.create!(name: "TheGrouping")
+    create_tree(group)
+    reloaded_group = group.reload
+    exceed_query_limit(4) do
+      root = reloaded_group.root_user_including_tree(contracts: :contract_type)
+      assert_equal "2@example.com", root.children[0].email
+      assert_equal "3@example.com", root.children[0].parent.children[1].email
+      assert_equal %w[Type1 Type2], root.children[1].contracts.map(&:contract_type).map(&:name)
+      assert_equal "Type1", root.children[1].children[0].contracts[0].contract_type.name
+      assert_equal "Type2", root.children[0].children[0].contracts[0].user.parent.parent.children[1].children[1].contracts[0].contract_type.name
+    end
+  end
+end

data/test/closure_tree/hierarchy_maintenance_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe ClosureTree::HierarchyMaintenance do
+  describe '.rebuild!' do
+    it 'rebuild tree' do
+      20.times do |counter|
+        Metal.create(value: "Nitro-#{counter}", parent: Metal.all.sample)
+      end
+      hierarchy_count = MetalHierarchy.count
+      assert_operator hierarchy_count, :>, (20 * 2) - 1 # shallowest-possible case, where all children use the first root
+      MetalHierarchy.delete_all
+      Metal.rebuild!
+      assert_equal MetalHierarchy.count, hierarchy_count
+    end
+  end
+
+  describe '.cleanup!' do
+    before do
+      @parent = Metal.create(value: 'parent metal')
+      @child = Metal.create(value: 'child metal', parent: @parent)
+      MetalHierarchy.delete_all
+      Metal.rebuild!
+    end
+
+    describe 'when an element is deleted' do
+      it 'should delete the child hierarchies' do
+        @child.delete
+
+        Metal.cleanup!
+
+        assert_empty MetalHierarchy.where(descendant_id: @child.id)
+        assert_empty MetalHierarchy.where(ancestor_id: @child.id)
+      end
+
+      it 'should not delete the parent hierarchies' do
+        @child.delete
+        Metal.cleanup!
+        assert_equal 1, MetalHierarchy.where(ancestor_id: @parent.id).size
+      end
+
+      it 'should not delete other hierarchies' do
+        other_parent = Metal.create(value: 'other parent metal')
+        other_child = Metal.create(value: 'other child metal', parent: other_parent)
+        Metal.rebuild!
+
+        @child.delete
+        Metal.cleanup!
+
+        assert_equal 2, MetalHierarchy.where(ancestor_id: other_parent.id).size
+        assert_equal 2, MetalHierarchy.where(descendant_id: other_child.id).size
+      end
+    end
+  end
+end