closure_tree 6.0.0.alpha → 6.0.0.gamma

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7fc5558a4e6b00aab12761e615cd4fe3925ce3c
-  data.tar.gz: baf418817e89ee4dbc66717627e4871eaed2134c
+  metadata.gz: d32d23158e9b974aeffc5fe307d6dc59aa37907b
+  data.tar.gz: 190e8a6f9a7e8678657f82de4335aa14f9239a0c
 SHA512:
-  metadata.gz: ec01be25fc3f9c11c539c6892603839d33f77f4e4429653d3e3ba68c4548a0921f26311c9fe7cade4cf0c9bbee13ab00546b8e8b677d8e1b567379c8f3fb1458
-  data.tar.gz: 2f9021c6d64f1d3d0436bcc6439113bdb12fe7d768ead39d6523498f0e03a2a6e5abf04cbfec607af82f8f512d552559d995b50f350ccc7095cee0207a476929
+  metadata.gz: a7cbc97513019349f2c193dcf3976bb402406b68e3c285a19d07717a0e3ff24f5fa7860aef0589ba634a3d0f57046eb8580bcb20587d14ee2d786277ba5d1401
+  data.tar.gz: e9efa70b8a6c7c5e048296ceef1d285d210db2e89497fd2ea8179ebdef60b85b53b174a9d8935a7aa69530e100a274eadc635ec89e98d4e194e4cfadc5136250

data/.travis.yml

@@ -2,7 +2,7 @@ cache: bundler
 sudo: false
 language: ruby
 rvm:
-  - 2.2
+  - 2.2.3
   - jruby-head
 
 gemfile:

data/CHANGELOG.md

@@ -1,7 +1,11 @@
 # Changelog
 
 ### 6.0.0.alpha
