chronic_tree 1.0.0

data/lib/chronic_tree.rb

@@ -0,0 +1,73 @@
+require "chronic_tree/version"
+require "chronic_tree/active_record/element"
+require "chronic_tree/travesal"
+require "chronic_tree/operation"
+require "chronic_tree/active_record/relation"
+require "set"
+
+module ChronicTree
+  require 'chronic_tree/railtie' if defined?(Rails)
+
+  class Error < RuntimeError; end
+  class InvalidObjectError < Error; end
+
+  include ChronicTree::ActiveRecord::Relation
+  include ChronicTree::Travesal
+  include ChronicTree::Operation
+
+  def self.included(base)
+    base.class_eval <<-RUBY
+      attr_reader :current_time_at, :current_scope_name
+
+      @@defined_chronic_tree_scopes = Set.new
+
+      def self.defined_chronic_tree_scopes
+        @@defined_chronic_tree_scopes
+      end
+    RUBY
+
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def chronic_tree(scope_name = 'default')
+      self.class_eval <<-RUBY
+        has_many :"elements_under_#{scope_name}_parent",
+          proc { |owner| where(scope_name: scope_name, tree_type: owner.class.name) },
+          class_name: 'ChronicTree::ActiveRecord::Element',
+          foreign_key: 'parent_id',
+          dependent: :destroy
+
+        has_many :"elements_as_#{scope_name}_child",
+          proc { |owner| where(scope_name: scope_name, tree_type: owner.class.name) },
+          class_name: 'ChronicTree::ActiveRecord::Element',
+          foreign_key: 'child_id',
+          dependent: :destroy
+
+        has_many :"elements_under_#{scope_name}_root",
+          proc { |owner| where(scope_name: scope_name, tree_type: owner.class.name) },
+          class_name: 'ChronicTree::ActiveRecord::Element',
+          foreign_key: 'root_id',
+          dependent: :destroy
+      RUBY
+
+      defined_chronic_tree_scopes << scope_name
+    end
+
+  end
+
+  def as_tree(time_at = Time.now, scope_name = 'default')
+    time_at, scope_name = Time.now, time_at if time_at.is_a?(String)
+
+    raise "Scope name is wrong.  It should be equal to the name that has " \
+     "been set up." unless self.class.defined_chronic_tree_scopes.include?(scope_name)
+
+    raise "Time can't be later than now." if time_at > Time.now
+
+    @current_time_at = time_at
+    @current_scope_name = scope_name
+
+    self
+  end
+end

data/lib/chronic_tree/active_record/element.rb

@@ -0,0 +1,26 @@
+module ChronicTree
+  module ActiveRecord
+    class Element < ::ActiveRecord::Base
+      self.table_name = "chronic_tree_elements"
+
+      belongs_to :parent, polymorphic: true, foreign_type: 'tree_type'
+      belongs_to :child, polymorphic: true, foreign_type: 'tree_type'
+      belongs_to :root, polymorphic: true, foreign_type: 'tree_type'
+
+      scope :at, -> (time = Time.now) {
+        start_time_col = self.arel_table[:start_time]
+        end_time_col = self.arel_table[:end_time]
+        where(start_time_col.lteq(time)).where(end_time_col.gt(time))
+      }
+
+      scope :exclude_root, -> {
+        root_id_col = self.arel_table[:root_id]
+        child_id_col = self.arel_table[:child_id]
+        where(root_id_col.not_eq(child_id_col))
+      }
+
+      scope :direct, -> { where(distance: 1) }
+      scope :all_distance, -> { unscope(where: :distance) }
+    end
+  end
+end

data/lib/chronic_tree/active_record/relation.rb

@@ -0,0 +1,34 @@
+module ChronicTree
+  module ActiveRecord
+    module Relation
+      def children_relation(time_at, scope_name)
+        send("elements_under_#{scope_name}_parent").
+          at(time_at).
+          direct.
+          exclude_root.
+          includes(:child)
+      end
+
+      def parent_relation(time_at, scope_name)
+        existed_relation(time_at, scope_name).
+          direct.
+          exclude_root
+      end
+
+      def existed_relation(time_at, scope_name)
+        send("elements_as_#{scope_name}_child").
+          at(time_at)
+      end
+
+      def descendants_relation(time_at, scope_name)
+        children_relation(time_at, scope_name).order(:distance).all_distance
+      end
+
+      def ancestors_relation(time_at, scope_name)
+        existed_relation(time_at, scope_name).
+          includes(:parent).
+          order(:distance)
+      end
+    end
+  end
+end

data/lib/chronic_tree/command.rb

