closure_tree 6.6.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c2a4b1786131c2b97479335f02da9e7c07a07f68
-  data.tar.gz: a2a1803ef7cb252a5f6f3996b3196606abf4c396
+SHA256:
+  metadata.gz: aad24f6acfed9da72a06c877919ef7a349680abb951a185307590b42484582e0
+  data.tar.gz: 543f9482cd9497d99174358b6d342caa6c860608acc51f5989e5d780c1747f58
 SHA512:
-  metadata.gz: e088751351930a9ff34d6fbcd0468e6949bff95d4ffccdaaab36cd240163029fccc752234c3ba04ceabb819a8be9a1af39b4e11beecb38003d36da7ed17dd6de
-  data.tar.gz: fc9d0ce048a35d852767bbed49b3b3dae1f6bd2efe92c31b37517205a5999fb69b8ae5d7c38984537121ea00702df667a4ed4e35e170c44d307eb9ddfa528136
+  metadata.gz: 69c034fe0ee0278b143758381412ca43663da441bd35a81b67d516d58defc5f19b79d83a28a9fea18984cb105b757b7028c9898cab34eaae98fccb56e7b0d71e
+  data.tar.gz: 53346203044b6eb82b784bc715105b6a2a5029d8ab8c48665d1bb02bf667bff643ba0768c6dfa6ec476b03b7f5567e28846c8b6b2c7b17344f2d17227ca1e24c

data/.travis.yml

@@ -2,14 +2,14 @@ cache: bundler
 sudo: false
 language: ruby
 rvm:
-  - 2.4.0
-  - 2.3.3
-  - 2.2.7
-# these haven't been passing for a while:
-#  - jruby-head
-#  - rbx
+  - 2.6.0
+  - 2.5.1
+  - 2.4.4
+  - 2.3.6
+  - 2.2.10
 
 gemfile:
+  - gemfiles/activerecord_5.2.gemfile
   - gemfiles/activerecord_5.1.gemfile
   - gemfiles/activerecord_5.0.gemfile
   - gemfiles/activerecord_4.2.gemfile
@@ -27,3 +27,4 @@ matrix:
     - gemfile: gemfiles/activerecord_edge.gemfile
     - rvm: jruby-head
     - rvm: rbx
+    - rvm: 2.6.0

data/Appraisals

@@ -1,17 +1,75 @@
 
 appraise 'activerecord-4.2' do
   gem 'activerecord', '~> 4.2.0'
+  platforms :ruby do
+    gem 'mysql2', "< 0.5"
+    gem 'pg', "~> 0.21"
+    gem 'sqlite3'
+  end
+
+  platforms :jruby do
+    gem 'activerecord-jdbcmysql-adapter'
+    gem 'activerecord-jdbcpostgresql-adapter'
+    gem 'activerecord-jdbcsqlite3-adapter'
+  end
 end
 
 appraise 'activerecord-5.0' do
   gem 'activerecord', '~> 5.0.0'
+  platforms :ruby do
+    gem 'mysql2'
+    gem 'pg'
+    gem 'sqlite3'
+  end
+
+  platforms :jruby do
+    gem 'activerecord-jdbcmysql-adapter'
+    gem 'activerecord-jdbcpostgresql-adapter'
+    gem 'activerecord-jdbcsqlite3-adapter'
+  end
 end
 
 appraise 'activerecord-5.1' do
   gem 'activerecord', '~> 5.1.0'
+  platforms :ruby do
+    gem 'mysql2'
+    gem 'pg'
+    gem 'sqlite3'
+  end
+
+  platforms :jruby do
+    gem 'activerecord-jdbcmysql-adapter'
+    gem 'activerecord-jdbcpostgresql-adapter'
+    gem 'activerecord-jdbcsqlite3-adapter'
+  end
+end
+
+appraise 'activerecord-5.2' do
+  gem 'activerecord', '~> 5.2.0'
+  platforms :ruby do
+    gem 'mysql2'
+    gem 'pg'
+    gem 'sqlite3'
+  end
+
+  platforms :jruby do
+    gem 'activerecord-jdbcmysql-adapter'
+    gem 'activerecord-jdbcpostgresql-adapter'
+    gem 'activerecord-jdbcsqlite3-adapter'
+  end
 end
 
 appraise 'activerecord-edge' do
   gem 'activerecord', github: 'rails/rails'
