closure_tree 5.0.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92930bde62d7c1d8460fcefb8964da22b6edca2b
-  data.tar.gz: fe1eb67d373bda0ce3e4f7a404e521d7dce52bf7
+  metadata.gz: df0555778d166d7f54acabde46e6118f2990c6c5
+  data.tar.gz: 837a50c2039d612eac26a9d4bf4ec106729991b0
 SHA512:
-  metadata.gz: e07b36bf6badfeb5d9035eddd650e821159a8963b71df737f8e42947401aecf7456a218fe34f787cad6f8ddbd341e11072fb4a23f1c96c8d45e0a8ba42290fae
-  data.tar.gz: f767928d73fefcc76338fe0edb444f6b282b7249dfa808e7f406f4b04593f63696ecabd23e3b421b39f2ea09f9883b9f4000a91c23ab3e24bcadfd8955a0f813
+  metadata.gz: 223f1243db513bc4754d6894f971799a0b998642841f5fb536b7023e9b4b8437ce3cca6b9e750477534b04674c46e49e00544022a2b1186f4d1cd4e691c10c9d
+  data.tar.gz: 5ca1595f2c52d857902d51020cc354b035272a210c5e3d6748071a86840beecc65ae996d6001ca5d4883c51175a6d30aa9b60aa34f4e429c55942676cba7ee73

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+### 5.1.0
+
+* [Abdelkader Boudih](https://github.com/seuros) added a database generator
+  for the hierarchies table. Thanks!
+* [Jason Weathered](https://github.com/jasoncodes) fixed [issue #117](https://github.com/mceachen/closure_tree/pull/117)
+  with the preordered traversal code that assumed the primary key column was called `id`. Thanks!   
+
 ### 5.0.0
 
 #### Breaking API changes

data/README.md

@@ -27,7 +27,7 @@ closure_tree has some great features:
   * 3 SQL INSERT/UPDATEs on node reparenting
 * __Support for [concurrency](#concurrency)__ (using [with_advisory_lock](https://github.com/mceachen/with_advisory_lock))
 * __Support for Rails 3.2, 4.0, and 4.1__
-* __Support for Ruby 1.9, 2.1, and jRuby 1.6.13
+* __Support for Ruby 1.9, 2.1, and jRuby 1.6.13__
 * Support for reparenting children (and all their descendants)
 * Support for [single-table inheritance (STI)](#sti) within the hierarchy
 * ```find_or_create_by_path``` for [building out heterogeneous hierarchies quickly and conveniently](#find_or_create_by_path)
@@ -56,16 +56,24 @@ for a description of different tree storage algorithms.
 
 Note that closure_tree only supports Rails 3.2 and later, and has test coverage for MySQL, PostgreSQL, and SQLite.
 
-1.  Add this to your Gemfile: ```gem 'closure_tree'```
+1.  Add `gem 'closure_tree'` to your Gemfile 
 
-2.  Run ```bundle install```
+2.  Run `bundle install`
 
-3.  Add ```acts_as_tree``` to your hierarchical model(s).
-    Make sure you add ```acts_as_tree``` *after any ```attr_accessible``` and ```self.table_name =```
-    lines in your model.
-    Please review the [available options](#available-options) you can provide.
+3.  Add `acts_as_tree` to your hierarchical model:
 
-4.  Add a migration to add a ```parent_id``` column to the model you want to act_as_tree.
+    ```ruby
+    class Tag < ActiveRecord::Base
+      acts_as_tree
+    end
+    ```
+
+    Make sure you check out the [large number options](#available-options) that `acts_as_tree` accepts.
+    
+    Make sure you add `acts_as_tree` **after** `attr_accessible` and
+    `self.table_name =` lines in your model.
+
+4.  Add a migration to add a `parent_id` column to the hierarchical model.
     You may want to also [add a column for deterministic ordering of children](#sort_order), but that's optional.
 
     ```ruby
@@ -76,40 +84,22 @@ Note that closure_tree only supports Rails 3.2 and later, and has test coverage
     end
     ```
 
-    Note that if the column is null, the tag will be considered a root node.
+    The column must be nullable. Root nodes have a `NULL` `parent_id`.
 
-5.  Add a database migration to store the hierarchy for your model. By
-    default the table name will be the model's table name, followed by
-    "_hierarchies". Note that by calling ```acts_as_tree```, a "virtual model" (in this case, ```TagHierarchy```)
-    will be added automatically, so you don't need to create it.
+5.  Run `rails g closure_tree:migration tag` (and replace `tag` with your model name)
+    to create the closure tree table for your model.
 
-    ```ruby
-    class CreateTagHierarchies < ActiveRecord::Migration
-      def change
-        create_table :tag_hierarchies, :id => false do |t|
-          t.integer  :ancestor_id, :null => false   # ID of the parent/grandparent/great-grandparent/... tag
-          t.integer  :descendant_id, :null => false # ID of the target tag
-          t.integer  :generations, :null => false   # Number of generations between the ancestor and the descendant. Parent/child = 1, for example.
-        end
-
-        # For "all progeny of…" and leaf selects:
-        add_index :tag_hierarchies, [:ancestor_id, :descendant_id, :generations],
-          :unique => true, :name => "tag_anc_desc_udx"
-
-        # For "all ancestors of…" selects,
-        add_index :tag_hierarchies, [:descendant_id],
-          :name => "tag_desc_idx"
-      end
-    end
-    ```
+    By default the table name will be the model's table name, followed by
+    "_hierarchies". Note that by calling ```acts_as_tree```, a "virtual model" (in this case, ```TagHierarchy```)
+    will be created dynamically. You don't need to create it.
 
-6.  Run ```rake db:migrate```
+6.  Run `rake db:migrate`
 
 7.  If you're migrating from another system where your model already has a
-    ```parent_id``` column, run ```Tag.rebuild!``` and your
-    ```tag_hierarchies``` table will be truncated and rebuilt.
+    `parent_id` column, run `Tag.rebuild!` and your
+    `tag_hierarchies` table will be truncated and rebuilt.
 
-    If you're starting from scratch you don't need to call ```rebuild!```.
+    If you're starting from scratch you don't need to call `rebuild!`.
 
 ## Usage
 
@@ -118,26 +108,26 @@ Note that closure_tree only supports Rails 3.2 and later, and has test coverage
 Create a root node:
 
 ```ruby
-grandparent = Tag.create(:name => 'Grandparent')
+grandparent = Tag.create(name: 'Grandparent')
 ```
 
 Child nodes are created by appending to the children collection:
 
 ```ruby
-parent = grandparent.children.create(:name => 'Parent')
+parent = grandparent.children.create(name: 'Parent')
 ```
 
 Or by appending to the children collection:
 
 ```ruby
-child2 = Tag.new(:name => 'Second Child')
+child2 = Tag.new(name: 'Second Child')
 parent.children << child2
 ```
 
 Or by calling the "add_child" method:
 
 ```ruby
-child3 = Tag.new(:name => 'Third Child')
+child3 = Tag.new(name: 'Third Child')
 parent.add_child child3
 ```
 
@@ -153,22 +143,22 @@ child1.ancestry_path
 
 ### find_or_create_by_path
 
-You can ```find``` as well as ```find_or_create``` by "ancestry paths".
+You can `find` as well as `find_or_create` by "ancestry paths".
 
 If you provide an array of strings to these methods, they reference the `name` column in your 
-model, which can be overridden with the `:name_column` option provided to ```acts_as_tree```.
+model, which can be overridden with the `:name_column` option provided to `acts_as_tree`.
 
 ```ruby
-child = Tag.find_or_create_by_path(["grandparent", "parent", "child"])
+child = Tag.find_or_create_by_path(%w[grandparent parent child])
 ```
 
 As of v5.0.0, `find_or_create_by_path` can also take an array of attribute hashes:
 
 ```ruby
 child = Tag.find_or_create_by_path([
-  {name: "Grandparent", title: "Sr."},
-  {name: "Parent", title: "Mrs."},
-  {name: "Child", title: "Jr."}
+  {name: 'Grandparent', title: 'Sr.'},
+  {name: 'Parent', title: 'Mrs.'},
+  {name: 'Child', title: 'Jr.'}
 ])
 ```
 
@@ -189,8 +179,8 @@ Nodes can be moved around to other parents, and closure_tree moves the node's de
 new parent for you:
 
 ```ruby
-d = Tag.find_or_create_by_path %w(a b c d)
-h = Tag.find_or_create_by_path %w(e f g h)
+d = Tag.find_or_create_by_path %w[a b c d]
+h = Tag.find_or_create_by_path %w[e f g h]
 e = h.root
 d.add_child(e) # "d.children << e" would work too, of course
 h.ancestry_path
@@ -486,7 +476,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).
 

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -38,14 +38,14 @@ module ClosureTree
         JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
           ON anc_hier.descendant_id = #{_ct.quoted_hierarchy_table_name}.descendant_id
         JOIN #{_ct.quoted_table_name} anc
-          ON anc.id = anc_hier.ancestor_id
+          ON anc.#{_ct.quoted_id_column_name} = anc_hier.ancestor_id
         JOIN #{_ct.quoted_hierarchy_table_name} depths
-          ON depths.ancestor_id = #{_ct.quote(self.id)} AND depths.descendant_id = anc.id
+          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}.id").reorder(order_by)
+      self_and_descendants.joins(join_sql).group("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}").reorder(order_by)
     end
 
     module ClassMethods
@@ -58,19 +58,19 @@ module ClosureTree
         SQL
         join_sql = <<-SQL.strip_heredoc
           JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
-            ON anc_hier.descendant_id = #{_ct.quoted_table_name}.id
+            ON anc_hier.descendant_id = #{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}
           JOIN #{_ct.quoted_table_name} anc
-            ON anc.id = anc_hier.ancestor_id
+            ON anc.#{_ct.quoted_id_column_name} = anc_hier.ancestor_id
           JOIN (
             SELECT descendant_id, max(generations) AS max_depth
             FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY 1
-          ) AS depths ON depths.descendant_id = anc.id
+          ) 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}.id").reorder(order_by)
+        joins(join_sql).group("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}").reorder(order_by)
       end
     end
 

data/lib/closure_tree/support_attributes.rb

@@ -21,6 +21,14 @@ module ClosureTree
       options[:hierarchy_class_name] || model_class.to_s + "Hierarchy"
     end
 
+    def primary_key_column
+      model_class.columns.detect { |ea| ea.name == model_class.primary_key }
+    end
+
+    def primary_key_type
+      primary_key_column.type
+    end
+
     def parent_column_name
       options[:parent_column_name]
     end

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = Gem::Version.new('5.0.0') unless defined?(::ClosureTree::VERSION)
+  VERSION = Gem::Version.new('5.1.0') unless defined?(::ClosureTree::VERSION)
 end

data/lib/generators/closure_tree/migration_generator.rb

@@ -0,0 +1,30 @@
+require 'rails/generators/named_base'
+require 'rails/generators/active_record/migration'
+require 'forwardable'
+
+module ClosureTree
+  module Generators # :nodoc:
+    class MigrationGenerator < ::Rails::Generators::NamedBase # :nodoc:
+      include ActiveRecord::Generators::Migration
+
+      extend Forwardable
+      def_delegators :ct, :hierarchy_table_name, :primary_key_type
+
+      def self.default_generator_root
+        File.dirname(__FILE__)
+      end
+
+      def create_migration_file
+        migration_template 'create_hierarchies_table.rb.erb', "db/migrate/create_#{singular_table_name}_hierarchies.rb"
+      end
+
+      def migration_class_name
+        "Create#{ct.hierarchy_class_name}".gsub(/\W/, '')
+      end
+
+      def ct
+        @ct ||= class_name.constantize._ct
+      end
+    end
+  end
+end

data/lib/generators/closure_tree/templates/create_hierarchies_table.rb.erb

@@ -0,0 +1,16 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def change
+    create_table :<%= hierarchy_table_name %>, id: false do |t|
+      t.<%= primary_key_type %> :ancestor_id, null: false
+      t.<%= primary_key_type %> :descendant_id, null: false
+      t.integer :generations, null: false
+    end
+
+    add_index :<%= hierarchy_table_name %>, [:ancestor_id, :descendant_id, :generations],
+      unique: true,
+      name: "anc_desc_idx"
+
+    add_index :<%= hierarchy_table_name -%>, [:descendant_id],
+      name: "desc_idx"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Matthew McEachen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-08 00:00:00.000000000 Z
+date: 2014-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -203,6 +203,8 @@ files:
 - lib/closure_tree/support_flags.rb
 - lib/closure_tree/test/matcher.rb
 - lib/closure_tree/version.rb
+- lib/generators/closure_tree/migration_generator.rb
+- lib/generators/closure_tree/templates/create_hierarchies_table.rb.erb
 - mktree.rb
 - spec/cache_invalidation_spec.rb
 - spec/cuisine_type_spec.rb