@@ -0,0 +1,165 @@
+module ChronicTree
+  module Command
+
+    class AddRootElement
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      def do
+        source.send("elements_under_#{source.current_scope_name}_root").create(
+          child: source,
+          parent: source,
+          distance: 0,
+          start_time: source.current_time_at,
+          end_time: 1000.years.since(source.current_time_at)
+        )
+      end
+    end
+
+    class AddChildElement
+      attr_reader :source, :child_id, :distance, :source_root_id
+
+      def initialize(source, child_object_or_child_id, distance = 1, source_root_id = nil)
+        @source = source
+        @source_root_id = if source_root_id.nil?
+          source.root.id
+        else
+          source_root_id
+        end
+
+        @distance = distance
+
+        @child_id = if child_object_or_child_id.respond_to?(:id)
+          child_object_or_child_id.send(:id)
+        else
+          child_object_or_child_id
+        end
+      end
+
+      def do
+        source.send("elements_under_#{source.current_scope_name}_parent").create(
+          root_id: source_root_id,
+          child_id: child_id,
+          distance: distance,
+          start_time: source.current_time_at,
+          end_time: 1000.years.since(source.current_time_at)
+        )
+      end
+    end
+
+    class RemoveChildElementsFromAncestors
+      attr_reader :ancestor_ids, :child_ids, :source
+
+      def initialize(source, ancestor_ids, child_ids)
+        @source = source
+        @ancestor_ids = ancestor_ids
+        @child_ids = child_ids
+      end
+
+      def do
+        ChronicTree::ActiveRecord::Element.at(source.current_time_at).
+          where(tree_type: source.class.name).
+          where(scope_name: source.current_scope_name).
+          where(parent_id: ancestor_ids).
+          where(child_id: child_ids).
+          update_all(end_time: source.current_time_at)
+      end
+    end
+
+    class AddChildElementsToNewAncestors
+      attr_reader :source, :source_root_id, :new_ancestors, :child_elements
+
+      def initialize(source, source_root_id, new_ancestors, child_elements)
+        @source = source
+        @source_root_id = source_root_id
+        @new_ancestors = new_ancestors
+        @child_elements = child_elements
+      end
+
+      def do
+        new_ancestors.each_with_index do |parent_object, i|
+          child_elements.each do |e|
+            AddChildElement.new(parent_object, e.child_id, e.distance + i, source_root_id).do
+          end
+        end
+      end
+    end
+
+    class AddChildElementToOrigAncestors
+      attr_reader :source, :child
+
+      def initialize(source, child)
+        @source = source
+        @child = child
+      end
+
+      def do
+        source.ancestors.each_with_index do |parent_object, index|
+          AddChildElement.new(parent_object, child, index + 2, source.root.id).do
+        end
+      end
+    end
+
+    class AddReplacedObjToOrigAncestors
+      attr_reader :source, :source_root_id, :source_ancestors, :target
+
+      def initialize(source, source_root_id, source_ancestors, target)
+        @source = source
+        @source_root_id = source_root_id
+        @source_ancestors = source_ancestors
+        @target = target
+      end
+
+      def do
+        source_ancestors.each_with_index do |parent_object, i|
+          AddChildElement.new(parent_object, target.id, i + 1, source_root_id).do
+        end
+      end
+    end
+
+    class AddChildElementsToReplacedObject
+      attr_reader :source, :source_root_id, :target, :child_elements
+
+      def initialize(source, source_root_id, target, child_elements)
+        @source = source
+        @source_root_id = source_root_id
+        @target = target
+        @child_elements = child_elements
+      end
+
+      def do
+        child_elements.each { |el| AddChildElement.new(target, el.child_id, el.distance).do }
+      end
+    end
+
+    class RemoveSelfElement
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      def do
+        source.existed_relation(source.current_time_at, source.current_scope_name).each do |el|
+          el.update_attribute(:end_time, source.current_time_at)
+        end
+      end
+    end
+
+    class RemoveDescendantElements
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      def do
+        source.flat_descendants.each { |object| RemoveSelfElement.new(object).do }
+      end
+    end
+
+  end
+end

data/lib/chronic_tree/operation.rb