-  gem 'arel', github: 'rails/arel'
+  platforms :ruby do
+    gem 'mysql2'
+    gem 'pg'
+    gem 'sqlite3'
+  end
+
+  platforms :jruby do
+    gem 'activerecord-jdbcmysql-adapter'
+    gem 'activerecord-jdbcpostgresql-adapter'
+    gem 'activerecord-jdbcsqlite3-adapter'
+  end
 end

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+### 7.0.0
+Closure Tree is now tested against Rails 5.2
+
+- Postpone configuration (database introspection)[PR 264](https://github.com/ClosureTree/closure_tree/pull/264)
+- Fix "tree.find_by_path([])" [PR 288](https://github.com/ClosureTree/closure_tree/pull/288)
+- Fixed generator specs and added migration version [PR 292](https://github.com/ClosureTree/closure_tree/pull/292)
+- Eliminate deprecation warnings in ActiveRecord 5.2 [PR 296](https://github.com/ClosureTree/closure_tree/pull/296)
+- When using 'oracle_enhanced', remove 'AS' on the table_name alias. [PR 298](https://github.com/ClosureTree/closure_tree/pull/298)
+- README update [PR 301](https://github.com/ClosureTree/closure_tree/pull/301)
+- Add `with_descendant` finder [PR 302](https://github.com/ClosureTree/closure_tree/pull/302)
+- Fix pg version for rails prior 5.1 [PR 303](https://github.com/ClosureTree/closure_tree/pull/303)
+- Test on Rails 5.2 & fix mysql for older Rails [PR 304](https://github.com/ClosureTree/closure_tree/pull/304)
+- Test with ActiveRecord 5.2.0 [PR 307](https://github.com/ClosureTree/closure_tree/pull/307)
+- README update [PR 310](https://github.com/ClosureTree/closure_tree/pull/310)
+- FactoryBot linter failing for a model that uses closure_tree [PR 311](https://github.com/ClosureTree/closure_tree/pull/311)
+- Added dont_order_roots option [PR 312](https://github.com/ClosureTree/closure_tree/pull/312)
+- Added instance methods to determine the relationship between 2 nodes [PR 314](https://github.com/ClosureTree/closure_tree/pull/314)
+- Add an instance method to check the relationship between 2 nodes: #family_of? [PR 319](https://github.com/ClosureTree/closure_tree/pull/319)
+- Remove options restrictions on has_closure_tree_root [PR 321](https://github.com/ClosureTree/closure_tree/pull/321)
+- Fix uninitialized variable warnings [PR 323](https://github.com/ClosureTree/closure_tree/pull/323)
+
 ### 6.6.0
 
 Closure Tree is now tested against Rails 5.1, and just passed 50 contributors and

data/Gemfile

@@ -1,15 +1,3 @@
 source 'https://rubygems.org'
 
-platforms :ruby, :rbx do
-  gem 'mysql2'
-  gem 'pg'
-  gem 'sqlite3'
-end
-
-platforms :jruby do
-  gem 'activerecord-jdbcmysql-adapter'
-  gem 'activerecord-jdbcpostgresql-adapter'
-  gem 'activerecord-jdbcsqlite3-adapter'
-end
-
 gemspec

data/README.md

@@ -74,7 +74,7 @@ Note that closure_tree only supports ActiveRecord 4.2 and later, and has test co
     end
     ```
 
-    Make sure you check out the [large number options](#available-options) that `has_closure_tree` accepts.
+    Make sure you check out the [large number of options](#available-options) that `has_closure_tree` accepts.
 
     **IMPORTANT: Make sure you add `has_closure_tree` _after_ `attr_accessible` and
     `self.table_name =` lines in your model.**
@@ -88,7 +88,7 @@ Note that closure_tree only supports ActiveRecord 4.2 and later, and has test co
     ```ruby
     class AddParentIdToTag < ActiveRecord::Migration
       def change
-        add_column :tag, :parent_id, :integer
+        add_column :tags, :parent_id, :integer
       end
     end
     ```
@@ -346,15 +346,19 @@ When you include ```has_closure_tree``` in your model, you can provide a hash to
 
 * ```tag.root``` returns the root for this node
 * ```tag.root?``` returns true if this is a root node
+* ```tag.root_of?(node)``` returns true if current node is root of another one
 * ```tag.child?``` returns true if this is a child node. It has a parent.
 * ```tag.leaf?``` returns true if this is a leaf node. It has no children.
 * ```tag.leaves``` is scoped to all leaf nodes in self_and_descendants.
 * ```tag.depth``` returns the depth, or "generation", for this node in the tree. A root node will have a value of 0.
 * ```tag.parent``` returns the node's immediate parent. Root nodes will return nil.
+* ```tag.parent_of?(node)``` returns true if current node is parent of another one
 * ```tag.children``` is a ```has_many``` of immediate children (just those nodes whose parent is the current node).
 * ```tag.child_ids``` is an array of the IDs of the children.
+* ```tag.child_of?(node)``` returns true if current node is child of another one
 * ```tag.ancestors``` is a ordered scope of [ parent, grandparent, great grandparent, … ]. Note that the size of this array will always equal ```tag.depth```.
 * ```tag.ancestor_ids``` is an array of the IDs of the ancestors.
+* ```tag.ancestor_of?(node)``` returns true if current node is ancestor of another one
 * ```tag.self_and_ancestors``` returns a scope containing self, parent, grandparent, great grandparent, etc.
 * ```tag.self_and_ancestors_ids``` returns IDs containing self, parent, grandparent, great grandparent, etc.
 * ```tag.siblings``` returns a scope containing all nodes with the same parent as ```tag```, excluding self.
@@ -362,8 +366,10 @@ When you include ```has_closure_tree``` in your model, you can provide a hash to
 * ```tag.self_and_siblings``` returns a scope containing all nodes with the same parent as ```tag```, including self.
 * ```tag.descendants``` returns a scope of all children, childrens' children, etc., excluding self ordered by depth.
 * ```tag.descendant_ids``` returns an array of the IDs of the descendants.
+* ```tag.descendant_of?(node)``` returns true if current node is descendant of another one
 * ```tag.self_and_descendants``` returns a scope of self, all children, childrens' children, etc., ordered by depth.
 * ```tag.self_and_descendant_ids``` returns IDs of self, all children, childrens' children, etc., ordered by depth.
+* ```tag.family_of?``` returns true if current node and another one have a same root.
 * ```tag.hash_tree``` returns an [ordered, nested hash](#nested-hashes) that can be depth-limited.
 * ```tag.find_by_path(path)``` returns the node whose name path *from ```tag```* is ```path```. See (#find_or_create_by_path).
 * ```tag.find_or_create_by_path(path)``` returns the node whose name path *from ```tag```* is ```path```, and will create the node if it doesn't exist already.See (#find_or_create_by_path).
@@ -389,6 +395,18 @@ class WhereTag < Tag ; end
 class WhatTag < Tag ; end
 ```
 
+Note that if you call `rebuild!` on any of the subclasses, the complete Tag hierarchy will be emptied, thus taking the hiearchies of all other subclasses with it (issue #275). However, only the hierarchies for the class `rebuild!` was called on will be rebuilt, leaving the other subclasses without hierarchy entries.
+
+You can work around that by overloading the `rebuild!` class method in all your STI subclasses and call the super classes `rebuild!` method:
+```ruby
+class WhatTag < Tag
+  def self.rebuild!
+    Tag.rebuild!
+  end
+end
+```
+This way, the complete hierarchy including all subclasses will be rebuilt.
+
 ## Deterministic ordering
 
 By default, children will be ordered by your database engine, which may not be what you want.
@@ -411,7 +429,7 @@ and in your model:
 
 ```ruby
 class OrderedTag < ActiveRecord::Base
-  has_closure_tree order: 'sort_order'
+  has_closure_tree order: 'sort_order', numeric_order: true
 end
 ```
 
@@ -477,6 +495,25 @@ root.reload.children.pluck(:name)
 => ["b", "c", "a"]
 ```
 
+### Ordering Roots
+
+With numeric ordering, root nodes are, by default, assigned order values globally across the whole database
+table. So for instance if you have 5 nodes with no parent, they will be ordered 0 through 4 by default.
+If your model represents many separate trees and you have a lot of records, this can cause performance
+problems, and doesn't really make much sense.
+
+You can disable this default behavior by passing `dont_order_roots: true` as an option to your delcaration:
+
+```
+has_closure_tree order: 'sort_order', numeric_order: true, dont_order_roots: true
+```
+
+In this case, calling `prepend_sibling` and `append_sibling` on a root node or calling
+`roots_and_descendants_preordered` on the model will raise a `RootOrderingDisabledError`.
+
+The `dont_order_roots` option will be ignored unless `numeric_order` is set to true.
+
+
 ## Concurrency
 
 Several methods, especially ```#rebuild``` and ```#find_or_create_by_path```, cannot run concurrently correctly.

data/closure_tree.gemspec

@@ -12,20 +12,23 @@ Gem::Specification.new do |gem|
   gem.description = gem.summary
   gem.license     = 'MIT'
 
-  gem.files       = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.files         = `git ls-files`.split($/).reject do |f|
+    f.match(%r{^(spec|img|gemfiles)})
+  end
+
   gem.test_files  = gem.files.grep(%r{^spec/})
   gem.required_ruby_version = '>= 2.0.0'
 
-  gem.add_runtime_dependency 'activerecord', '>= 4.1.0'
-  gem.add_runtime_dependency 'with_advisory_lock', '>= 3.0.0'
+  gem.add_runtime_dependency 'activerecord', '>= 4.2.10'
+  gem.add_runtime_dependency 'with_advisory_lock', '>= 4.0.0'
 
+  gem.add_development_dependency 'appraisal'
+  gem.add_development_dependency 'database_cleaner'
+  gem.add_development_dependency 'generator_spec'
+  gem.add_development_dependency 'parallel'
   gem.add_development_dependency 'rspec-instafail'
   gem.add_development_dependency 'rspec-rails'
-  gem.add_development_dependency 'database_cleaner'
-  gem.add_development_dependency 'appraisal'
   gem.add_development_dependency 'timecop'
-  gem.add_development_dependency 'parallel'
-  # gem.add_development_dependency 'ammeter', '1.1.2' # See https://github.com/mceachen/closure_tree/issues/181
   # gem.add_development_dependency 'byebug'
   # gem.add_development_dependency 'ruby-prof' # <- don't need this normally.
 end

data/lib/closure_tree/finders.rb

@@ -41,7 +41,7 @@ module ClosureTree
           WHERE ancestor_id = #{_ct.quote(self.id)}
           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)
+        ) #{ _ct.t_alias_keyword } descendants ON (#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} = descendants.descendant_id)
       SQL
       _ct.scope_with_order(s)
     end
@@ -76,7 +76,7 @@ module ClosureTree
             FROM #{_ct.quoted_hierarchy_table_name}
             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)
+          ) #{ _ct.t_alias_keyword } leaves ON (#{_ct.quoted_table_name}.#{primary_key} = leaves.ancestor_id)
         SQL
         _ct.scope_with_order(s.readonly(false))
       end
@@ -90,19 +90,28 @@ module ClosureTree
         _ct.scope_with_order(scope)
       end
 
+      def with_descendant(*descendants)
+        descendant_ids = descendants.map { |ea| ea.is_a?(ActiveRecord::Base) ? ea._ct_id : ea }
+        scope = descendant_ids.blank? ? all : joins(:descendant_hierarchies).
+          where("#{_ct.hierarchy_table_name}.descendant_id" => descendant_ids).
+          where("#{_ct.hierarchy_table_name}.generations > 0").
+          readonly(false)
+        _ct.scope_with_order(scope)
+      end
+
       def find_all_by_generation(generation_level)
         s = joins(<<-SQL.strip_heredoc)
           INNER JOIN (
             SELECT #{primary_key} as root_id
             FROM #{_ct.quoted_table_name}
             WHERE #{_ct.quoted_parent_column_name} IS NULL
-          ) AS roots ON (1 = 1)
+          ) #{ _ct.t_alias_keyword }  roots ON (1 = 1)
           INNER JOIN (
             SELECT ancestor_id, descendant_id
             FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY ancestor_id, descendant_id
             HAVING MAX(generations) = #{generation_level.to_i}
-          ) AS descendants ON (
+          ) #{ _ct.t_alias_keyword }  descendants ON (
             #{_ct.quoted_table_name}.#{primary_key} = descendants.descendant_id
             AND roots.root_id = descendants.ancestor_id
           )
@@ -112,6 +121,7 @@ module ClosureTree
 
       # Find the node whose +ancestry_path+ is +path+
       def find_by_path(path, attributes = {}, parent_id = nil)
+        return nil if path.blank?
         path = _ct.build_ancestry_attr_path(path, attributes)
         if path.size > _ct.max_join_tables
           return _ct.find_by_large_path(path, attributes, parent_id)
@@ -121,7 +131,7 @@ module ClosureTree
         path.reverse.each_with_index do |ea, idx|
           next_joined_table = "p#{idx}"
           scope = scope.joins(<<-SQL.strip_heredoc)
-            INNER JOIN #{_ct.quoted_table_name} AS #{next_joined_table}
+            INNER JOIN #{_ct.quoted_table_name} #{ _ct.t_alias_keyword } #{next_joined_table}
               ON #{next_joined_table}.#{_ct.quoted_id_column_name} =
  #{connection.quote_table_name(last_joined_table)}.#{_ct.quoted_parent_column_name}
           SQL

data/lib/closure_tree/has_closure_tree.rb

@@ -8,6 +8,8 @@ module ClosureTree
         :hierarchy_table_name,
         :name_column,
         :order,
+        :dont_order_roots,
+        :numeric_order,
         :touch,
         :with_advisory_lock
       )

data/lib/closure_tree/has_closure_tree_root.rb

@@ -1,15 +1,11 @@
 module ClosureTree
   class MultipleRootError < StandardError; end
+  class RootOrderingDisabledError < 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[:class_name] ||= assoc_name.to_s.sub(/\Aroot_/, "").classify
       options[:foreign_key] ||= self.name.underscore << "_id"
 
       has_one assoc_name, -> { where(parent: nil) }, options

data/lib/closure_tree/hash_tree_support.rb

@@ -10,7 +10,7 @@ module ClosureTree
             FROM #{quoted_hierarchy_table_name}
             GROUP BY descendant_id
             #{having_clause}
-          ) AS generation_depth
+          ) #{ t_alias_keyword } generation_depth
             ON #{quoted_table_name}.#{model_class.primary_key} = generation_depth.descendant_id
         SQL
         scope_with_order(scope.joins(generation_depth), 'generation_depth.depth')

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -20,7 +20,7 @@ module ClosureTree
     end
 
     def _ct_validate
-      if !@_ct_skip_cycle_detection &&
+      if !(defined? @_ct_skip_cycle_detection) &&
         !new_record? && # don't validate for cycles if we're a new record
         changes[_ct.parent_column_name] && # don't validate for cycles if we didn't change our parent
         parent.present? && # don't validate if we're root
@@ -64,7 +64,7 @@ module ClosureTree
 
     def rebuild!(called_by_rebuild = false)
       _ct.with_advisory_lock do
-        delete_hierarchy_references unless @was_new_record
+        delete_hierarchy_references unless (defined? @was_new_record) && @was_new_record
         hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
         unless root?
           _ct.connection.execute <<-SQL.strip_heredoc
@@ -102,7 +102,7 @@ module ClosureTree
               FROM #{_ct.quoted_hierarchy_table_name}
               WHERE ancestor_id = #{_ct.quote(id)}
                  OR descendant_id = #{_ct.quote(id)}
-            ) AS x )
+            ) #{ _ct.t_alias_keyword } x )
         SQL
       end
     end

data/lib/closure_tree/model.rb

@@ -13,7 +13,7 @@ module ClosureTree
         touch: _ct.options[:touch],
         optional: true)
 
-      order_by_generations = "#{_ct.quoted_hierarchy_table_name}.generations asc"
+      order_by_generations = -> { Arel.sql("#{_ct.quoted_hierarchy_table_name}.generations ASC") }
 
       has_many :children, *_ct.has_many_with_order_option(
         class_name: _ct.model_class.to_s,
@@ -134,6 +134,36 @@ module ClosureTree
       _ct.ids_from(siblings)
     end
 
+    # node's parent is this record
+    def parent_of?(node)
+      self == node.parent
+    end
+
+    # node's root is this record
+    def root_of?(node)
+      self == node.root
+    end
+
+    # node's ancestors include this record
+    def ancestor_of?(node)
+      node.ancestors.include? self
+    end
+
+    # node is record's ancestor
+    def descendant_of?(node)
+      self.ancestors.include? node
+    end
+
+    # node is record's parent
+    def child_of?(node)
+      self.parent == node
+    end
+
+    # node and record have a same root
+    def family_of?(node)
+      self.root == node.root
+    end
+
     # Alias for appending to the children collection.
     # You can also add directly to the children collection, if you'd prefer.
     def add_child(child_node)