has_hierarchy 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c92de68d598ce6447ce4688b7425659aea75bc7c
-  data.tar.gz: 6d7c9fc5daadf07893bfbacec56ac7dce23476e0
+  metadata.gz: abe351194af5c2a75cbaad480fce586064fddad1
+  data.tar.gz: 283c8fd7fd5b8d27fdbe3b15bc4af195a90b15b5
 SHA512:
-  metadata.gz: e508fdf364899edbbad77b0ab59a5243442f2829622c82d0f709edb4b36e20dfbbec8c815cf8c7616ac1989f0ce9ea4bef3009c67274d43fb99717933dedc81d
-  data.tar.gz: e0fe3d89fbf0e180bc88be851c96aabc7fc6ad576b3273fba992547dd49ee9dcddc906cc1d8651513d70f442c63d2c1917347f40a9c13c66c2bc57c8b82c544f
+  metadata.gz: 8b529a4e0c3a0937d215feb5c77647c7ef9e7877ecdca68365bc888789d6abc050675e29ac0526dc27b14f7ece94b610849fdb2a6b982093f6e4ba779a414376
+  data.tar.gz: 12978bfbbbf31fd2d8ffcaed16c67fe1c029076af8365708ff54cb56de6accfe11879cb80b82fc5fb71880bf20d07ce777fc97550ffcd5cda54a3af3979e8497

data/.gitignore