@@ -0,0 +1,212 @@
+require 'chronic_tree/command'
+
+module ChronicTree
+  module Operation
+
+    class ChangeParent
+      attr_reader :source, :source_root_id, :ready_to_move_elements, :new_ancestors
+
+      def initialize(source, new_parent_object)
+        @source = source
+
+        @ready_to_move_elements = source.
+          descendants_relation(source.current_time_at,
+                               source.current_scope_name).map do |el|
+
+          OpenStruct.new(child_id: el.child_id, distance: el.distance + 1)
+        end
+        @ready_to_move_elements << OpenStruct.new(child_id: source.id, distance: 1)
+
+        @source_root_id = source.root.id
+
+        @new_ancestors = new_parent_object.ancestors
+        @new_ancestors.unshift(new_parent_object) unless new_parent_object.id == @source_root_id
+      end
+
+      def act
+        ::ActiveRecord::Base.transaction do
+          ChronicTree::Command::RemoveChildElementsFromAncestors.new(
+            source,
+            source.ancestors.map(&:id),
+            ready_to_move_elements.map(&:child_id)).do
+
+          ChronicTree::Command::AddChildElementsToNewAncestors.new(
+            source,
+            source_root_id,
+            new_ancestors,
+            ready_to_move_elements).do
+        end
+
+        source
+      end
+    end
+
+    class ReplaceBy
+      attr_reader :source, :target, :source_root_id, :source_ancestors, :ready_to_move_elements
+
+      def initialize(source, target)
+        @source = source
+        @target = target
+
+        @ready_to_move_elements = source.descendants_relation(
+          source.current_time_at,
+          source.current_scope_name).map do |el|
+
+          OpenStruct.new(id: el.id, child_id: el.child_id, distance: el.distance)
+        end
+
+        @source_root_id = (source == source.root) ? target.id : source.root.id
+        @source_ancestors = source.ancestors
+      end
+
+      def act
+        ::ActiveRecord::Base.transaction do
+          remove_obsolete_elements
+          add_new_elements
+        end
+
+        source
+      end
+
+      private
+
+        def remove_obsolete_elements
+          ChronicTree::Command::RemoveChildElementsFromAncestors.new(
+            source,
+            [source.id],
+            ready_to_move_elements.map(&:child_id)).do
+
+          ChronicTree::Command::RemoveSelfElement.new(source).do
+        end
+
+        def add_new_elements
+          if source.id == source_root_id
+            ChronicTree::Command::AddRootElement.new(source).do
+          else
+            ChronicTree::Command::AddReplacedObjToOrigAncestors.new(
+              source, source_root_id, source_ancestors, target).do
+          end
+
+          ChronicTree::Command::AddChildElementsToReplacedObject.new(
+            source, source_root_id, target, ready_to_move_elements).do
+        end
+    end
+
+
+
+    def add_as_root
+      as_tree(Time.now, current_scope_name || 'default')
+
+      raise_if_tree_is_not_empty
+
+      ChronicTree::Command::AddRootElement.new(self).do
+
+      self
+    end
+
+    def add_child(object)
+      as_tree(Time.now, current_scope_name || 'default') && object.as_tree(current_time_at, current_scope_name)
+
+      raise_if_object_unmatched(object)
+      raise_if_object_is_in_the_tree(object)
+      raise_if_self_is_not_in_the_tree
+
+      ::ActiveRecord::Base.transaction do
+        ChronicTree::Command::AddChildElement.new(self, object).do
+        ChronicTree::Command::AddChildElementToOrigAncestors.new(self, object).do unless self == root
+      end
+
+      self
+    end
+
+    def remove_self
+      as_tree(Time.now, current_scope_name || 'default')
+
+      raise_if_self_is_not_in_the_tree
+
+      ::ActiveRecord::Base.transaction do
+        ChronicTree::Command::RemoveSelfElement.new(self).do
+        ChronicTree::Command::RemoveDescendantElements.new(self).do
+      end
+
+      self
+    end
+
+    def remove_descendants
+      as_tree(Time.now, current_scope_name || 'default')
+
+      raise_if_self_is_not_in_the_tree
+
+      ::ActiveRecord::Base.transaction { ChronicTree::Command::RemoveDescendantElements.new(self).do }
+
+      self
+    end
+
+    def change_parent(object)
+      as_tree(Time.now, current_scope_name || 'default') && object.as_tree(current_time_at, current_scope_name)
+      return self if self != root && parent == object
+
+      raise_if_object_unmatched(object)
+      raise_if_object_is_not_in_the_tree(object)
+      raise_if_object_equals_to_self(object)
+      raise_if_object_is_a_child_of_self(object)
+      raise_if_self_is_not_in_the_tree
+
+      ChangeParent.new(self, object).act
+    end
+
+    def replace_by(object)
+      as_tree(Time.now, current_scope_name || 'default') && object.as_tree(current_time_at, current_scope_name)
+
+      raise_if_object_unmatched(object)
+      raise_if_object_is_in_the_tree(object)
+      raise_if_self_is_not_in_the_tree
+
+      ReplaceBy.new(self, object).act
+    end
+
+    private
+
+      def raise_if_object_unmatched(object)
+        if object.class.name != self.class.name
+          raise InvalidObjectError, "Object invalid. You can't add two types of objects in a tree."
+        end
+
+        raise InvalidObjectError, "Object invalid. You must save it first." if object.new_record?
+      end
+
+      def raise_if_object_is_in_the_tree(object)
+        if object.existed_in_tree?(current_time_at, current_scope_name)
+          raise InvalidObjectError, "Object must not be in the tree now."
+        end
+      end
+
+      def raise_if_object_is_not_in_the_tree(object)
+        unless object.existed_in_tree?(current_time_at, current_scope_name)
+          raise InvalidObjectError, "Object must be in the tree now."
+        end
+      end
+
+      def raise_if_object_equals_to_self(object)
+        raise InvalidObjectError, "Object can't be equal to self." if self == object
+      end
+
+      def raise_if_object_is_a_child_of_self(object)
+        if descendants_relation(current_time_at, current_scope_name).where(child_id: object.id).any?
+          raise InvalidObjectError, "Object can't be a child of self."
+        end
+      end
+
+      def raise_if_self_is_not_in_the_tree
+        unless existed_in_tree?(current_time_at, current_scope_name)
+          raise Error, "Self must be in the tree now."
+        end
+      end
+
+      def raise_if_tree_is_not_empty
+        unless tree_empty?(current_time_at, current_scope_name)
+          raise Error, "Tree isn't empty, can't add root element."
+        end
+      end
+  end
+end