has_hierarchy 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ff1f9affc659f62ba4a9b6eb0f25309b980939f
-  data.tar.gz: 4de2b383019e35c329b4bb11a3e7c39f1a5b2207
+  metadata.gz: 296f6af57a4b4997d4f63b1ad555c9723da8701b
+  data.tar.gz: 83c399372635843bbeac74f6aa632d2eaeea0b05
 SHA512:
-  metadata.gz: 8748539cfaf294108ff6d4e3bbf443dd42320171f5e89a0982b00b4aa32f4e6f255b6f3fa0a3726b970b5e7cf6b1b02a48e8bd0e203d892127547afb82c99567
-  data.tar.gz: edc08f4f3e803bf13f4d9b8dfd84cd4b690489ddab3daf3f3a39aea833fe44d93a506b50d0319a970f9dacc91b45722b3768b321023ba7ab7dda4246dc169a87
+  metadata.gz: 14a6ad138900fa59c5e174e26497ede7184c8e33137f8fc724045b1fb4d2c4befc89f82ed1071f82b5507bac917f517994e592f5cefd83928579d5f6a47e4549
+  data.tar.gz: 3df4da8267691965a285f537ab10e994596de77e3fda143223a9f00f6bb180eba0fc73368a8ef1dcac56d45092b464892dea7b5997daedcf575a8c1aff1d30f4

data/.travis.yml

@@ -5,6 +5,16 @@ rvm:
   - 2.0.0
   - 2.1.0
 
+env:
+  - HAS_HIERARCHY_ORM=mongoid
+  - HAS_HIERARCHY_ORM=active_record
+
+matrix:
+  fast_finish: true
+
+services:
+  - mongodb
+
 addons:
   code_climate:
     repo_token: cf2619e78bacdbeab2c8c1e2e1f37ff6c47b06374ee717f38cbbcdafaceeeb59

data/README.md

@@ -5,7 +5,7 @@
 
 # has_hierarchy
 
-Provides tree behavior to active_record models.
+Tree behavior for ActiveRecord models and Mongoid documents.
 
 ## Installation
 
@@ -19,15 +19,15 @@ And then execute:
 
 ## Usage
 
-Example tree:
+Example model:
 ```sh
 $ rails g model Item \
-    name:string \
-    path:string \
-    depth:integer \
-    position:integer \
-    parent:belongs_to \
-    children_count:integer
+  name:string \
+  path:string \
+  depth:integer \
+  position:integer \
+  parent:belongs_to \
+  children_count:integer
 ```
 ```ruby
 class Item < ActiveRecord::Base
@@ -36,12 +36,24 @@ class Item < ActiveRecord::Base
                 counter_cache: true,
                 dependent: :destroy
 end
+```
 
-foo = Item.create!(name: 'foo')
-bar = Item.create!(name: 'bar')
-qux = bar.children.create!(name: 'qux')
-baz = bar.children.create!(name: 'baz')
-quux = qux.children.create!(name: 'quux')
+or Mongoid document:
+```ruby
+class Item
+  include Mongoid::Document
+  include Mongoid::HasHierarchy
+
+  has_hierarchy path_part: :name,
+                depth_cache: true,
+                counter_cache: true,
+                dependent: :destroy
+
+  field :name,  type: String
+  field :path,  type: String
+  field :depth, type: Fixnum, default: 0
+  field :children_count, type: Fixnum, default: 0
+end
 ```
 
 Options:
@@ -58,6 +70,12 @@ dependent      - optional, :dependent option for children association.
 
 Operations on the tree:
 ```ruby
+foo = Item.create!(name: 'foo')
+bar = Item.create!(name: 'bar')
+qux = bar.children.create!(name: 'qux')
+baz = bar.children.create!(name: 'baz')
+quux = qux.children.create!(name: 'quux')
+
 Item.roots
 # => [ foo, bar ]
 
@@ -88,7 +106,7 @@ bar.root?            # => true
 qux.leaf?            # => false
 ```
 
-Path cache is required for following methods:
+Ancestors/descendants (requires path_cache):
 ```ruby
 bar.root_of?(quux)      # => true
 bar.ancestor_of?(quux)  # => true
@@ -100,6 +118,9 @@ bar.descendants         # => [ qux, quux, baz ]
 
 Ordering (see [has_order](https://github.com/kolesnikovde/has_order)):
 ```ruby
