closure_tree 6.1.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be5442160917053dfca50f710fa8276b2d2d937c
-  data.tar.gz: e6012dd4b630ace5fa36835de936bd395e41df20
+  metadata.gz: e3b96ba78aea59298da3138316379a458d28c713
+  data.tar.gz: f1c786fb41309ea4460a06ae296b7393ea058b63
 SHA512:
-  metadata.gz: 43316c4fd1030f11ca90d59cf477f9a7d5300a16771152e3b81a779d5a25f665b9f9a288c42bc0c54183717d537cc95d704fc180166064079fbe6a9ee20d2bc5
-  data.tar.gz: 7f65c0281b3d878b2c333087f3e63a8e09c6aecbcabc98d798e2e1651853f50f7aefe50ece31b611bf12b17718fa3b023adc67cb39c747034a79aafae152dd93
+  metadata.gz: b5850fadca83ecdc88e53f4fac48a19faaafda82c7b6bd93f8051e264b632a94b56edbc3b22d9d060d658cf76dca02268fda625835c74e9e6cfb6ef75e9430d6
+  data.tar.gz: cae0ca262a5f9f76d1a01b24aac119a5307a49637a77e9287305630d2e97c2b3265a767180b5e76eedff9a4a9ada44ff07aebe648d0b109949c7ed2e012b9b93

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+### 6.2.0
+
+* Fix for [MySQL lock lengths](https://github.com/mceachen/closure_tree/issues/231).
+   Thanks to [Liam](https://github.com/hut8)!
+* [Tom Smyth](https://github.com/hooverlunch) added [eager tree loading](https://github.com/mceachen/closure_tree/pull/232)
+* Merged [PR 200](https://github.com/mceachen/closure_tree/pull/200) which may or may not add support to SQLServer 2008 (but this is not a supported RDBMS).
+
 ### 6.1.0
 
 * Added official support for ActiveRecord 5.0! Thanks to [Abdelkader Boudih](https://github.com/seuros),

data/README.md

@@ -468,7 +468,12 @@ Yup! [Ilya Bodrov](https://github.com/bodrovis) wrote [Nested Comments with Rail
 
 ### Does this work well with ```#default_scope```?
 
-No. Please see [issue 86](https://github.com/mceachen/closure_tree/issues/86) for details.
+**No.** Please see [issue 86](https://github.com/mceachen/closure_tree/issues/86) for details.
+
+### Can I update parentage with `update_attribute`?
+
+**No.** `update_attribute` skips the validation hook that is required for maintaining the 
+hierarchy table.
 
 ### Does this gem support multiple parents?
 

data/lib/closure_tree.rb

@@ -4,6 +4,7 @@ module ClosureTree
   extend ActiveSupport::Autoload
 
   autoload :HasClosureTree
+  autoload :HasClosureTreeRoot
   autoload :Support
   autoload :HierarchyMaintenance
   autoload :Model
@@ -25,4 +26,5 @@ end
 
 ActiveSupport.on_load :active_record do
   ActiveRecord::Base.send :extend, ClosureTree::HasClosureTree
+  ActiveRecord::Base.send :extend, ClosureTree::HasClosureTreeRoot
 end

data/lib/closure_tree/finders.rb

@@ -39,7 +39,7 @@ module ClosureTree
           SELECT descendant_id
           FROM #{_ct.quoted_hierarchy_table_name}
           WHERE ancestor_id = #{_ct.quote(self.id)}
-          GROUP BY 1
+          GROUP BY 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
@@ -74,7 +74,7 @@ module ClosureTree
           INNER JOIN (
             SELECT ancestor_id
             FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY 1
+            GROUP BY ancestor_id
             HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = 0
           ) AS leaves ON (#{_ct.quoted_table_name}.#{primary_key} = leaves.ancestor_id)
         SQL
@@ -100,7 +100,7 @@ module ClosureTree
           INNER JOIN (
             SELECT ancestor_id, descendant_id
             FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY 1, 2
+            GROUP BY ancestor_id, descendant_id
             HAVING MAX(generations) = #{generation_level.to_i}
           ) AS descendants ON (
             #{_ct.quoted_table_name}.#{primary_key} = descendants.descendant_id

data/lib/closure_tree/has_closure_tree_root.rb

@@ -0,0 +1,88 @@
+module ClosureTree
+  class MultipleRootError < StandardError; end
+
+  module HasClosureTreeRoot
+
+    def has_closure_tree_root(assoc_name, options = {})
+      options.assert_valid_keys(
+        :class_name,
+        :foreign_key
+      )
+
+      options[:class_name] ||= assoc_name.to_s.sub(/\Aroot_/, "").classify
+      options[:foreign_key] ||= self.name.underscore << "_id"
+
+      has_one assoc_name, -> { where(parent: nil) }, options
+
+      # Fetches the association, eager loading all children and given associations
+      define_method("#{assoc_name}_including_tree") do |assoc_map_or_reload = nil, assoc_map = nil|
+        reload = false
+        if assoc_map_or_reload.is_a?(::Hash)
+          assoc_map = assoc_map_or_reload
+        else
+          reload = assoc_map_or_reload
+        end
+
+        unless reload
+          # Memoize
+          @closure_tree_roots ||= {}
+          @closure_tree_roots[assoc_name] ||= {}
+          if @closure_tree_roots[assoc_name].has_key?(assoc_map)
+            return @closure_tree_roots[assoc_name][assoc_map]
+          end
+        end
+
+        roots = options[:class_name].constantize.where(parent: nil, options[:foreign_key] => id).to_a
+
+        return nil if roots.empty?
+
+        if roots.size > 1
+          raise MultipleRootError.new("#{self.class.name}: has_closure_tree_root requires a single root")
+        end
+
+        temp_root = roots.first
+        root = nil
+        id_hash = {}
+        parent_col_id = temp_root.class._ct.options[:parent_column_name]
+
+        # Lookup inverse belongs_to association reflection on target class.
+        inverse = temp_root.class.reflections.values.detect do |r|
+          r.macro == :belongs_to && r.klass == self.class
+        end
+
+        # Fetch all descendants in constant number of queries.
+        # This is the last query-triggering statement in the method.
+        temp_root.self_and_descendants.includes(assoc_map).each do |node|
+          id_hash[node.id] = node
+          parent_node = id_hash[node[parent_col_id]]
+
+          # Pre-assign parent association
+          parent_assoc = node.association(:parent)
+          parent_assoc.loaded!
+          parent_assoc.target = parent_node
+
+          # Pre-assign children association as empty for now,
+          # children will be added in subsequent loop iterations
+          children_assoc = node.association(:children)
+          children_assoc.loaded!
+
+          if parent_node
+            parent_node.association(:children).target << node
+          else
+            # Capture the root we're going to use
+            root = node
+          end
+
+          # Pre-assign inverse association back to this class, if it exists on target class.
+          if inverse
+            inverse_assoc = node.association(inverse.name)
+            inverse_assoc.loaded!
+            inverse_assoc.target = self
+          end
+        end
+
+        @closure_tree_roots[assoc_name][assoc_map] = root
+      end
+    end
+  end
+end

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -72,7 +72,7 @@ module ClosureTree
           JOIN (
             SELECT descendant_id, max(generations) AS max_depth
             FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY 1
+            GROUP BY descendant_id
           ) AS depths ON depths.descendant_id = anc.#{_ct.quoted_id_column_name}
         SQL
         joins(join_sql)

data/lib/closure_tree/support_attributes.rb

@@ -1,12 +1,11 @@
 require 'forwardable'
 module ClosureTree
   module SupportAttributes
-
     extend Forwardable
     def_delegators :model_class, :connection, :transaction, :table_name, :base_class, :inheritance_column, :column_names
 
     def advisory_lock_name
-      "ClosureTree::#{base_class.name}"
+      Digest::SHA1.hexdigest("ClosureTree::#{base_class.name}")[0..32]
     end
 
     def quoted_table_name

data/lib/closure_tree/version.rb

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

data/spec/db/models.rb

@@ -35,13 +35,30 @@ end
 class DestroyedTag < ActiveRecord::Base
 end
 
+class Group < ActiveRecord::Base
+  has_closure_tree_root :root_user
+end
+
+class Grouping < ActiveRecord::Base
+  has_closure_tree_root :root_person, class_name: "User", foreign_key: :group_id
+end
+
+class UserSet < ActiveRecord::Base
+  has_closure_tree_root :root_user, class_name: "Useur"
+end
+
+class Team < ActiveRecord::Base
+  has_closure_tree_root :root_user, class_name: "User", foreign_key: :grp_id
+end
+
 class User < ActiveRecord::Base
   acts_as_tree :parent_column_name => "referrer_id",
     :name_column => 'email',
     :hierarchy_class_name => 'ReferralHierarchy',
     :hierarchy_table_name => 'referral_hierarchies'
 
-  has_many :contracts
+  has_many :contracts, inverse_of: :user
+  belongs_to :group # Can't use and don't need inverse_of here when using has_closure_tree_root.
 
   def indirect_contracts
     Contract.where(:user_id => descendant_ids)
@@ -53,7 +70,12 @@ class User < ActiveRecord::Base
 end
 
 class Contract < ActiveRecord::Base
-  belongs_to :user
+  belongs_to :user, inverse_of: :contracts
+  belongs_to :contract_type, inverse_of: :contracts
+end
+
+class ContractType < ActiveRecord::Base
+  has_many :contracts, inverse_of: :contract_type
 end
 
 class Label < ActiveRecord::Base

data/spec/db/schema.rb

@@ -43,9 +43,26 @@ ActiveRecord::Schema.define(:version => 0) do
   add_index "tag_hierarchies", [:ancestor_id, :descendant_id, :generations], :unique => true, :name => "tag_anc_desc_idx"
   add_index "tag_hierarchies", [:descendant_id], :name => "tag_desc_idx"
 
+  create_table "groups" do |t|
+    t.string "name", null: false
+  end
+
+  create_table "groupings" do |t|
+    t.string "name", null: false
+  end
+
+  create_table "user_sets" do |t|
+    t.string "name", null: false
+  end
+
+  create_table "teams" do |t|
+    t.string "name", null: false
+  end
+
   create_table "users" do |t|
     t.string "email"
     t.integer "referrer_id"
+    t.integer "group_id"
     t.timestamps null: false
   end
 
@@ -53,6 +70,11 @@ ActiveRecord::Schema.define(:version => 0) do
 
   create_table "contracts" do |t|
     t.integer "user_id", :null => false
+    t.integer "contract_type_id"
+  end
+
+  create_table "contract_types" do |t|
+    t.string "name", :null => false
   end
 
   create_table "referral_hierarchies", :id => false do |t|

data/spec/has_closure_tree_root_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+
+describe "has_closure_tree_root" do
+  let!(:ct1) { ContractType.create!(name: "Type1") }
+  let!(:ct2) { ContractType.create!(name: "Type2") }
+  let!(:user1) { User.create!(email: "1@example.com", group_id: group.id) }
+  let!(:user2) { User.create!(email: "2@example.com", group_id: group.id) }
+  let!(:user3) { User.create!(email: "3@example.com", group_id: group.id) }
+  let!(:user4) { User.create!(email: "4@example.com", group_id: group.id) }
+  let!(:user5) { User.create!(email: "5@example.com", group_id: group.id) }
+  let!(:user6) { User.create!(email: "6@example.com", group_id: group.id) }
+  let!(:group_reloaded) { group.class.find(group.id) } # Ensures were starting fresh.
+
+  before do
+    # 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!(contract_type: ct1)
+    user2.contracts.create!(contract_type: ct1)
+    user3.contracts.create!(contract_type: ct1)
+    user3.contracts.create!(contract_type: ct2)
+    user4.contracts.create!(contract_type: ct2)
+    user5.contracts.create!(contract_type: ct1)
+    user6.contracts.create!(contract_type: ct2)
+  end
+
+  context "with basic config" do
+    let!(:group) { Group.create!(name: "TheGroup") }
+
+    it "loads all nodes and associations in a constant number of queries" do
+      expect do
+        root = group_reloaded.root_user_including_tree(contracts: :contract_type)
+        expect(root.children[0].email).to eq "2@example.com"
+        expect(root.children[0].parent.children[1].email).to eq "3@example.com"
+        expect(root.children[1].contracts.map(&:contract_type).map(&:name)).to eq %w(Type1 Type2)
+        expect(root.children[1].children[0].contracts[0].contract_type.name).to eq "Type1"
+        expect(root.children[0].children[0].contracts[0].user.
+          parent.parent.children[1].children[1].contracts[0].contract_type.name).to eq "Type2"
+      end.to_not exceed_query_limit(4) # Without this feature, this is 15, and scales with number of nodes.
+    end
+
+    it "memoizes by assoc_map" do
+      group_reloaded.root_user_including_tree.email = "x"
+      expect(group_reloaded.root_user_including_tree.email).to eq "x"
+      group_reloaded.root_user_including_tree(contracts: :contract_type).email = "y"
+      expect(group_reloaded.root_user_including_tree(contracts: :contract_type).email).to eq "y"
+      expect(group_reloaded.root_user_including_tree.email).to eq "x"
+    end
+
+    it "doesn't memoize if true argument passed" do
+      group_reloaded.root_user_including_tree.email = "x"
+      expect(group_reloaded.root_user_including_tree(true).email).to eq "1@example.com"
+      group_reloaded.root_user_including_tree(contracts: :contract_type).email = "y"
+      expect(group_reloaded.root_user_including_tree(true, contracts: :contract_type).email).
+        to eq "1@example.com"
+    end
+
+    it "eager loads inverse association to group" do
+      expect do
+        root = group_reloaded.root_user_including_tree
+        expect(root.group).to eq group
+        expect(root.children[0].group).to eq group
+      end.to_not exceed_query_limit(2)
+    end
+
+    it "works if eager load association map is not given" do
+      expect do
+        root = group_reloaded.root_user_including_tree
+        expect(root.children[0].email).to eq "2@example.com"
+        expect(root.children[0].parent.children[1].children[0].email).to eq "5@example.com"
+      end.to_not exceed_query_limit(2)
+    end
+
+    context "with no tree root" do
+      let(:group2) { Group.create!(name: "OtherGroup") }
+
+      it "should return nil" do
+        expect(group2.root_user_including_tree(contracts: :contract_type)).to be_nil
+      end
+    end
+
+    context "with multiple tree roots" do
+      let!(:other_root) { User.create!(email: "10@example.com", group_id: group.id) }
+
+      it "should error" do
+        expect do
+          root = group_reloaded.root_user_including_tree(contracts: :contract_type)
+        end.to raise_error(ClosureTree::MultipleRootError)
+      end
+    end
+  end
+
+  context "with explicit class_name and foreign_key" do
+    let(:group) { Grouping.create!(name: "TheGrouping") }
+
+    it "should still work" do
+      root = group_reloaded.root_person_including_tree(contracts: :contract_type)
+      expect(root.children[0].email).to eq "2@example.com"
+    end
+  end
+
+  context "with bad class_name" do
+    let(:group) { UserSet.create!(name: "TheUserSet") }
+
+    it "should error" do
+      expect do
+        root = group_reloaded.root_user_including_tree(contracts: :contract_type)
+      end.to raise_error(NameError)
+    end
+  end
+
+  context "with bad foreign_key" do
+    let(:group) { Team.create!(name: "TheTeam") }
+
+    it "should error" do
+      expect do
+        root = group_reloaded.root_user_including_tree(contracts: :contract_type)
+      end.to raise_error(ActiveRecord::StatementInvalid)
+    end
+  end
+end

data/spec/support/exceed_query_limit.rb

@@ -0,0 +1,18 @@
+# Derived from http://stackoverflow.com/a/13423584/153896. Updated for RSpec 3.
+RSpec::Matchers.define :exceed_query_limit do |expected|
+  supports_block_expectations
+
+  match do |block|
+    query_count(&block) > expected
+  end
+
+  failure_message_when_negated do |actual|
+    "Expected to run maximum #{expected} queries, got #{@counter.query_count}"
+  end
+
+  def query_count(&block)
+    @counter = ActiveRecord::QueryCounter.new
+    ActiveSupport::Notifications.subscribed(@counter.to_proc, 'sql.active_record', &block)
+    @counter.query_count
+  end
+end

data/spec/support/query_counter.rb

@@ -0,0 +1,18 @@
+# From http://stackoverflow.com/a/13423584/153896
+module ActiveRecord
+  class QueryCounter
+    attr_reader :query_count
+
+    def initialize
+      @query_count = 0
+    end
+
+    def to_proc
+      lambda(&method(:callback))
+    end
+
+    def callback(name, start, finish, message_id, values)
+      @query_count += 1 unless %w(CACHE SCHEMA).include?(values[:name])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 6.1.0
+  version: 6.2.0
 platform: ruby
 authors:
 - Matthew McEachen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-22 00:00:00.000000000 Z
+date: 2016-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -154,6 +154,7 @@ files:
 - lib/closure_tree/digraphs.rb
 - lib/closure_tree/finders.rb
 - lib/closure_tree/has_closure_tree.rb
+- lib/closure_tree/has_closure_tree_root.rb
 - lib/closure_tree/hash_tree.rb
 - lib/closure_tree/hash_tree_support.rb
 - lib/closure_tree/hierarchy_maintenance.rb
@@ -177,6 +178,7 @@ files:
 - spec/db/schema.rb
 - spec/fixtures/tags.yml
 - spec/generators/migration_generator_spec.rb
+- spec/has_closure_tree_root_spec.rb
 - spec/hierarchy_maintenance_spec.rb
 - spec/label_spec.rb
 - spec/matcher_spec.rb
@@ -187,7 +189,9 @@ files:
 - spec/spec_helper.rb
 - spec/support/database.rb
 - spec/support/database_cleaner.rb
+- spec/support/exceed_query_limit.rb
 - spec/support/hash_monkey_patch.rb
+- spec/support/query_counter.rb
 - spec/support/sqlite3_with_advisory_lock.rb
 - spec/support_spec.rb
 - spec/tag_examples.rb
@@ -227,6 +231,7 @@ test_files:
 - spec/db/schema.rb
 - spec/fixtures/tags.yml
 - spec/generators/migration_generator_spec.rb
+- spec/has_closure_tree_root_spec.rb
 - spec/hierarchy_maintenance_spec.rb
 - spec/label_spec.rb
 - spec/matcher_spec.rb
@@ -237,7 +242,9 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/database.rb
 - spec/support/database_cleaner.rb
+- spec/support/exceed_query_limit.rb
 - spec/support/hash_monkey_patch.rb
+- spec/support/query_counter.rb
 - spec/support/sqlite3_with_advisory_lock.rb
 - spec/support_spec.rb
 - spec/tag_examples.rb