-* Drop support for unsupported version of Rails
+* Drop support for unsupported versions of Rails, 3.2 and 4.0.
+* Drop support for Ruby 1.9 and JRuby 1.9
+* Added support for `.hash_tree` from `.parent` and `.children`. 
+  Addresses [PR146](https://github.com/mceachen/closure_tree/pull/146).
+  Thanks for reporting this and the breaking test, [Mike](https://github.com/mkralla11)!
 
 ### 5.2.0
 

data/README.md

@@ -480,7 +480,7 @@ the spec ```tag_spec.rb```:
       Tag.rebuild! # <- required if you use fixtures
     end
 ```
-`
+
 **However, if you're just starting with Rails, may I humbly suggest you adopt a factory library**,
 rather than using fixtures? [Lots of people have written about this already](https://www.google.com/search?q=fixtures+versus+factories).
 
@@ -552,7 +552,7 @@ See the [change log](https://github.com/mceachen/closure_tree/blob/master/CHANGE
 
 ## Thanks to
 
-* The more than 20 engineers around the world that have contributed their time and code to this gem
+* The more than 30 engineers around the world that have contributed their time and code to this gem
   (see the [changelog](https://github.com/mceachen/closure_tree/blob/master/CHANGELOG.md)!)
 * https://github.com/collectiveidea/awesome_nested_set
 * https://github.com/patshaughnessy/class_factory

data/lib/closure_tree/active_record_support.rb

@@ -1,5 +1,10 @@
 module ClosureTree
   module ActiveRecordSupport
+
+    def quote(field)
+      connection.quote(field)
+    end
+
     def ensure_fixed_table_name(table_name)
       [
         ActiveRecord::Base.table_name_prefix,

data/lib/closure_tree/finders.rb

@@ -52,11 +52,6 @@ module ClosureTree
 
     module ClassMethods
 
-      # Fix deprecation warning:
-      def _ct_all
-        (ActiveRecord::VERSION::MAJOR >= 4) ? all : scoped
-      end
-
       def without(instance)
         if instance.new_record?
           all
@@ -88,7 +83,7 @@ module ClosureTree
 
       def with_ancestor(*ancestors)
         ancestor_ids = ancestors.map { |ea| ea.is_a?(ActiveRecord::Base) ? ea._ct_id : ea }
-        scope = ancestor_ids.blank? ? _ct_all : joins(:ancestor_hierarchies).
+        scope = ancestor_ids.blank? ? all : joins(:ancestor_hierarchies).
           where("#{_ct.hierarchy_table_name}.ancestor_id" => ancestor_ids).
           where("#{_ct.hierarchy_table_name}.generations > 0").
           readonly(false)

data/lib/closure_tree/hash_tree.rb

@@ -2,17 +2,8 @@ module ClosureTree
   module HashTree
     extend ActiveSupport::Concern
 
-    def hash_tree_scope(limit_depth = nil)
-      scope = self_and_descendants
-      if limit_depth
-        scope.where("#{_ct.quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}")
-      else
-        scope
-      end
-    end
-
     def hash_tree(options = {})
-      self.class.build_hash_tree(hash_tree_scope(options[:limit_depth]))
+      _ct.hash_tree(self_and_descendants, options[:limit_depth])
     end
 
     module ClassMethods
@@ -20,39 +11,7 @@ module ClosureTree
       # There is no default depth limit. This might be crazy-big, depending
       # on your tree shape. Hash huge trees at your own peril!
       def hash_tree(options = {})
-        build_hash_tree(hash_tree_scope(options[:limit_depth]))
-      end
-
-      def hash_tree_scope(limit_depth = nil)
-        # Deepest generation, within limit, for each descendant
-        # NOTE: Postgres requires HAVING clauses to always contains aggregate functions (!!)
-        having_clause = limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ''
-        generation_depth = <<-SQL.strip_heredoc
-          INNER JOIN (
-            SELECT descendant_id, MAX(generations) as depth
-            FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY descendant_id
-            #{having_clause}
-          ) AS generation_depth
-            ON #{_ct.quoted_table_name}.#{primary_key} = generation_depth.descendant_id
-        SQL
-        _ct.scope_with_order(joins(generation_depth), "generation_depth.depth")
-      end
-
-      # Builds nested hash structure using the scope returned from the passed in scope
-      def build_hash_tree(tree_scope)
-        tree = ActiveSupport::OrderedHash.new
-        id_to_hash = {}
-
-        tree_scope.each do |ea|
-          h = id_to_hash[ea.id] = ActiveSupport::OrderedHash.new
-          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
-          end
-        end
-        tree
+        _ct.hash_tree(nil, options[:limit_depth])
       end
     end
   end

data/lib/closure_tree/hash_tree_support.rb

@@ -0,0 +1,40 @@
+module ClosureTree
+  module HashTreeSupport
+    def default_tree_scope(limit_depth = nil)
+        # Deepest generation, within limit, for each descendant
+        # NOTE: Postgres requires HAVING clauses to always contains aggregate functions (!!)
+        having_clause = limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ''
+        generation_depth = <<-SQL.strip_heredoc
+          INNER JOIN (
+            SELECT descendant_id, MAX(generations) as depth
+            FROM #{quoted_hierarchy_table_name}
+            GROUP BY descendant_id
+            #{having_clause}
+          ) AS generation_depth
+            ON #{quoted_table_name}.#{model_class.primary_key} = generation_depth.descendant_id
+        SQL
+        scope_with_order(model_class.joins(generation_depth), 'generation_depth.depth')
+      end
+
+    def hash_tree(tree_scope, limit_depth = nil)
+      limited_scope = if tree_scope
+        limit_depth ? tree_scope.where("#{quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}") : tree_scope
+      else
+        default_tree_scope(limit_depth)
+      end
+      build_hash_tree(limited_scope)
+    end
+
+    # Builds nested hash structure using the scope returned from the passed in scope
+    def build_hash_tree(tree_scope)
+      tree = ActiveSupport::OrderedHash.new
+      id_to_hash = {}
+
+      tree_scope.each do |ea|
+        h = id_to_hash[ea.id] = ActiveSupport::OrderedHash.new
+        (id_to_hash[ea._ct_parent_id] || tree)[ea] = h
+      end
+      tree
+    end
+  end
+end

data/lib/closure_tree/model.rb

@@ -17,7 +17,14 @@ module ClosureTree
         class_name: _ct.model_class.to_s,
         foreign_key: _ct.parent_column_name,
         dependent: _ct.options[:dependent],
-        inverse_of: :parent)
+        inverse_of: :parent) do
+          # We have to redefine hash_tree because the activerecord relation is already scoped to parent_id.
+          def hash_tree(options = {})
+            # we want limit_depth + 1 because we don't do self_and_descendants.
+            limit_depth = options[:limit_depth]
+            _ct.hash_tree(@association.owner.descendants, limit_depth ? limit_depth + 1 : nil)
+          end
+        end
 
       has_many :ancestor_hierarchies, *_ct.has_many_without_order_option(
         class_name: _ct.hierarchy_class_name,

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -27,13 +27,6 @@ module ClosureTree
 
     def self_and_descendants_preordered
       # TODO: raise NotImplementedError if sort_order is not numeric and not null?
-      h = _ct.connection.select_one(<<-SQL)
-        SELECT
-          count(*) as total_descendants,
-          max(generations) as max_depth
-        FROM #{_ct.quoted_hierarchy_table_name}
-        WHERE ancestor_id = #{_ct.quote(self.id)}
-      SQL
       join_sql = <<-SQL
         JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
           ON anc_hier.descendant_id = #{_ct.quoted_hierarchy_table_name}.descendant_id
@@ -42,20 +35,35 @@ module ClosureTree
         JOIN #{_ct.quoted_hierarchy_table_name} depths
           ON depths.ancestor_id = #{_ct.quote(self.id)} AND depths.descendant_id = anc.#{_ct.quoted_id_column_name}
       SQL
-      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("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}").reorder(order_by)
+
+      self_and_descendants
+        .joins(join_sql)
+        .group("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}")
+        .reorder(self.class._ct_sum_order_by(self))
     end
 
     module ClassMethods
-      def roots_and_descendants_preordered
-        h = _ct.connection.select_one(<<-SQL.strip_heredoc)
+
+      # If node is nil, order the whole tree.
+      def _ct_sum_order_by(node = nil)
+        stats_sql = <<-SQL.strip_heredoc
           SELECT
             count(*) as total_descendants,
             max(generations) as max_depth
           FROM #{_ct.quoted_hierarchy_table_name}
         SQL
+        stats_sql += " WHERE ancestor_id = #{_ct.quote(node.id)}" if node
+        h = _ct.connection.select_one(stats_sql)
+
+        depth_column = node ? 'depths.generations' : 'depths.max_depth'
+
+        node_score = "(1 + anc.#{_ct.quoted_order_column(false)}) * " +
+          "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - #{depth_column})"
+
+        "sum(#{node_score})"
+      end
+
+      def roots_and_descendants_preordered
         join_sql = <<-SQL.strip_heredoc
           JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
             ON anc_hier.descendant_id = #{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}
@@ -67,10 +75,9 @@ module ClosureTree
             GROUP BY 1
           ) AS depths ON depths.descendant_id = anc.#{_ct.quoted_id_column_name}
         SQL
-        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("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}").reorder(order_by)
+        joins(join_sql)
+          .group("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}")
+          .reorder(_ct_sum_order_by)
       end
     end
 

data/lib/closure_tree/support.rb

@@ -2,6 +2,7 @@ require 'closure_tree/support_flags'
 require 'closure_tree/support_attributes'
 require 'closure_tree/numeric_order_support'
 require 'closure_tree/active_record_support'
+require 'closure_tree/hash_tree_support'
 require 'with_advisory_lock'
 
 # This class and mixins are an effort to reduce the namespace pollution to models that act_as_tree.
@@ -10,6 +11,7 @@ module ClosureTree
     include ClosureTree::SupportFlags
     include ClosureTree::SupportAttributes
     include ClosureTree::ActiveRecordSupport
+    include ClosureTree::HashTreeSupport
 
     attr_reader :model_class
     attr_reader :options
@@ -22,7 +24,7 @@ module ClosureTree
         :name_column => 'name',
         :with_advisory_lock => true
       }.merge(options)
-      raise IllegalArgumentException, "name_column can't be 'path'" if options[:name_column] == 'path'
+      raise ArgumentError, "name_column can't be 'path'" if options[:name_column] == 'path'
       if order_is_numeric?
         extend NumericOrderSupport.adapter_for_connection(connection)
       end
@@ -59,10 +61,6 @@ module ClosureTree
       ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
     end
 
-    def quote(field)
-      connection.quote(field)
-    end
-
     def with_order_option(opts)
       if order_option?
         opts[:order] = [opts[:order], order_by].compact.join(",")
@@ -80,20 +78,12 @@ module ClosureTree
 
     # lambda-ize the order, but don't apply the default order_option
     def has_many_without_order_option(opts)
-      if ActiveRecord::VERSION::MAJOR > 3
         [lambda { order(opts[:order]) }, opts.except(:order)]
-      else
-        [opts]
-      end
     end
 
     def has_many_with_order_option(opts)
-      if ActiveRecord::VERSION::MAJOR > 3
-        order_options = [opts[:order], order_by].compact
-        [lambda { order(order_options) }, opts.except(:order)]
-      else
-        [with_order_option(opts)]
-      end
+      order_options = [opts[:order], order_by].compact
+      [lambda { order(order_options) }, opts.except(:order)]
     end
 
     def ids_from(scope)

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = Gem::Version.new('6.0.0.alpha')
+  VERSION = Gem::Version.new('6.0.0.gamma')
 end

data/spec/support/database.rb

@@ -45,7 +45,7 @@ require "#{database_folder}/models"
 def count_queries(&block)
   count = 0
   counter_fn = ->(name, started, finished, unique_id, payload) do
-    count += 1 unless payload[:name].in? %w[CACHE SCHEMA]
+    count += 1 unless %w[CACHE SCHEMA].include? payload[:name]
   end
   ActiveSupport::Notifications.subscribed(counter_fn, 'sql.active_record', &block)
   count

data/spec/tag_examples.rb

@@ -20,25 +20,25 @@ shared_examples_for Tag do
     end
 
     it 'should have a correct parent column name' do
-      expected_parent_column_name = tag_class == UUIDTag ? "parent_uuid" : "parent_id"
+      expected_parent_column_name = tag_class == UUIDTag ? 'parent_uuid' : 'parent_id'
       expect(tag_class._ct.parent_column_name).to eq(expected_parent_column_name)
     end
   end
 
-  describe "from empty db" do
+  describe 'from empty db' do
 
-    context "with no tags" do
-      it "should return no entities" do
+    context 'with no tags' do
+      it 'should return no entities' do
         expect(tag_class.roots).to be_empty
         expect(tag_class.leaves).to be_empty
       end
 
-      it "#find_or_create_by_path with strings" do
+      it '#find_or_create_by_path with strings' do
         a = tag_class.create!(name: 'a')
         expect(a.find_or_create_by_path(%w{b c}).ancestry_path).to eq(%w{a b c})
       end
 
-      it "#find_or_create_by_path with hashes" do
+      it '#find_or_create_by_path with hashes' do
         a = tag_class.create!(name: 'a', title: 'A')
         subject = a.find_or_create_by_path([
           {name: 'b', title: 'B'},
@@ -49,16 +49,16 @@ shared_examples_for Tag do
       end
     end
 
-    context "with 1 tag" do
+    context 'with 1 tag' do
       before do
-        @tag = tag_class.create!(name: "tag")
+        @tag = tag_class.create!(name: 'tag')
       end
 
-      it "should be a leaf" do
+      it 'should be a leaf' do
         expect(@tag.leaf?).to be_truthy
       end
 
-      it "should be a root" do
+      it 'should be a root' do
         expect(@tag.root?).to be_truthy
       end
 
@@ -66,13 +66,13 @@ shared_examples_for Tag do
         expect(@tag.parent).to be_nil
       end
 
-      it "should return the only entity as a root and leaf" do
+      it 'should return the only entity as a root and leaf' do
         expect(tag_class.all).to eq([@tag])
         expect(tag_class.roots).to eq([@tag])
         expect(tag_class.leaves).to eq([@tag])
       end
 
-      context "with child" do
+      context 'with child' do
         before do
           @child = tag_class.create!(name: 'tag 2')
         end
@@ -90,13 +90,13 @@ shared_examples_for Tag do
           expect(@tag.reload.children.to_a).to eq([@child])
         end
 
-        it "adds children through add_child" do
+        it 'adds children through add_child' do
           @tag.add_child @child
           assert_roots_and_leaves
           assert_parent_and_children
         end
 
-        it "adds children through collection" do
+        it 'adds children through collection' do
           @tag.children << @child
           assert_roots_and_leaves
           assert_parent_and_children
@@ -104,48 +104,48 @@ shared_examples_for Tag do
       end
     end
 
-    context "with 2 tags" do
+    context 'with 2 tags' do
       before :each do
-        @root = tag_class.create!(name: "root")
-        @leaf = @root.add_child(tag_class.create!(name: "leaf"))
+        @root = tag_class.create!(name: 'root')
+        @leaf = @root.add_child(tag_class.create!(name: 'leaf'))
       end
-      it "should return a simple root and leaf" do
+      it 'should return a simple root and leaf' do
         expect(tag_class.roots).to eq([@root])
         expect(tag_class.leaves).to eq([@leaf])
       end
-      it "should return child_ids for root" do
+      it 'should return child_ids for root' do
         expect(@root.child_ids).to eq([@leaf.id])
       end
 
-      it "should return an empty array for leaves" do
+      it 'should return an empty array for leaves' do
         expect(@leaf.child_ids).to be_empty
       end
     end
 
-    context "3 tag collection.create db" do
+    context '3 tag collection.create db' do
       before :each do
-        @root = tag_class.create! name: "root"
-        @mid = @root.children.create! name: "mid"
-        @leaf = @mid.children.create! name: "leaf"
+        @root = tag_class.create! name: 'root'
+        @mid = @root.children.create! name: 'mid'
+        @leaf = @mid.children.create! name: 'leaf'
         DestroyedTag.delete_all
       end
 
-      it "should create all tags" do
+      it 'should create all tags' do
         expect(tag_class.all.to_a).to match_array([@root, @mid, @leaf])
       end
 
-      it "should return a root and leaf without middle tag" do
+      it 'should return a root and leaf without middle tag' do
         expect(tag_class.roots).to eq([@root])
         expect(tag_class.leaves).to eq([@leaf])
       end
 
-      it "should delete leaves" do
+      it 'should delete leaves' do
         tag_class.leaves.destroy_all
         expect(tag_class.roots).to eq([@root]) # untouched
         expect(tag_class.leaves).to eq([@mid])
       end
 
-      it "should delete everything if you delete the roots" do
+      it 'should delete everything if you delete the roots' do
         tag_class.roots.destroy_all
         expect(tag_class.all).to be_empty
         expect(tag_class.roots).to be_empty
@@ -167,7 +167,7 @@ shared_examples_for Tag do
       end
 
       it 'moves non-leaves' do
-        new_root = tag_class.create! name: "new_root"
+        new_root = tag_class.create! name: 'new_root'
         new_root.children << @mid
         expect(@root.reload.descendants).to be_empty
         expect(new_root.descendants).to eq([@mid, @leaf])
@@ -175,7 +175,7 @@ shared_examples_for Tag do
       end
 
       it 'moves leaves' do
-        new_root = tag_class.create! name: "new_root"
+        new_root = tag_class.create! name: 'new_root'
         new_root.children << @leaf
         expect(new_root.descendants).to eq([@leaf])
         expect(@root.reload.descendants).to eq([@mid])
@@ -183,46 +183,46 @@ shared_examples_for Tag do
       end
     end
 
-    context "3 tag explicit_create db" do
+    context '3 tag explicit_create db' do
       before :each do
-        @root = tag_class.create!(name: "root")
-        @mid = @root.add_child(tag_class.create!(name: "mid"))
-        @leaf = @mid.add_child(tag_class.create!(name: "leaf"))
+        @root = tag_class.create!(name: 'root')
+        @mid = @root.add_child(tag_class.create!(name: 'mid'))
+        @leaf = @mid.add_child(tag_class.create!(name: 'leaf'))
       end
 
-      it "should create all tags" do
+      it 'should create all tags' do
         expect(tag_class.all.to_a).to match_array([@root, @mid, @leaf])
       end
 
-      it "should return a root and leaf without middle tag" do
+      it 'should return a root and leaf without middle tag' do
         expect(tag_class.roots).to eq([@root])
         expect(tag_class.leaves).to eq([@leaf])
       end
 
-      it "should prevent parental loops from torso" do
+      it 'should prevent parental loops from torso' do
         @mid.children << @root
         expect(@root.valid?).to be_falsey
         expect(@mid.reload.children).to eq([@leaf])
       end
 
-      it "should prevent parental loops from toes" do
+      it 'should prevent parental loops from toes' do
         @leaf.children << @root
         expect(@root.valid?).to be_falsey
         expect(@leaf.reload.children).to be_empty
       end
 
-      it "should support re-parenting" do
+      it 'should support re-parenting' do
         @root.children << @leaf
         expect(tag_class.leaves).to eq([@leaf, @mid])
       end
 
-      it "cleans up hierarchy references for leaves" do
+      it 'cleans up hierarchy references for leaves' do
         @leaf.destroy
         expect(tag_hierarchy_class.where(ancestor_id: @leaf.id)).to be_empty
         expect(tag_hierarchy_class.where(descendant_id: @leaf.id)).to be_empty
       end
 
-      it "cleans up hierarchy references" do
+      it 'cleans up hierarchy references' do
         @mid.destroy
         expect(tag_hierarchy_class.where(ancestor_id: @mid.id)).to be_empty
         expect(tag_hierarchy_class.where(descendant_id: @mid.id)).to be_empty
@@ -233,17 +233,17 @@ shared_examples_for Tag do
         expect(tag_hierarchy_class.where(descendant_id: @root.id)).to eq(root_hiers)
       end
 
-      it "should have different hash codes for each hierarchy model" do
+      it 'should have different hash codes for each hierarchy model' do
         hashes = tag_hierarchy_class.all.map(&:hash)
         expect(hashes).to match_array(hashes.uniq)
       end
 
-      it "should return the same hash code for equal hierarchy models" do
+      it 'should return the same hash code for equal hierarchy models' do
         expect(tag_hierarchy_class.first.hash).to eq(tag_hierarchy_class.first.hash)
       end
     end
 
-    it "performs as the readme says it does" do
+    it 'performs as the readme says it does' do
       grandparent = tag_class.create(name: 'Grandparent')
       parent = grandparent.children.create(name: 'Parent')
       child1 = tag_class.create(name: 'First Child', parent: parent)
@@ -252,13 +252,13 @@ shared_examples_for Tag do
       child3 = tag_class.new(name: 'Third Child')
       parent.add_child child3
       expect(grandparent.self_and_descendants.collect(&:name)).to eq(
-        ["Grandparent", "Parent", "First Child", "Second Child", "Third Child"]
+        ['Grandparent', 'Parent', 'First Child', 'Second Child', 'Third Child']
       )
       expect(child1.ancestry_path).to eq(
-        ["Grandparent", "Parent", "First Child"]
+        ['Grandparent', 'Parent', 'First Child']
       )
       expect(child3.ancestry_path).to eq(
-        ["Grandparent", "Parent", "Third Child"]
+        ['Grandparent', 'Parent', 'Third Child']
       )
       d = tag_class.find_or_create_by_path %w(a b c d)
       h = tag_class.find_or_create_by_path %w(e f g h)
@@ -267,8 +267,8 @@ shared_examples_for Tag do
       expect(h.ancestry_path).to eq(%w(a b c d e f g h))
     end
 
-    it "roots sort alphabetically" do
-      expected = ("a".."z").to_a
+    it 'roots sort alphabetically' do
+      expected = ('a'..'z').to_a
       expected.shuffle.each { |ea| tag_class.create!(name: ea) }
       expect(tag_class.roots.collect { |ea| ea.name }).to eq(expected)
     end
@@ -403,7 +403,7 @@ shared_examples_for Tag do
           expect(@child.self_and_ancestors).to eq([@child, @parent, @grandparent])
         end
 
-        it "should find by path" do
+        it 'should find by path' do
           # class method:
           expect(tag_class.find_by_path(%w{grandparent parent child})).to eq(@child)
           # instance method:
@@ -412,7 +412,7 @@ shared_examples_for Tag do
           expect(@parent.find_by_path(%w{child larvae})).to be_nil
         end
 
-        it "should respect attribute hashes with both selection and creation" do
+        it 'should respect attribute hashes with both selection and creation' do
           expected_title = 'something else'
           attrs = {title: expected_title}
           existing_title = @grandparent.title
@@ -422,7 +422,7 @@ shared_examples_for Tag do
           expect(@grandparent.reload.title).to eq(existing_title)
         end
 
-        it "should create a hierarchy with a given attribute" do
+        it 'should create a hierarchy with a given attribute' do
           expected_title = 'unicorn rainbows'
           attrs = {title: expected_title}
           child = tag_class.find_or_create_by_path(%w{grandparent parent child}, attrs)
@@ -433,20 +433,20 @@ shared_examples_for Tag do
         end
       end
 
-      it "finds correctly rooted paths" do
+      it 'finds correctly rooted paths' do
         decoy = tag_class.find_or_create_by_path %w(a b c d)
         b_d = tag_class.find_or_create_by_path %w(b c d)
         expect(tag_class.find_by_path(%w(b c d))).to eq(b_d)
         expect(tag_class.find_by_path(%w(c d))).to be_nil
       end
 
-      it "find_by_path for 1 node" do
+      it 'find_by_path for 1 node' do
         b = tag_class.find_or_create_by_path %w(a b)
         b2 = b.root.find_by_path(%w(b))
         expect(b2).to eq(b)
       end
 
-      it "find_by_path for 2 nodes" do
+      it 'find_by_path for 2 nodes' do
         path = %w(a b c)
         c = tag_class.find_or_create_by_path path
         permutations = path.permutation.to_a
@@ -457,34 +457,34 @@ shared_examples_for Tag do
         end
       end
 
-      it "find_by_path for 3 nodes" do
+      it 'find_by_path for 3 nodes' do
         d = tag_class.find_or_create_by_path %w(a b c d)
         expect(d.root.find_by_path(%w(b c d))).to eq(d)
         expect(tag_class.find_by_path(%w(a b c d))).to eq(d)
         expect(tag_class.find_by_path(%w(d))).to be_nil
       end
 
-      it "should return nil for missing nodes" do
+      it 'should return nil for missing nodes' do
         expect(tag_class.find_by_path(%w{missing})).to be_nil
         expect(tag_class.find_by_path(%w{grandparent missing})).to be_nil
         expect(tag_class.find_by_path(%w{grandparent parent missing})).to be_nil
         expect(tag_class.find_by_path(%w{grandparent parent missing child})).to be_nil
       end
 
-      describe ".find_or_create_by_path" do
-        it "uses existing records" do
+      describe '.find_or_create_by_path' do
+        it 'uses existing records' do
           grandparent = tag_class.find_or_create_by_path(%w{grandparent})
           expect(grandparent).to eq(grandparent)
           child = tag_class.find_or_create_by_path(%w{grandparent parent child})
           expect(child).to eq(child)
         end
 
-        it "creates 2-deep trees with strings" do
+        it 'creates 2-deep trees with strings' do
           subject = tag_class.find_or_create_by_path(%w{events anniversary})
           expect(subject.ancestry_path).to eq(%w{events anniversary})
         end
 
-        it "creates 2-deep trees with hashes" do
+        it 'creates 2-deep trees with hashes' do
           subject = tag_class.find_or_create_by_path([
             {name: 'test1', title: 'TEST1'},
             {name: 'test2', title: 'TEST2'}
@@ -497,93 +497,129 @@ shared_examples_for Tag do
       end
     end
 
-    context "hash_tree" do
-
+    context 'hash_tree' do
       before :each do
-        @b = tag_class.find_or_create_by_path %w(a b)
+        @d1 = tag_class.find_or_create_by_path %w(a b c1 d1)
+        @c1 = @d1.parent
+        @b = @c1.parent
         @a = @b.parent
+        @a2 = tag_class.create(name: 'a2')
         @b2 = tag_class.find_or_create_by_path %w(a b2)
-        @d1 = @b.find_or_create_by_path %w(c1 d1)
-        @c1 = @d1.parent
-        @d2 = @b.find_or_create_by_path %w(c2 d2)
-        @c2 = @d2.parent
-        @full_tree = {@a => {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}, @b2 => {}}}
+        @c3 = tag_class.find_or_create_by_path %w(a3 b3 c3)
+        @b3 = @c3.parent
+        @a3 = @b3.parent
+        @tree2 = {
+          @a => {@b => {}, @b2 => {}}, @a2 => {}, @a3 => {@b3 => {}}
+        }
+
+        @one_tree = {
+          @a => {},
+          @a2 => {},
+          @a3 => {}
+        }
+        @two_tree = {
+          @a => {
+            @b => {},
+            @b2 => {}
+          },
+          @a2 => {},
+          @a3 => {
+            @b3 => {}
+          }
+        }
+        @three_tree = {
+          @a => {
+            @b => {
+              @c1 => {},
+            },
+            @b2 => {}
+          },
+          @a2 => {},
+          @a3 => {
+            @b3 => {
+              @c3 => {}
+            }
+          }
+        }
+        @full_tree = {
+          @a => {
+            @b => {
+              @c1 => {
+                @d1 => {}
+              },
+            },
+            @b2 => {}
+          },
+          @a2 => {},
+          @a3 => {
+            @b3 => {
+              @c3 => {}
+            }
+          }
+        }
         #File.open("example.dot", "w") { |f| f.write(tag_class.root.to_dot_digraph) }
       end
 
-      context "#hash_tree" do
-        it "returns {} for depth 0" do
+      context '#hash_tree' do
+        it 'returns {} for depth 0' do
           expect(tag_class.hash_tree(limit_depth: 0)).to eq({})
         end
-        it "limit_depth 1" do
-          expect(tag_class.hash_tree(limit_depth: 1)).to eq({@a => {}})
+        it 'limit_depth 1' do
+          expect(tag_class.hash_tree(limit_depth: 1)).to eq(@one_tree)
         end
-        it "limit_depth 2" do
-          expect(tag_class.hash_tree(limit_depth: 2)).to eq({@a => {@b => {}, @b2 => {}}})
+        it 'limit_depth 2' do
+          expect(tag_class.hash_tree(limit_depth: 2)).to eq(@two_tree)
         end
-        it "limit_depth 3" do
-          expect(tag_class.hash_tree(limit_depth: 3)).to eq({@a => {@b => {@c1 => {}, @c2 => {}}, @b2 => {}}})
+        it 'limit_depth 3' do
+          expect(tag_class.hash_tree(limit_depth: 3)).to eq(@three_tree)
         end
-        it "limit_depth 4" do
+        it 'limit_depth 4' do
           expect(tag_class.hash_tree(limit_depth: 4)).to eq(@full_tree)
         end
-        it "no limit holdum" do
+        it 'no limit' do
           expect(tag_class.hash_tree).to eq(@full_tree)
         end
       end
 
-      def assert_no_dupes(scope)
-        # the named scope is complicated enough that an incorrect join could result in unnecessarily
-        # duplicated rows:
-        a = scope.collect { |ea| ea.id }
-        expect(a).to eq(a.uniq)
-      end
-
-      context "#hash_tree_scope" do
-        it "no dupes for any depth" do
-          (0..5).each do |ea|
-            assert_no_dupes(tag_class.hash_tree_scope(ea))
-          end
+      context '.hash_tree' do
+        it 'returns {} for depth 0' do
+          expect(@b.hash_tree(limit_depth: 0)).to eq({})
         end
-        it "no limit holdum" do
-          assert_no_dupes(tag_class.hash_tree_scope)
+        it 'limit_depth 1' do
+          expect(@b.hash_tree(limit_depth: 1)).to eq(@two_tree[@a].slice(@b))
         end
-      end
-
-      context ".hash_tree_scope" do
-        it "no dupes for any depth" do
-          (0..5).each do |ea|
-            assert_no_dupes(@a.hash_tree_scope(ea))
-          end
+        it 'limit_depth 2' do
+          expect(@b.hash_tree(limit_depth: 2)).to eq(@three_tree[@a].slice(@b))
         end
-        it "no limit holdum" do
-          assert_no_dupes(@a.hash_tree_scope)
+        it 'limit_depth 3' do
+          expect(@b.hash_tree(limit_depth: 3)).to eq(@full_tree[@a].slice(@b))
         end
-      end
-
-      context ".hash_tree" do
-        before :each do
+        it 'no limit from subsubroot' do
+          expect(@c1.hash_tree).to eq(@full_tree[@a][@b].slice(@c1))
         end
-        it "returns {} for depth 0" do
-          expect(@b.hash_tree(limit_depth: 0)).to eq({})
+        it 'no limit from subroot' do
+          expect(@b.hash_tree).to eq(@full_tree[@a].slice(@b))
         end
-        it "limit_depth 1" do
-          expect(@b.hash_tree(limit_depth: 1)).to eq({@b => {}})
+        it 'no limit from root' do
+          expect(@a.hash_tree.merge(@a2.hash_tree)).to eq(@full_tree.slice(@a, @a2))
         end
-        it "limit_depth 2" do
-          expect(@b.hash_tree(limit_depth: 2)).to eq({@b => {@c1 => {}, @c2 => {}}})
+      end
+
+      context '.hash_tree from relations' do
+        it 'limit_depth 2 from chained activerecord association subroots' do
+          expect(@a.children.hash_tree(limit_depth: 2)).to eq(@three_tree[@a])
         end
-        it "limit_depth 3" do
-          expect(@b.hash_tree(limit_depth: 3)).to eq({@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}})
+        it 'no limit from chained activerecord association subroots' do
+          expect(@a.children.hash_tree).to eq(@full_tree[@a])
         end
-        it "no limit holdum from subsubroot" do
-          expect(@c1.hash_tree).to eq({@c1 => {@d1 => {}}})
+        it 'limit_depth 3 from b.parent' do
+          expect(@b.parent.hash_tree(limit_depth: 3)).to eq(@three_tree.slice(@a))
         end
-        it "no limit holdum from subroot" do
-          expect(@b.hash_tree).to eq({@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}})
+        it 'no limit_depth from b.parent' do
+          expect(@b.parent.hash_tree).to eq(@full_tree.slice(@a))
         end
-        it "no limit holdum from root" do
-          expect(@a.hash_tree).to eq(@full_tree)
+        it 'no limit_depth from c.parent' do
+          expect(@c1.parent.hash_tree).to eq(@full_tree[@a].slice(@b))
         end
       end
     end
@@ -600,7 +636,7 @@ shared_examples_for Tag do
 
     describe 'DOT rendering' do
       it 'should render for an empty scope' do
-        expect(tag_class.to_dot_digraph(tag_class.where("0=1"))).to eq("digraph G {\n}\n")
+        expect(tag_class.to_dot_digraph(tag_class.where('0=1'))).to eq("digraph G {\n}\n")
       end
       it 'should render for an empty scope' do
         tag_class.find_or_create_by_path(%w(a b1 c1))

data/tests.sh

@@ -1,6 +1,6 @@
 #!/bin/sh -ex
 
-for RMI in 2.1.5 #jruby-1.6.13 :P
+for RMI in 2.2.3 #jruby-1.6.13 :P
 do
   rbenv local $RMI
   for DB in postgresql mysql sqlite

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 6.0.0.alpha
+  version: 6.0.0.gamma
 platform: ruby
 authors:
 - Matthew McEachen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-05 00:00:00.000000000 Z
+date: 2015-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -166,6 +166,7 @@ files:
 - lib/closure_tree/finders.rb
 - lib/closure_tree/has_closure_tree.rb
 - lib/closure_tree/hash_tree.rb
+- lib/closure_tree/hash_tree_support.rb
 - lib/closure_tree/hierarchy_maintenance.rb
 - lib/closure_tree/model.rb
 - lib/closure_tree/numeric_deterministic_ordering.rb