+bar.previous_siblings  # => [ foo, quux ]
+foo.next_siblings      # => [ quux, bar ]
+
 foo.move_after(quux)
 Item.ordered.tree
 # => {

data/has_hierarchy.gemspec

@@ -21,10 +21,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1'
   spec.add_development_dependency 'rake',    '~> 10'
   spec.add_development_dependency 'rspec',   '~> 3'
-  spec.add_development_dependency 'sqlite3', '~> 1'
+
+  spec.add_development_dependency 'sqlite3',      '~> 1'
+  spec.add_development_dependency 'activerecord', '~> 4'
+  spec.add_development_dependency 'mongoid',      '~> 4'
+
   spec.add_development_dependency 'codeclimate-test-reporter'
 
-  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_order',     '~> 0.2'
 end

data/lib/has_hierarchy/counter_cache.rb

@@ -0,0 +1,26 @@
+module HasHierarchy
+  module CounterCache
+    extend ActiveSupport::Concern
+
+    included do
+      after_save :update_children_counter,       if: :parent_id_changed?
+      after_destroy :decrement_children_counter, if: :parent_id?
+    end
+
+    protected
+
+    def update_children_counter
+      if parent_id
+        self.class.increment_counter(children_count_column, parent_id)
+      end
+
+      if parent_id_was
+        self.class.decrement_counter(children_count_column, parent_id_was)
+      end
+    end
+
+    def decrement_children_counter
+      self.class.decrement_counter(children_count_column, parent_id)
+    end
+  end
+end

data/lib/has_hierarchy/order.rb

@@ -5,11 +5,16 @@ module HasHierarchy
     extend ActiveSupport::Concern
 
     included do
+      include Mongoid::HasOrder if defined?(Mongoid)
+
       options = has_hierarchy_options
 
       has_order scope: Array(options[:scope]).concat([ :parent_id ]),
                 position_column: options[:order]
 
+      alias_method :previous_siblings, :lower
+      alias_method :next_siblings, :higher
+
       include HasOrderOverrides
     end
 

data/lib/has_hierarchy/orm_adapter/active_record.rb

@@ -0,0 +1,34 @@
+module HasHierarchy
+  module OrmAdapter
+    module ActiveRecord
+      def ancestors
+        tree_scope.where(path_part_column => path_parts)
+      end
+
+      def siblings
+        t = self.class.arel_table
+
+        tree_scope.where(t[:parent_id].eq(parent_id).and(t[:id].not_eq(id)))
+      end
+
+      def subtree
+        t = self.class.arel_table
+
+        tree_scope.where(t[:id].eq(id).or(descendants_conditions))
+      end
+
+      def descendants
+        tree_scope.where(descendants_conditions)
+      end
+
+      protected
+
+      def descendants_conditions
+        t = self.class.arel_table
+
+        t[path_column].matches("#{path_for_children}%")
+      end
+    end
+  end
+end
+

data/lib/has_hierarchy/orm_adapter/mongoid.rb