@@ -1,6 +1,6 @@
-/*.gem
+*.gem
 /.bundle
 /Gemfile.lock
-/log
+/pkg
 /tmp
 /coverage

data/CHANGELOG.md

@@ -1,26 +1,51 @@
 # Changelog
 
+## 0.3.0
+
+- Added "path_separator" option.
+- Added ordering support.
+- Cleaned up options.
+- Renamed to has_hierarchy.
+
 ## 0.2.1
 
-- has_children-0.2.2
-- Rewrited specs.
+- Fixed `.find_by_node_path`.
+- Added tree rebuilding on node_id change.
+- Added depth caching.
 
 ## 0.2.0
 
-- has_children-0.2.0
+- Added custom node path values.
+- Added `.find_by_node_path`.
+- Added `#child_of?`.
+- Updated "node_path_column" option (renamed to "node_path_cache").
+- Rewrited specs.
+
+## 0.1.3
+
+- Added README.md.
+- Added `#leaf?`.
+- Added `has_children_options` accessor.
+- Added counter cache and root scope specs.
+- Updated "orphan_strategy" option (renamed to "dependent").
+- Updated rake tasks.
+- Updated .gitignore.
+- Updated codestyle.
+- Fixed rspec deprication warnings.
 
 ## 0.1.2
 
-- Added README.md
-- Updated dependencies.
-- has_children-0.1.3
-- has_order-0.1.2
+- Added root association.
+- Added `#root_id`.
+- Added `#root_of?`.
+- Added `#parent_of?`.
 
 ## 0.1.1
 
-- has_children-0.1.2
+- Fixed scopes (always using lambdas).
 
 ## 0.1.0
 
-- Added `#set_default_position?` support.
-- Updated dependencies.
+- Added `#move_children_to_parent`.
+- `#ancestor_tokens` renamed to `#ancestor_ids`.
+- Added lambda scopes support.

data/README.md

@@ -1,11 +1,11 @@
 [![Gem Version](https://badge.fury.io/rb/has_hierarchy.svg)](http://badge.fury.io/rb/has_hierarchy)
-[![Build Status](https://travis-ci.org/kolesnikovde/has_hierarchy.svg?branch=master)](https://travis-ci.org/kolesnikovde/has_hierarchy)
+[![Build Status](https://api.travis-ci.org/kolesnikovde/has_hierarchy.svg)](https://travis-ci.org/kolesnikovde/has_hierarchy)
 [![Code Climate](https://codeclimate.com/github/kolesnikovde/has_hierarchy/badges/gpa.svg)](https://codeclimate.com/github/kolesnikovde/has_hierarchy)
 [![Test Coverage](https://codeclimate.com/github/kolesnikovde/has_hierarchy/badges/coverage.svg)](https://codeclimate.com/github/kolesnikovde/has_hierarchy)
 
 # has_hierarchy
 
-Provides sortable tree behavior to active_record models.
+Provides tree behavior to active_record models.
 
 ## Installation
 
@@ -19,16 +19,21 @@ And then execute:
 
 ## Usage
 
+Example tree:
 ```sh
-$ rails g migration CreateItems \
+$ rails g model Item \
     name:string \
-    parent:belongs_to \
+    path:string \
+    depth:integer \
     position:integer \
-    node_path:string
+    parent:belongs_to \
+    children_count:integer
 ```
 ```ruby
 class Item < ActiveRecord::Base
-  has_hierarchy
+  has_hierarchy path_part: :name,
+                counter_cache: :children_count,
+                dependent: :destroy
 end
 
 foo = Item.create!(name: 'foo')
@@ -36,33 +41,76 @@ bar = Item.create!(name: 'bar')
 qux = bar.children.create!(name: 'qux')
 baz = bar.children.create!(name: 'baz')
 quux = qux.children.create!(name: 'quux')
+```
 
-Item.tree # => {
-          #   foo => {},
-          #   bar => {
-          #     qux => {
-          #       quux => {}
-          #     },
-          #     baz => {}
-          #   }
-          # }
+Options:
+```
+scope          - optional, proc, symbol or an array of symbols.
+order          - optional, column name or boolean, default :position.
+path_cache     - optional, column name or boolean, default :path.
+path_part      - optional, column name, default :id.
+path_separator - optional, string, default '/'.
+depth_cache    - optional, column name or boolean, default :depth.
+counter_cache  - optional, :counter_cache option for parent association.
+dependent      - optional, :dependent option for children association.
+```
 
-foo.move_after(quux)
+Operations on the tree:
+```ruby
+Item.roots
+# => [ foo, bar ]
+
+Item.ordered.tree
+# => {
+#   foo => {},
+#   bar => {
+#     qux => {
+#       quux => {}
+#     },
+#     baz => {}
+#   }
+# }
+
+Item.find_by_node_path('bar/qux/quux')
+# => quux
+```
 
-Item.tree # => {
-          #   bar => {
-          #     qux => {
-          #       quux => {},
-          #       foo => {}
-          #     },
-          #     baz => {}
-          #   }
-          # }
+Operations on nodes:
+```ruby
+bar.children         # => [ qux, baz ]
+qux.parent           # => bar
+foo.siblings         # => [ bar ]
+bar.parent_of?(quux) # => false
+qux.child_of?(bar)   # => true
+bar.sibling_of?(foo) # => true
+bar.root?            # => true
+qux.leaf?            # => false
+```
 
+Path cache is required for following methods:
+```ruby
+bar.root_of?(quux)      # => true
+bar.ancestor_of?(quux)  # => true
+qux.descendant_of?(bar) # => true
+quux.root               # => bar
+quux.ancestors          # => [ qux, bar ]
+bar.descendants         # => [ qux, quux, baz ]
 ```
 
-See [has_children](https://github.com/kolesnikovde/has_children) and
-[has_order](https://github.com/kolesnikovde/has_order) for details.
+Ordering (see [has_order](https://github.com/kolesnikovde/has_order)):
+```ruby
+foo.move_after(quux)
+Item.ordered.tree
+# => {
+#   bar => {
+#     qux => {
+#       quux => {},
+#       foo => {}
+#     },
+#     baz => {}
+#   }
+# }
+```
 
 ## License
 

data/has_hierarchy.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
 
   spec.authors       = ['Kolesnikov Danil']
   spec.email         = ['kolesnikovde@gmail.com']
-  spec.description   = 'Provides sortable tree behavior to active_record models.'
-  spec.summary       = 'Provides sortable tree behavior to active_record models.'
+  spec.description   = 'Provides tree behavior to active_record models.'
+  spec.summary       = 'Provides tree behavior to active_record models.'
   spec.homepage      = 'https://github.com/kolesnikovde/has_hierarchy'
   spec.license       = 'MIT'
 
@@ -27,5 +27,4 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'activerecord',  '~> 4'
   spec.add_runtime_dependency 'activesupport', '~> 4'
   spec.add_runtime_dependency 'has_order',     '~> 0.1'
-  spec.add_runtime_dependency 'has_children',  '~> 0.2.1'
 end

data/lib/has_hierarchy/depth_cache.rb

@@ -0,0 +1,25 @@
+module HasHierarchy
+  module DepthCache
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :cache_depth
+
+      cattr_accessor :depth_column do
+        column = has_hierarchy_options[:depth_cache]
+        column = :depth if column == true
+        column
+      end
+    end
+
+    protected
+
+    def depth
+      self[depth_column] || 0
+    end
+
+    def cache_depth
+      self[depth_column] = root? ? 0 : (parent.depth + 1)
+    end
+  end
+end

data/lib/has_hierarchy/order.rb

@@ -0,0 +1,38 @@
+require 'has_order'
+
+module HasHierarchy
+  module Order
+    extend ActiveSupport::Concern
+
+    included do
+      options = has_hierarchy_options
+
+      has_order scope: Array(options[:scope]).concat([ :parent_id ]),
+                position_column: options[:order]
+
+      include HasOrderOverrides
+    end
+
+    module HasOrderOverrides
+      def move_before(node)
+        self.parent_id = node.parent_id
+        @prevent_default_position = true
+        super
+        @prevent_default_position = false
+      end
+
+      def move_after(node)
+        self.parent_id = node.parent_id
+        @prevent_default_position = true
+        super
+        @prevent_default_position = false
+      end
+
+      protected
+
+      def set_default_position?
+        super or (parent_id_changed? and not @prevent_default_position)
+      end
+    end
+  end
+end

data/lib/has_hierarchy/path.rb

@@ -0,0 +1,120 @@
+module HasHierarchy
+  module Path
+    extend ActiveSupport::Concern
+
+    included do
+      before_create :populate_path
+      before_update :rebuild_subtree, if: :need_to_rebuild_subtree?
+
+      cattr_accessor :path_column do
+        column = has_hierarchy_options[:path_cache]
+        column = :path if column.nil? or column == true
+        column
+      end
+
+      cattr_accessor :path_separator do
+        has_hierarchy_options[:path_separator] || '/'
+      end
+
+      cattr_accessor :path_part_column do
+        has_hierarchy_options[:path_part] || :id
+      end
+    end
+
+    module ClassMethods
+      def find_by_path(path)
+        sep = path_separator
+        parts = path.split(sep)
+        part = parts.pop
+        path = parts.length > 0 ? parts.join(sep) + sep : ''
+
+        where(path_part_column => part, path_column => path).first
+      end
+    end
+
+    def root
+      self.class.find_by(path_part_column => path_parts.first)
+    end
+
+    def root_of?(node)
+      node.path_parts.first == path_part if path_part.present?
+    end
+
+    def ancestors
+      tree_scope.where(ancestors_conditions)
+    end
+
+    def ancestor_of?(node)
+      node.path_parts.include?(path_part)
+    end
+
+    def descendants
+      tree_scope.where(descendants_conditions)
+    end
+
+    def descendant_of?(node)
+      path_parts.include?(node.path_part)
+    end
+
+    def subtree
+      tree_scope.where(subtree_conditions)
+    end
+
+    def depth
+      path_parts.size
+    end
+
+    def path
+      self[path_column]
+    end
+
+    def path=(path)
+      self[path_column] = path
+    end
+
+    protected
+
+    def path_part
+      self[path_part_column].to_s
+    end
+
+    def path_parts
+      path.split(path_separator)
+    end
+
+    def path_for_children
+      [ path, path_part, path_separator ].join
+    end
+
+    def populate_path
+      self.path = root? ? '' : parent.path_for_children
+    end
+
+    def ancestors_conditions
+      { path_part_column => path_parts }
+    end
+
+    def descendants_conditions
+      arel_path = self.class.arel_table[path_column]
+      arel_path.matches("#{path_for_children}%")
+    end
+
+    def subtree_conditions
+      arel_path_part = self.class.arel_table[path_part_column]
+      arel_path_part.eq(path_part).or(descendants_conditions)
+    end
+
+    def rebuild_subtree
+      populate_path
+
+      children.each do |child|
+        child.rebuild_subtree
+        child.save!
+      end
+    end
+
+    def need_to_rebuild_subtree?
+      parent_id_changed? or changed_attributes.include?(path_part_column)
+    end
+  end
+end

data/lib/has_hierarchy/version.rb

@@ -1,3 +1,3 @@
 module HasHierarchy
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/lib/has_hierarchy.rb

@@ -1,42 +1,110 @@
 require 'active_record'
-require 'has_order'
-require 'has_children'
 require 'has_hierarchy/version'
+require 'has_hierarchy/order'
+require 'has_hierarchy/path'
+require 'has_hierarchy/depth_cache'
 
 module HasHierarchy
-  def has_hierarchy options = {}
-    has_order options.merge(scope: :parent_id)
-    has_children options
-
-    after_save :reset_parent_acceptance
+  def has_hierarchy(options = {})
+    cattr_accessor(:has_hierarchy_options) { options }
 
+    extend ClassMethods
     include InstanceMethods
+
+    include Order      unless options[:order] == false
+    include Path       unless options[:path_cache] == false
+    include DepthCache if options[:depth_cache]
+
+    belongs_to :parent, class_name: self.name,
+                        inverse_of: :children,
+                        counter_cache: options[:counter_cache]
+
+    has_many :children, class_name: self.name,
+                        foreign_key: :parent_id,
+                        inverse_of: :parent,
+                        dependent: options[:dependent]
+
+    define_tree_scope(options[:scope])
   end
 
-  module InstanceMethods
-    def move_before node
-      accept_parent(node)
-      super
+  module ClassMethods
+    def roots
+      where(parent_id: nil)
     end
 
-    def move_after node
-      accept_parent(node)
-      super
+    def tree
+      nodes = all
+      index = {}
+      arranged = {}
+
+      nodes.each do |node|
+        struct = node.root? ? arranged : (index[node.parent_id] ||= {})
+        struct[node] = (index[node.id] ||= {})
+      end
+
+      arranged
     end
 
     protected
 
-    def accept_parent node
-      self.parent_id = node.parent_id
-      @parent_accepted = true
+    def define_tree_scope(tree_scope)
+      scope :tree_scope, case tree_scope
+      when Proc
+        tree_scope
+      when nil
+        ->(model) { where(nil) }
+      else
+        ->(model) { where(Hash[Array(tree_scope).map{ |s| [ s, model[s] ] }]) }
+      end
+    end
+  end
+
+  module InstanceMethods
+    def leaf?
+      if counter_cache = has_hierarchy_options[:counter_cache]
+        self[counter_cache] == 0
+      else
+        children.empty?
+      end
+    end
+
+    def root?
+      parent_id.nil?
     end
 
-    def reset_parent_acceptance
-      @parent_accepted = false
+    def parent_of?(node)
+      node.parent_id == id
     end
 
-    def set_default_position?
-      super or parent_id_changed? and not @parent_accepted
+    def child_of?(node)
+      node.id == parent_id
+    end
+
+    def sibling_of?(node)
+      parent_id == node.parent_id and id != node.id
+    end
+
+    def siblings
+      tree_scope.where(siblings_conditions)
+    end
+
+    def move_children_to_parent
+      children.each do |c|
+        c.parent = self.parent
+        c.save
+      end
+    end
+
+    protected
+
+    def tree_scope
+      self.class.tree_scope(self)
+    end
+
+    def siblings_conditions
+      t = self.class.arel_table
+
+      t[:parent_id].eq(parent_id).and(t[:id].not_eq(id))
     end
   end
 end

data/spec/db/schema.rb

@@ -1,7 +1,10 @@
 ActiveRecord::Schema.define(version: 0) do
   create_table :items, force: true do |t|
     t.string :name
-    t.string :node_path
+    t.string :category
+    t.string :path
+    t.integer :children_count, default: 0
+    t.integer :depth
     t.integer :position
 
     t.belongs_to :parent

data/spec/has_hierarchy_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-shared_examples 'ordered tree' do
+shared_context 'example tree' do
   let!(:foo) { described_class.create!(name: 'foo') }
   let!(:bar) { described_class.create!(name: 'bar') }
   let!(:qux) { bar.children.create!(name: 'qux') }
@@ -11,18 +11,256 @@ shared_examples 'ordered tree' do
     [ foo, bar, baz, qux, quux ].each(&:reload)
   end
 
-  it do
-    expect(described_class.tree).to be_arranged_like({
-      foo => {},
-      bar => {
+  before do
+    reload_items
+  end
+end
+
+shared_examples 'adjacency list' do
+  include_context 'example tree'
+
+  describe '.tree' do
+    it 'arranges tree' do
+      expect(described_class.tree).to be_arranged_like({
+        foo => {},
+        bar => {
+          qux => {
+            quux => {}
+          },
+          baz => {}
+        }
+      })
+    end
+
+    it 'allows custom order' do
+      expect(described_class.alphabetic.tree).to be_arranged_like({
+        bar => {
+          baz => {},
+          qux => {
+            quux => {}
+          }
+        },
+        foo => {}
+      })
+    end
+  end
+
+  describe '.roots' do
+    it 'returns roots' do
+      expect(described_class.roots).to match_array([ foo, bar ])
+    end
+  end
+
+  describe '#move_children_to_parent' do
+    it 'changes children parent' do
+      bar.move_children_to_parent
+
+      expect(described_class.tree).to be_arranged_like({
+        foo => {},
+        bar => {},
         qux => {
-          quux => {},
+          quux => {}
         },
         baz => {}
-      }
-    })
+      })
+    end
+  end
+
+  describe '#root?' do
+    it 'returns true if node has parent' do
+      expect(bar).to be_root
+      expect(baz).not_to be_root
+    end
+  end
+
+  describe '#leaf?' do
+    it 'returns true if node does not have children' do
+      expect(quux).to be_leaf
+      expect(qux).not_to be_leaf
+    end
+  end
+
+  describe '#parent_of?' do
+    it 'returns true if node is a parent of given node' do
+      expect(bar).to be_parent_of(qux)
+      expect(bar).not_to be_parent_of(quux)
+    end
+  end
+
+  describe '#child_of?' do
+    it 'returns true if node is a child of given node' do
+      expect(qux).to be_child_of(bar)
+      expect(qux).not_to be_child_of(quux)
+    end
+  end
+
+  describe '#sibling_of?' do
+    it 'returns true if both nodes have same parent' do
+      expect(foo).to be_sibling_of(bar)
+      expect(baz).to be_sibling_of(qux)
+      expect(foo).not_to be_sibling_of(qux)
+    end
+  end
+end
+
+shared_examples 'materialized path' do
+  include_context 'example tree'
+  it_behaves_like 'adjacency list'
+
+  describe '.find_by_path' do
+    it 'returns node' do
+      expect(described_class.find_by_path('bar')).to eq(bar)
+      expect(described_class.find_by_path('bar/qux')).to eq(qux)
+      expect(described_class.find_by_path('bar/qux/quux')).to eq(quux)
+    end
+  end
+
+  describe '#root' do
+    it 'returns first node ancestor' do
+      expect(baz.root).to eq(bar)
+    end
+
+    it 'returns nil if node is a root' do
+      expect(bar.root).to be nil
+    end
+  end
+
+  describe '#ancestors' do
+    it 'returns node ancestors' do
+      expect(quux.ancestors).to match_array([ qux, bar ])
+      expect(qux.ancestors).to match_array([ bar ])
+      expect(bar.ancestors).to be_empty
+    end
+  end
+
+  describe '#descendants' do
+    it 'returns node descendants' do
+      expect(bar.descendants).to match_array([ qux, quux, baz ])
+      expect(qux.descendants).to match_array([ quux ])
+      expect(quux.descendants).to be_empty
+    end
   end
 
+  describe '#subtree' do
+    it 'returns node with descendants' do
+      expect(bar.subtree.tree).to be_arranged_like({
+        bar => {
+          qux => {
+            quux => {}
+          },
+          baz => {}
+        }
+      })
+    end
+
+    it 'returns node if node is a leaf' do
+      expect(baz.subtree).to eq([ baz ])
+    end
+  end
+
+  describe '#root_of?' do
+    it 'returns true of node is a root of given node' do
+      expect(bar).to be_root_of(qux)
+      expect(bar).to be_root_of(quux)
+      expect(bar).not_to be_root_of(bar)
+      expect(bar).not_to be_root_of(foo)
+    end
+  end
+
+  describe '#ancestor_of?' do
+    it 'returns true if node is an ancestors of given node' do
+      expect(bar).to be_ancestor_of(qux)
+      expect(bar).to be_ancestor_of(quux)
+      expect(bar).not_to be_ancestor_of(bar)
+      expect(bar).not_to be_ancestor_of(foo)
+    end
+  end
+
+  describe '#descendant_of?' do
+    it 'returns true if node is a descendant of given node' do
+      expect(quux).to be_descendant_of(qux)
+      expect(quux).to be_descendant_of(bar)
+      expect(quux).not_to be_descendant_of(quux)
+      expect(quux).not_to be_descendant_of(foo)
+    end
+  end
+
+  describe '#depth' do
+    it 'returns ancestors count' do
+      expect(bar.depth).to eq(0)
+      expect(qux.depth).to eq(1)
+      expect(quux.depth).to eq(2)
+    end
+  end
+
+  describe 'node id column change' do
+    before do
+      bar.name = 'bor'
+      bar.save!
+    end
+
+    it 'updates children pathes' do
+      expect(described_class.find_by_path('bor')).to eq(bar)
+      expect(described_class.find_by_path('bor/qux')).to eq(qux)
+      expect(described_class.find_by_path('bor/qux/quux')).to eq(quux)
+    end
+  end
+
+  describe 'parent change' do
+    let(:prev_parent) { baz.parent }
+    let(:new_parent) { foo }
+    let(:new_ancestors) { [ foo ] }
+
+    before do
+      baz.parent = new_parent
+      baz.save!
+      reload_items
+    end
+
+    it 'updates counter_cache' do
+      expect(prev_parent.children_count).to eq(prev_parent.children.count)
+      expect(new_parent.children_count).to eq(new_parent.children.count)
+    end
+
+    it 'changes ancestors' do
+      expect(baz.ancestors).to eq(new_ancestors)
+    end
+
+    it 'applies to all descendants' do
+      baz.children.each do |child|
+        expect(child).to be_descendant_of(new_parent)
+
+        child.children.each do |subchild|
+          expect(subchild).to be_descendant_of(new_parent)
+        end
+      end
+    end
+  end
+end
+
+shared_examples 'tree with cached depth' do
+  include_context 'example tree'
+  it_behaves_like 'adjacency list'
+
+  it 'stores node level' do
+    expect(described_class.where(depth: 0)).to match_array([ foo, bar ])
+    expect(described_class.where(depth: 1)).to match_array([ qux, baz ])
+    expect(described_class.where(depth: 2)).to match_array([ quux ])
+  end
+end
+
+shared_examples 'scoped tree' do
+  let!(:foo) { described_class.create!(name: 'foo', category: 'foo') }
+  let!(:bar) { described_class.create!(name: 'bar', category: 'bar') }
+
+  it 'restricts scope' do
+    expect(bar.siblings).to be_empty
+  end
+end
+
+shared_examples 'ordered tree' do
+  include_context 'example tree'
+
   it '#move_after' do
     quux.move_after(foo)
     reload_items
@@ -53,6 +291,23 @@ shared_examples 'ordered tree' do
   end
 end
 
-describe Item do
+describe AdjacencyListTreeItem do
+  it_behaves_like 'adjacency list'
   it_behaves_like 'ordered tree'
 end
+
+describe MaterializedPathTreeItem do
+  it_behaves_like 'materialized path'
+end
+
+describe CachedDepthTreeItem do
+  it_behaves_like 'tree with cached depth'
+end
+
+describe ScopedWithColumnTreeItem do
+  it_behaves_like 'scoped tree'
+end
+
+describe ScopedWithLambdaTreeItem do
+  it_behaves_like 'scoped tree'
+end

data/spec/support/models.rb

@@ -1,5 +1,29 @@
 require 'has_hierarchy'
 
 class Item < ActiveRecord::Base
-  has_hierarchy
+  scope :alphabetic, ->{ order('name asc') }
+end
+
+class AdjacencyListTreeItem < Item
+  has_hierarchy counter_cache: :children_count,
+                path_cache: false
+end
+
+class MaterializedPathTreeItem < Item
+  has_hierarchy counter_cache: :children_count,
+                path_part: :name
+end
+
+class CachedDepthTreeItem < Item
+  has_hierarchy depth_cache: true
+end
+
+class ScopedWithColumnTreeItem < Item
+  has_hierarchy scope: :category
+end
+
+class ScopedWithLambdaTreeItem < Item
+  has_hierarchy scope: ->(item){ where(category: item.category) },
+                # Ordering scope (parent_id) cannot be combined with lambda.
+                order: false
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_hierarchy
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Kolesnikov Danil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,21 +122,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: has_children
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.1
-description: Provides sortable tree behavior to active_record models.
+description: Provides tree behavior to active_record models.
 email:
 - kolesnikovde@gmail.com
 executables: []
@@ -153,6 +139,9 @@ files:
 - Rakefile
 - has_hierarchy.gemspec
 - lib/has_hierarchy.rb
+- lib/has_hierarchy/depth_cache.rb
+- lib/has_hierarchy/order.rb
+- lib/has_hierarchy/path.rb
 - lib/has_hierarchy/version.rb
 - spec/db/schema.rb
 - spec/has_hierarchy_spec.rb
@@ -182,7 +171,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Provides sortable tree behavior to active_record models.
+summary: Provides tree behavior to active_record models.
 test_files:
 - spec/db/schema.rb
 - spec/has_hierarchy_spec.rb