mongoid-ancestry-fixes 0.0.1

data/lib/mongoid-ancestry/instance_methods.rb

@@ -0,0 +1,248 @@
+module Mongoid
+  module Ancestry
+
+    # Validate that the ancestors don't include itself
+    def ancestry_exclude_self
+      if ancestor_ids.include? id
+        errors.add(:base, "#{self.class.name.humanize} cannot be a descendant of itself.")
+      end
+    end
+
+    # Update descendants with new ancestry
+    def update_descendants_with_new_ancestry
+      # Skip this if callbacks are disabled
+      unless ancestry_callbacks_disabled?
+        # If node is valid, not a new record and ancestry was updated ...
+        if changed.include?(self.base_class.ancestry_field.to_s) && !new_record? && valid?
+          # ... for each descendant ...
+          descendants.each do |descendant|
+            # ... replace old ancestry with new ancestry
+            descendant.without_ancestry_callbacks do
+              for_replace = \
+                if read_attribute(self.class.ancestry_field).blank?
+                  id.to_s
+                else
+                  "#{read_attribute self.class.ancestry_field}/#{id}"
+                end
+              new_ancestry = descendant.read_attribute(descendant.class.ancestry_field).gsub(/^#{self.child_ancestry}/, for_replace)
+              descendant.update_attribute(self.base_class.ancestry_field, new_ancestry)
+            end
+          end
+        end
+      end
+    end
+
+    # Apply orphan strategy
+    def apply_orphan_strategy
+      # Skip this if callbacks are disabled
+      unless ancestry_callbacks_disabled?
+        # If this isn't a new record ...
+        unless new_record?
+          # ... make al children root if orphan strategy is rootify
+          if self.base_class.orphan_strategy == :rootify
+            descendants.each do |descendant|
+              descendant.without_ancestry_callbacks do
+                val = \
+                  unless descendant.ancestry == child_ancestry
+                    descendant.read_attribute(descendant.class.ancestry_field).gsub(/^#{child_ancestry}\//, '')
+                  end
+                descendant.update_attribute descendant.class.ancestry_field, val
+              end
+            end
+            # ... destroy all descendants if orphan strategy is destroy
+          elsif self.base_class.orphan_strategy == :destroy
+            descendants.all.each do |descendant|
+              descendant.without_ancestry_callbacks { descendant.destroy }
+            end
+            # ... throw an exception if it has children and orphan strategy is restrict
+          elsif self.base_class.orphan_strategy == :restrict
+            raise Error.new('Cannot delete record because it has descendants.') unless is_childless?
+          end
+        end
+      end
+    end
+
+    # The ancestry value for this record's children
+    def child_ancestry
+      # New records cannot have children
+      raise Error.new('No child ancestry for new record. Save record before performing tree operations.') if new_record?
+
+      if self.send("#{self.base_class.ancestry_field}_was").blank?
+        id.to_s
+      else
+        "#{self.send "#{self.base_class.ancestry_field}_was"}/#{id}"
+      end
+    end
+
+    # Scope
+    def current_search_scope
+      self.embedded? ? self._parent.send(self.base_class.to_s.tableize) : self.base_class
+    end
+
+    # Ancestors
+    def ancestor_ids
+      read_attribute(self.base_class.ancestry_field).to_s.split('/').map { |id| cast_primary_key(id) }
+    end
+
+    def ancestor_conditions
+      { :_id.in => ancestor_ids }
+    end
+
+    def ancestors depth_options = {}
+      self.base_class.scope_depth(depth_options, depth).where(ancestor_conditions)
+    end
+
+    def path_ids
+      ancestor_ids + [id]
+    end
+
+    def path_conditions
+      { :_id.in => path_ids }
+    end
+
+    def path depth_options = {}
+      self.base_class.scope_depth(depth_options, depth).where(path_conditions)
+    end
+
+    def depth
+      ancestor_ids.size
+    end
+
+    def cache_depth
+      write_attribute self.base_class.depth_cache_field, depth
+    end
+
+    # Parent
+    def parent= parent
+      write_attribute(self.base_class.ancestry_field, parent.blank? ? nil : parent.child_ancestry)
+    end
+
+    def parent_id= parent_id
+      self.parent = parent_id.blank? ? nil : current_search_scope.find(parent_id)
+    end
+
+    def parent_id
+      ancestor_ids.empty? ? nil : ancestor_ids.last
+    end
+
+    def parent
+      parent_id.blank? ? nil : current_search_scope.find(parent_id)
+    end
+
+    # Root
+    def root_id
+      (root_id == id) ? self : current_search.find(root_id)
+    end
+
+    def root
+      (root_id == id) ? self : current_search_scope.find(root_id)
+    end
+
+    def is_root?
+      read_attribute(self.base_class.ancestry_field).blank?
+    end
+
+    # Children
+    def child_conditions
+      {self.base_class.ancestry_field => child_ancestry}
+    end
+
+    def children
+      current_search_scope.where(child_conditions)
+    end
+
+    def child_ids
+      children.only(:_id).map(&:id)
+    end
+
+    def has_children?
+      self.children.present?
+    end
+
+    def is_childless?
+      !has_children?
+    end
+
+    # Siblings
+    def sibling_conditions
+      {self.base_class.ancestry_field => read_attribute(self.base_class.ancestry_field)}
+    end
+
+    def siblings
+      self.base_class.where sibling_conditions
+    end
+
+    def sibling_ids
+      siblings.only(:_id).map(&:id)
+    end
+
+    def has_siblings?
+      self.siblings.count > 1
+    end
+
+    def is_only_child?
+      !has_siblings?
+    end
+
+    # Descendants
+    def descendant_conditions
+      [
+        { self.base_class.ancestry_field => /^#{child_ancestry}\// },
+        { self.base_class.ancestry_field => child_ancestry }
+      ]
+    end
+
+    def descendants depth_options = {}
+      self.base_class.scope_depth(depth_options, depth).any_of(descendant_conditions)
+    end
+
+    def descendant_ids depth_options = {}
+      descendants(depth_options).only(:_id).map(&:id)
+    end
+
+    # Subtree
+    def subtree_conditions
+      [
+        { :_id => id },
+        { self.base_class.ancestry_field => /^#{child_ancestry}\// },
+        { self.base_class.ancestry_field => child_ancestry }
+      ]
+    end
+
+    def subtree depth_options = {}
+      self.base_class.scope_depth(depth_options, depth).any_of(subtree_conditions)
+    end
+
+    def subtree_ids depth_options = {}
+      subtree(depth_options).only(:_id).map(&:id)
+    end
+
+    # Callback disabling
+    def without_ancestry_callbacks
+      @disable_ancestry_callbacks = true
+      yield
+      @disable_ancestry_callbacks = false
+    end
+
+    def ancestry_callbacks_disabled?
+      !!@disable_ancestry_callbacks
+    end
+
+    private
+
+    def cast_primary_key(key)
+      if primary_key_type == Integer
+        key.to_i
+      elsif primary_key_type == BSON::ObjectId && key =~ /[a-z0-9]{24}/
+        BSON::ObjectId.convert(self, key)
+      else
+        key
+      end
+    end
+
+    def primary_key_type
+      @primary_key_type ||= self.base_class.fields['_id'].options[:type]
+    end
+  end
+
+end

data/lib/mongoid-ancestry/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Ancestry
+    VERSION = '0.2.3'
+  end
+end

data/lib/mongoid-ancestry.rb

@@ -0,0 +1,15 @@
+module Mongoid
+  module Ancestry
+    extend ActiveSupport::Concern
+
+    autoload :ClassMethods,    'mongoid-ancestry/class_methods'
+    autoload :Error,           'mongoid-ancestry/exceptions'
+
+    included do
+      cattr_accessor :base_class
+      self.base_class = self
+    end
+
+    require 'mongoid-ancestry/instance_methods'
+  end
+end

data/log/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

data/mongoid-ancestry.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mongoid-ancestry/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'mongoid-ancestry-fixes'
+  s.version     = '0.0.1'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Stefan Kroes", "Anton Orel"]
+  s.email       = ["eagle.anton@gmail.com"]
+  s.description = %q{Organise Mongoid model into a tree structure}
+  s.homepage    = "http://github.com/skyeagle/mongoid-ancestry"
+  s.summary     = %q{Ancestry allows the records of a Mongoid model to be organised in a tree structure, using a single, intuitively formatted database field. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.}
+  s.licenses    = ["MIT"]
+
+  s.rubyforge_project = "mongoid-ancestry-fixes"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+
+  s.add_dependency('mongoid', ">= 2.0")
+  s.add_dependency('bson_ext', ">= 1.3")
+end
+

data/spec/lib/ancestry_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+require 'mongoid-ancestry/exceptions'
+
+
+describe MongoidAncestry do
+
+  subject { MongoidAncestry }
+
+  it "should have ancestry fields" do
+    subject.with_model do |model|
+      model.fields['ancestry'].options[:type].should eql(String)
+    end
+  end
+
+  it "should have non default ancestry field" do
+    subject.with_model :ancestry_field => :alternative_ancestry do |model|
+      model.ancestry_field.should eql(:alternative_ancestry)
+    end
+  end
+
+  it "should set ancestry field" do
+    subject.with_model do |model|
+      model.ancestry_field = :ancestors
+      model.ancestry_field.should eql(:ancestors)
+      model.ancestry_field = :ancestry
+      model.ancestry_field.should eql(:ancestry)
+    end
+  end
+
+  it "should have default orphan strategy" do
+    subject.with_model do |model|
+      model.orphan_strategy.should eql(:destroy)
+    end
+  end
+
+  it "should have non default orphan strategy" do
+    subject.with_model :orphan_strategy => :rootify do |model|
+      model.orphan_strategy.should eql(:rootify)
+    end
+  end
+
+  it "should set orphan strategy" do
+    subject.with_model do |model|
+      model.orphan_strategy = :rootify
+      model.orphan_strategy.should eql(:rootify)
+      model.orphan_strategy = :destroy
+      model.orphan_strategy.should eql(:destroy)
+    end
+  end
+
+  it "should not set invalid orphan strategy" do
+    subject.with_model do |model|
+      expect {
+        model.orphan_strategy = :non_existent_orphan_strategy
+      }.to raise_error Mongoid::Ancestry::Error
+    end
+  end
+
+  it "should setup test nodes" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      roots.class.should eql(Array)
+      roots.length.should eql(3)
+      roots.each do |node, children|
+        node.class.should eql(model)
+        children.class.should eql(Array)
+        children.length.should eql(3)
+        children.each do |node, children|
+          node.class.should eql(model)
+          children.class.should eql(Array)
+          children.length.should eql(3)
+          children.each do |node, children|
+            node.class.should eql(model)
+            children.class.should eql(Array)
+            children.length.should eql(0)
+          end
+        end
+      end
+    end
+  end
+
+  it "should have STI support" do
+    subject.with_model :extra_columns => {:type => :string} do |model|
+      subclass1 = Object.const_set 'Subclass1', Class.new(model)
+      (class << subclass1; self; end).send(:define_method, :model_name) do
+      Struct.new(:human, :underscore).new 'Subclass1', 'subclass1'
+      end
+      subclass2 = Object.const_set 'Subclass2', Class.new(model)
+      (class << subclass2; self; end).send(:define_method, :model_name) do
+      Struct.new(:human, :underscore).new 'Subclass1', 'subclass1'
+      end
+
+      node1 = subclass1.create
+      node2 = subclass2.create :parent => node1
+      node3 = subclass1.create :parent => node2
+      node4 = subclass2.create :parent => node3
+      node5 = subclass1.create :parent => node4
+
+      model.all.each do |node|
+        [subclass1, subclass2].include?(node.class).should be_true
+      end
+
+      node1.descendants.map(&:id).should eql([node2.id, node3.id, node4.id, node5.id])
+      node1.subtree.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id, node5.id])
+      node5.ancestors.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id])
+      node5.path.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id, node5.id])
+    end
+  end
+
+end