@@ -0,0 +1,27 @@
+module HasHierarchy
+  module OrmAdapter
+    module Mongoid
+      def ancestors
+        tree_scope.where(path_part_column.in => path_parts)
+      end
+
+      def siblings
+        tree_scope.where(:parent_id => parent_id, :id.ne => id)
+      end
+
+      def subtree
+        tree_scope.or({ id: id }, descendants_conditions)
+      end
+
+      def descendants
+        tree_scope.where(descendants_conditions)
+      end
+
+      protected
+
+      def descendants_conditions
+        { path_column => /^#{path_for_children}/ }
+      end
+    end
+  end
+end

data/lib/has_hierarchy/orm_adapter.rb

@@ -0,0 +1,29 @@
+module HasHierarchy
+  # :nocov:
+  module OrmAdapter
+    if defined?(::ActiveRecord)
+      ::ActiveRecord::Base.extend(HasHierarchy)
+    end
+
+    if defined?(::Mongoid)
+      module ::Mongoid::HasHierarchy
+        def self.included(base)
+          base.extend(::HasHierarchy)
+        end
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        if defined?(::ActiveRecord) and self < ::ActiveRecord::Base
+          require 'has_hierarchy/orm_adapter/active_record'
+          include ActiveRecord
+        elsif defined?(::Mongoid) and self < ::Mongoid::Document
+          require 'has_hierarchy/orm_adapter/mongoid'
+          include Mongoid
+        end
+      end
+    end
+  end
+  # :nocov:
+end

data/lib/has_hierarchy/path.rb

@@ -23,33 +23,23 @@ module HasHierarchy
     end
 
     def root
-      self.class.find_by(path_part_column => path_parts.first)
+      if root_part = path_parts.first
+        self.class.find_by(path_part_column => root_part)
+      end
     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
@@ -80,35 +70,21 @@ module HasHierarchy
       [ 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)
+    def populate_path(path = nil)
+      self.path = root? ? '' : (path || parent.path_for_children)
     end
 
-    def rebuild_subtree
-      populate_path
+    def rebuild_subtree(path = nil)
+      populate_path(path)
 
       children.each do |child|
-        child.rebuild_subtree
+        child.rebuild_subtree(path_for_children)
         child.save!
       end
     end
 
     def need_to_rebuild_subtree?
-      parent_id_changed? or changed_attributes.include?(path_part_column)
+      parent_id_changed? or changed_attributes.include?(path_part_column.to_s)
     end
   end
 end

data/lib/has_hierarchy/version.rb

@@ -1,3 +1,3 @@
 module HasHierarchy
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/lib/has_hierarchy.rb

@@ -3,6 +3,8 @@ require 'has_hierarchy/version'
 require 'has_hierarchy/order'
 require 'has_hierarchy/path'
 require 'has_hierarchy/depth_cache'
+require 'has_hierarchy/counter_cache'
+require 'has_hierarchy/orm_adapter'
 
 module HasHierarchy
   DEFAULT_OPTIONS = {
@@ -22,13 +24,13 @@ module HasHierarchy
 
     setup_has_hierarchy_options(options)
 
-    include Order      if options[:order]
-    include Path       if options[:path_cache]
-    include DepthCache if options[:depth_cache]
+    include Order        if options[:order]
+    include Path         if options[:path_cache]
+    include DepthCache   if options[:depth_cache]
+    include CounterCache if options[:counter_cache]
 
     belongs_to :parent, class_name: self.name,
-                        inverse_of: :children,
-                        counter_cache: options[:counter_cache]
+                        inverse_of: :children
 
     has_many :children, class_name: self.name,
                         foreign_key: :parent_id,
@@ -36,6 +38,8 @@ module HasHierarchy
                         dependent: options[:dependent]
 
     define_tree_scope(options[:scope])
+
+    include HasHierarchy::OrmAdapter
   end
 
   module ClassMethods
@@ -72,6 +76,7 @@ module HasHierarchy
       cattr_accessor(:path_part_column) { options[:path_part] }
       cattr_accessor(:path_separator) { options[:path_separator] }
       cattr_accessor(:depth_column) { options[:depth_cache] }
+      cattr_accessor(:children_count_column) { options[:counter_cache] }
       cattr_accessor(:has_hierarchy_options) { options }
     end
 
@@ -112,10 +117,6 @@ module HasHierarchy
       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
@@ -128,13 +129,5 @@ module HasHierarchy
     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
-
-ActiveRecord::Base.extend(HasHierarchy)

data/spec/has_hierarchy_spec.rb

@@ -1,310 +1,5 @@
 require 'spec_helper'
-
-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') }
-  let!(:baz) { bar.children.create!(name: 'baz') }
-  let!(:quux) { qux.children.create!(name: 'quux') }
-
-  def reload_items
-    [ foo, bar, baz, qux, quux ].each(&:reload)
-  end
-
-  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 => {}
-        },
-        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 '.find_by_path!' do
-    it 'returns node or raises RecordNotFound' do
-      expect(described_class.find_by_path!('bar/qux/')).to eq(qux)
-      expect{ described_class.find_by_path!('wrong') }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-  end
-
-  describe '#full_path' do
-    it 'returns full node path' do
-      expect(bar.full_path).to eq('bar')
-      expect(qux.full_path).to eq('bar/qux')
-      expect(quux.full_path).to eq('bar/qux/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
-
-    expect(described_class.ordered.tree).to be_arranged_like({
-      foo => {},
-      quux => {},
-      bar => {
-        qux => {},
-        baz => {}
-      }
-    })
-  end
-
-  it '#move_before' do
-    baz.move_before(quux)
-    reload_items
-
-    expect(described_class.ordered.tree).to be_arranged_like({
-      foo => {},
-      bar => {
-        qux => {
-          baz => {},
-          quux => {},
-        }
-      }
-    })
-  end
-end
+require 'tree'
 
 describe AdjacencyListTreeItem do
   it_behaves_like 'adjacency list'

data/spec/spec_helper.rb

@@ -1,22 +1,12 @@
 require 'codeclimate-test-reporter'
 CodeClimate::TestReporter.start
 
-require 'sqlite3'
-require 'active_record'
+orm_adapter = ENV['HAS_HIERARCHY_ORM']
 
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-ActiveRecord::Schema.verbose = false
-
-require File.expand_path('../db/schema.rb', __FILE__)
-require File.expand_path('../support/models.rb', __FILE__)
-require File.expand_path('../support/matchers.rb', __FILE__)
-
-RSpec.configure do |config|
-  config.around :each do |example|
-    ActiveRecord::Base.transaction do
-      example.run
-
-      raise ActiveRecord::Rollback
-    end
-  end
+unless %w[active_record mongoid].include?(orm_adapter)
+  raise 'Unknown ORM.'
 end
+
+require "support/orm/#{orm_adapter}/setup"
+require 'support/models'
+require 'support/matchers'

data/spec/support/models.rb

@@ -1,17 +1,11 @@
-require 'has_hierarchy'
-
-class Item < ActiveRecord::Base
-  scope :alphabetic, ->{ order('name asc') }
-end
-
 class AdjacencyListTreeItem < Item
-  has_hierarchy counter_cache: :children_count,
+  has_hierarchy counter_cache: true,
                 path_cache: false,
                 order: true
 end
 
 class MaterializedPathTreeItem < Item
-  has_hierarchy counter_cache: :children_count,
+  has_hierarchy counter_cache: true,
                 path_part: :name
 end
 

data/spec/{db/schema.rb → support/orm/active_record/item_model.rb}

@@ -10,3 +10,7 @@ ActiveRecord::Schema.define(version: 0) do
     t.belongs_to :parent
   end
 end
+
+class Item < ActiveRecord::Base
+  scope :alphabetic, ->{ order('name asc') }
+end

data/spec/support/orm/active_record/setup.rb

@@ -0,0 +1,18 @@
+require 'active_record'
+require 'sqlite3'
+require 'has_hierarchy'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Schema.verbose = false
+
+require_relative 'item_model'
+
+RSpec.configure do |config|
+  config.around :each do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+
+      raise ActiveRecord::Rollback
+    end
+  end
+end

data/spec/support/orm/mongoid/item_model.rb

@@ -0,0 +1,12 @@
+class Item
+  include Mongoid::Document
+  include Mongoid::HasHierarchy
+
+  field :name,     type: String
+  field :path,     type: String
+  field :depth,    type: Fixnum, default: 0
+  field :category, type: String
+  field :children_count, type: Fixnum, default: 0
+
+  scope :alphabetic, ->{ asc(:name) }
+end

data/spec/support/orm/mongoid/setup.rb

@@ -0,0 +1,12 @@
+require 'mongoid'
+require 'has_hierarchy'
+
+Mongoid.configure do |config|
+  config.connect_to('mongoid_has_hierarchy_test')
+end
+
+require_relative 'item_model'
+
+RSpec.configure do |config|
+  config.after(:each) { Mongoid.purge! }
+end

data/spec/tree.rb

@@ -0,0 +1,323 @@
+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') }
+  let!(:baz) { bar.children.create!(name: 'baz') }
+  let!(:quux) { qux.children.create!(name: 'quux') }
+
+  def reload_items
+    [ foo, bar, baz, qux, quux ].each(&:reload)
+  end
+
+  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 => {}
+        },
+        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 '.find_by_path!' do
+    it 'returns node or raises RecordNotFound' do
+      expect(described_class.find_by_path!('bar/qux/')).to eq(qux)
+      expect{ described_class.find_by_path!('wrong') }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  describe '#full_path' do
+    it 'returns full node path' do
+      expect(bar.full_path).to eq('bar')
+      expect(qux.full_path).to eq('bar/qux')
+      expect(quux.full_path).to eq('bar/qux/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) { bar }
+    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)
+
+      new_parent.descendants.destroy_all
+      new_parent.reload
+
+      expect(new_parent.children_count).to eq(0)
+    end
+
+    it 'changes ancestors' do
+      expect(baz.ancestors).to match_array(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'
+
+  before(:each) do
+    quux.move_after(foo)
+    reload_items
+  end
+
+  describe '#previous_siblings' do
+    it 'returns siblings with smaller position' do
+      expect(bar.previous_siblings).to match_array([ foo, quux ])
+    end
+  end
+
+  describe '#next_siblings' do
+    it 'returns siblings with greater position' do
+      expect(foo.next_siblings).to match_array([ quux, bar ])
+    end
+  end
+
+  it '#move_after' do
+    expect(described_class.ordered.tree).to be_arranged_like({
+      foo => {},
+      quux => {},
+      bar => {
+        qux => {},
+        baz => {}
+      }
+    })
+  end
+
+  it '#move_before' do
+    baz.move_before(quux)
+    reload_items
+
+    expect(described_class.ordered.tree).to be_arranged_like({
+      foo => {},
+      baz => {},
+      quux => {},
+      bar => {
+        qux => {}
+      }
+    })
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_hierarchy
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Kolesnikov Danil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-22 00:00:00.000000000 Z
+date: 2014-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,33 +67,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: mongoid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -114,14 +128,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 description: Provides tree behavior to active_record models.
 email:
 - kolesnikovde@gmail.com
@@ -133,21 +147,28 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
-- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - has_hierarchy.gemspec
 - lib/has_hierarchy.rb
+- lib/has_hierarchy/counter_cache.rb
 - lib/has_hierarchy/depth_cache.rb
 - lib/has_hierarchy/order.rb
+- lib/has_hierarchy/orm_adapter.rb
+- lib/has_hierarchy/orm_adapter/active_record.rb
+- lib/has_hierarchy/orm_adapter/mongoid.rb
 - lib/has_hierarchy/path.rb
 - lib/has_hierarchy/version.rb
-- spec/db/schema.rb
 - spec/has_hierarchy_spec.rb
 - spec/spec_helper.rb
 - spec/support/matchers.rb
 - spec/support/models.rb
+- spec/support/orm/active_record/item_model.rb
+- spec/support/orm/active_record/setup.rb
+- spec/support/orm/mongoid/item_model.rb
+- spec/support/orm/mongoid/setup.rb
+- spec/tree.rb
 homepage: https://github.com/kolesnikovde/has_hierarchy
 licenses:
 - MIT
@@ -173,8 +194,12 @@ signing_key:
 specification_version: 4
 summary: Provides tree behavior to active_record models.
 test_files:
-- spec/db/schema.rb
 - spec/has_hierarchy_spec.rb
 - spec/spec_helper.rb
 - spec/support/matchers.rb
 - spec/support/models.rb
+- spec/support/orm/active_record/item_model.rb
+- spec/support/orm/active_record/setup.rb
+- spec/support/orm/mongoid/item_model.rb
+- spec/support/orm/mongoid/setup.rb
+- spec/tree.rb

data/CHANGELOG.md

@@ -1,59 +0,0 @@
-# Changelog
-
-## 0.3.1
-
-- Added path normalization to `.find_by_path`
-- Added `.find_by_path!`
-- Added `#full_path`
-- Fixed boolean options.
-- Added options validation.
-
-## 0.3.0
-
-- Added "path_separator" option.
-- Added ordering support.
-- Cleaned up options.
-- Renamed to has_hierarchy.
-
-## 0.2.1
-
-- Fixed `.find_by_node_path`.
-- Added tree rebuilding on node_id change.
-- Added depth caching.
-
-## 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 root association.
-- Added `#root_id`.
-- Added `#root_of?`.
-- Added `#parent_of?`.
-
-## 0.1.1
-
-- Fixed scopes (always using lambdas).
-
-## 0.1.0
-
-- Added `#move_children_to_parent`.
-- `#ancestor_tokens` renamed to `#ancestor_ids`.
-- Added lambda scopes support.