acts_as_nested_interval 0.2.0 → 0.3.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 252c9518f088df6b078b315b97ae732f1e5fffc7
-  data.tar.gz: a16f8ba25772672b1794742466883ac7d61e62b0
+  metadata.gz: 727dd5393b81d22ca456a5ac3f2661287f909a42
+  data.tar.gz: ff0dc310818337c838c1ac91c9f6a9e7054bc282
 SHA512:
-  metadata.gz: 60417ca3dffb7310836bd95d641c6a78dc1cf49668af22d2066eab081767b6cf70544a43f1a3948354a6fbbb001c31bc4e6bc52041bc52e4687645936e6402ec
-  data.tar.gz: 249f1d4171f569687190f46412438b13b754c418d82d23de1e9ee6f4a4334e78de892dc7d35fe9a7dc8c20cdc1b206be578bd2dc16857729d0e173e51a89d615
+  metadata.gz: fadcf0336a54a3d6deb0ae23d5a11c96c1e229a39653dca8568a1f9bf0b174057e7cb422751517409a1635857690d1a89925d959986896eeb68fcdb57b2fe39b
+  data.tar.gz: b33657f0b7cc2458a00827bb7b0b7fd24d39e8217bec60253acbbce2ff2487d572e0fe0669ee091d30bf7c09460bae0c7e6385b52b005af4a96d3016781707c2

data/README.md

@@ -17,8 +17,10 @@ If your database supports recursive queryes (`WITH RECURSIVE`) or specific custo
 ## Install
 
 ```ruby
-# add to Gemfile
-gem 'acts_as_nested_interval'
+# add to Gemfile when you use Ruby > 2.0 or Rails >= 4.0
+gem 'acts_as_nested_interval', '~> 0.2.0'
+# Orherwise
+gem 'acts_as_nested_interval', '~> 0.1.1' # This version could have less features than actual version, check legacy branch.
 ```
 
 ```sh
@@ -49,6 +51,7 @@ add_index :regions, :lftp
 add_index :regions, :lftq
 add_index :regions, :lft
 add_index :regions, :rgt
+add_index :regions, [:lftp, :lftq, :rgtq, :rgtp], unique: true
 ```
 
 ## Usage
@@ -59,8 +62,11 @@ point data types in the database.
 This act provides these named scopes:
 
 ```ruby
-Region.roots    # returns roots of tree.
-Region.preorder # returns records for preorder traversal.
+Region.roots								# returns roots of tree.
+Region.preorder							# returns records for preorder traversal.
+Region.ancestors_of(node)	  # returns all ancestors of given node
+Region.descendants_of(node) # returns all descendants of given node
+Region.siblings_of(node)		# returns all siblings of given node
 ```
 
 This act provides these instance methods:
@@ -70,6 +76,7 @@ Region.parent      # returns parent of record.
 Region.children    # returns children of record.
 Region.ancestors   # returns scoped ancestors of record.
 Region.descendants # returns scoped descendants of record.
+Region.siblings		 # returns scoped siblings of record.
 Region.depth       # returns depth of record.
 ```
 

data/lib/acts_as_nested_interval.rb

@@ -5,12 +5,14 @@
 # https://github.com/clyfe
 
 require 'acts_as_nested_interval/core_ext/integer'
+require 'acts_as_nested_interval/core_ext/rational'
 require 'acts_as_nested_interval/version'
 require 'acts_as_nested_interval/constants'
 require 'acts_as_nested_interval/configuration'
 require 'acts_as_nested_interval/callbacks'
 require 'acts_as_nested_interval/instance_methods'
 require 'acts_as_nested_interval/class_methods'
+require 'acts_as_nested_interval/associations'
 
 # This act implements a nested-interval tree. You can find all descendants
 # or all ancestors with just one select query. You can insert and delete
@@ -28,46 +30,17 @@ module ActsAsNestedInterval
     # * <tt>:dependent</tt> -- dependency between the parent node and children nodes (default :restrict)
     def acts_as_nested_interval(options = {})
       # Refactored
-      # TODO: table_exists?
       cattr_accessor :nested_interval
 
       self.nested_interval = Configuration.new( self, **options )
 
-      if nested_interval.fraction_cache?
-        scope :preorder, -> { order(rgt: :desc, lftp: :asc) }
-      else
-        scope :preorder, -> { order('1.0 * rgtp / rgtq DESC, lftp ASC') }
-      end
-      # When?
-      #scope :preorder, -> { order('nested_interval_rgt(lftp, lftq) DESC, lftp ASC') }
-
-
-      # OLD CODE
-      #cattr_accessor :nested_interval_foreign_key
-      #cattr_accessor :nested_interval_scope_columns
-      cattr_accessor :nested_interval_lft_index
-      #cattr_accessor :nested_interval_dependent
-
-      cattr_accessor :virtual_root
-      self.virtual_root = !!options[:virtual_root]
-
-      #self.nested_interval_foreign_key = options[:foreign_key] || :parent_id
-      #self.nested_interval_scope_columns = Array(options[:scope_columns])
-      self.nested_interval_lft_index = options[:lft_index]
-      #self.nested_interval_dependent = options[:dependent] || :restrict_with_exception
-
-      belongs_to :parent, class_name: name, foreign_key: nested_interval.foreign_key
-      has_many :children, class_name: name, foreign_key: nested_interval.foreign_key,
-        dependent: nested_interval.dependent
-      scope :roots, -> { where(nested_interval.foreign_key => nil) }
-
       if self.table_exists? # Fix problem with migrating without table
         include ActsAsNestedInterval::InstanceMethods
         include ActsAsNestedInterval::Callbacks
+        include ActsAsNestedInterval::Associations
         extend ActsAsNestedInterval::ClassMethods
       end
     end
   end
 end
 
-#ActiveRecord::Base.send :extend, ActsAsNestedInterval

data/lib/acts_as_nested_interval/associations.rb

@@ -0,0 +1,41 @@
+module ActsAsNestedInterval
+  module Associations
+    extend ActiveSupport::Concern
+
+    included do 
+      belongs_to :parent, class_name: name, foreign_key: nested_interval.foreign_key
+      has_many :children, class_name: name, foreign_key: nested_interval.foreign_key,
+        dependent: nested_interval.dependent
+      scope :roots, -> { where(nested_interval.foreign_key => nil) }
+
+      scope :ancestors_of, ->(node){ where("rgt >= CAST(:rgt AS FLOAT) AND lft < CAST(:lft AS FLOAT)", rgt: node.rgt, lft: node.lft) }
+      scope :subtree_of, ->(node){ where( "lft BETWEEN :lft AND :rgt", rgt: node.rgt, lft: node.lft ) } # Simple version
+      scope :descendants_of, ->(node){ subtree_of(node).where.not(id: node.id) }
+      scope :siblings_of, ->(node){ fkey = nested_interval.foreign_key; where( fkey => node.send(fkey) ).where.not(id: node.id) }
+
+      if nested_interval.fraction_cache?
+        scope :preorder, -> { order(rgt: :desc, lftp: :asc) }
+      else
+        scope :preorder, -> { order('1.0 * rgtp / rgtq DESC, lftp ASC') }
+      end
+    end
+
+    def ancestor_of?(node)
+      left < node.left && right >= node.right
+    end
+
+    def ancestors
+      nested_interval_scope.ancestors_of(self)
+    end
+
+    def descendants
+      nested_interval_scope.descendants_of(self)
+    end
+
+    def siblings
+      nested_interval_scope.siblings_of(self)
+    end
+
+
+  end
+end

data/lib/acts_as_nested_interval/callbacks.rb

@@ -17,26 +17,36 @@ module ActsAsNestedInterval
 
     # Creates record.
     def create_nested_interval
-      if read_attribute(nested_interval.foreign_key).nil?
-        set_nested_interval_for_top
-      else
-        set_nested_interval *parent.lock!.next_child_lft
-      end
+      set_nested_interval(parent.present? ? parent.next_child_lft : next_root_lft )
     end
 
     # Updates record, updating descendants if parent association updated,
     # in which case caller should first acquire table lock.
     def update_nested_interval
-      changed = send(:"#{nested_interval.foreign_key}_changed?")
-      if !changed
+      return if moving?
+      unless node_moved?
         db_self = self.class.find(id).lock!
         write_attribute(nested_interval.foreign_key, db_self.read_attribute(nested_interval.foreign_key))
-        set_nested_interval db_self.lftp, db_self.lftq
+        set_nested_interval Rational(db_self.lftp, db_self.lftq)
       else
         # No locking in this case -- caller should have acquired table lock.
         update_nested_interval_move
       end
     end
+
+    def move!
+      return if moving?
+      self.class.nested_interval.moving = true
+      transaction do
+        yield 
+      end
+    ensure
+      self.class.nested_interval.moving = false
+    end
+
+    def moving?
+      !!self.class.nested_interval.moving
+    end
     
   end
 end

data/lib/acts_as_nested_interval/configuration.rb

@@ -2,13 +2,16 @@ module ActsAsNestedInterval
   class Configuration
 
     attr_reader :foreign_key, :dependent, :scope_columns
+    attr_accessor :moving
 
     # multiple_roots - allow more than one root
-    def initialize( model, virtual_root: false, foreign_key: :parent_id, dependent: :restrict_with_exception, scope_columns: [] )
+    def initialize( model, virtual_root: false, foreign_key: :parent_id, dependent: :restrict_with_exception, scope_columns: [], moveable: true)
       @multiple_roots = !!virtual_root
-      @foreign_key = foreign_key
+      @foreign_key = foreign_key.to_sym
       @dependent = dependent
       @scope_columns = *scope_columns
+      @moveable = moveable && !model.readonly_attributes.include?(foreign_key) # Fix issue #9
+      @moving = false
 
       check_model_columns( model )
     end
@@ -21,6 +24,10 @@ module ActsAsNestedInterval
       @fraction_cache
     end
 
+    def moveable?
+      @moveable
+    end
+
     private
 
     def check_model_columns( model )

data/lib/acts_as_nested_interval/core_ext/rational.rb

@@ -0,0 +1,7 @@
+module Mediant
+  refine Rational do
+    def mediant(a)
+      Rational( numerator + a.numerator, denominator + a.denominator )
+    end
+  end
+end

data/lib/acts_as_nested_interval/instance_methods.rb

@@ -1,50 +1,23 @@
+using Mediant
+
 module ActsAsNestedInterval
   module InstanceMethods
+
     extend ActiveSupport::Concern
     
     # selectively define #descendants according to table features
     included do
-
-      if nested_interval.fraction_cache?
-
-        def descendants
-          nested_interval_scope.where( "lftp > :lftp AND lft BETWEEN :lft AND :rgt", lftp: lftp, rgt: rgt, lft: lft )
-        end
-
-      else
-
-        def descendants
-          quoted_table_name = self.class.quoted_table_name
-          nested_interval_scope.where <<-SQL
-              ( #{quoted_table_name}.lftp != #{rgtp} OR
-          #{quoted_table_name}.lftq != #{rgtq}
-              ) AND
-          #{quoted_table_name}.lftp BETWEEN
-                1 + #{quoted_table_name}.lftq * CAST(#{lftp} AS BIGINT) / #{lftq} AND
-          #{quoted_table_name}.lftq * CAST(#{rgtp} AS BIGINT) / #{rgtq}
-          SQL
-        end
-
-      end
-
+      validate :disallow_circular_dependency
     end
     
-    def set_nested_interval(lftp, lftq)
-      self.lftp, self.lftq = lftp, lftq
+    def set_nested_interval(rational)
+      self.lftp, self.lftq = rational.numerator, rational.denominator
       self.rgtp = rgtp if has_attribute?(:rgtp)
       self.rgtq = rgtq if has_attribute?(:rgtq)
       self.lft = lft if has_attribute?(:lft)
       self.rgt = rgt if has_attribute?(:rgt)
     end
     
-    def set_nested_interval_for_top
-      if nested_interval.multiple_roots?
-        set_nested_interval(*next_root_lft)
-      else
-        set_nested_interval 0, 1
-      end
-    end
-
     def nested_interval_scope
       conditions = {}
       nested_interval.scope_columns.each do |column_name|
@@ -53,80 +26,33 @@ module ActsAsNestedInterval
       self.class.where conditions
     end
 
-    # Rewrite method
-    def update_nested_interval_move
-      return if self.class.readonly_attributes.include?(nested_interval.foreign_key.to_sym) # Fix issue #9
-      begin
-        db_self = self.class.find(id)
-        db_parent = self.class.find(read_attribute(nested_interval.foreign_key))
-        if db_self.ancestor_of?(db_parent)
-          errors.add nested_interval.foreign_key, "is descendant"
-          raise ActiveRecord::RecordInvalid, self
-        end
-      rescue ActiveRecord::RecordNotFound => e # root
+    def recalculate_nested_interval!
+      move! do
+        lftr = parent.present? ? parent.next_child_lft : next_root_lft
+        set_nested_interval( lftr )
+        save!
+        self.recalculate_nested_interval!
+        children.preorder.map(&:recalculate_nested_interval!)
       end
-      
-      if read_attribute(nested_interval.foreign_key).nil? # root move
-        set_nested_interval_for_top
-      else # child move
-        set_nested_interval *parent.next_child_lft
-      end
-      cpp = db_self.lftq * rgtp - db_self.rgtq * lftp
-      cpq = db_self.rgtp * lftp - db_self.lftp * rgtp
-      cqp = db_self.lftq * rgtq - db_self.rgtq * lftq
-      cqq = db_self.rgtp * lftq - db_self.lftp * rgtq
+    end
 
-      updates = {}
-      vars = Set.new
-      # TODO
-      mysql = false #["MySQL", "Mysql2"].include?(connection.adapter_name)
-      var = ->(v) { mysql ? vars.add?(v) ? "(@#{v} := #{v})" : "@#{v}" : v }
-      multiply = ->(c, b) { "#{c} * #{var.(b)}" }
-      add = ->(a, b) { "#{a} + #{b}" }
-      one = sprintf("%#.30f", 1)
-      divide = ->(p, q) { "#{one} * (#{p}) / (#{q})" }
+    # Rewrite method
+    def update_nested_interval_move
+      return unless self.class.nested_interval.moveable?
 
-      if has_attribute?(:rgtp) && has_attribute?(:rgtq)
-        updates[:rgtp] = -> { add.(multiply.(cpp, :rgtp), multiply.(cpq, :rgtq)) }
-        updates[:rgtq] = -> { add.(multiply.(cqp, :rgtp), multiply.(cqq, :rgtq)) }
-        updates[:rgt] = -> { divide.(updates[:rgtp].(), updates[:rgtq].()) } if has_attribute?(:rgt)
+      if parent.present? and self.ancestor_of?(parent)
+        errors.add nested_interval.foreign_key, "is descendant"
+        raise ActiveRecord::RecordInvalid, self
       end
 
-      updates[:lftp] = -> { add.(multiply.(cpp, :lftp), multiply.(cpq, :lftq)) }
-      updates[:lftq] = -> { add.(multiply.(cqp, :lftp), multiply.(cqq, :lftq)) }
-      updates[:lft] = -> { divide.(updates[:lftp].(), updates[:lftq].()) } if has_attribute?(:lft)
-
-      sql = updates.map { |k, v| "#{k} = #{v.()}" }.join(', ')
-
-      db_self.descendants.update_all sql
+      # TODO: Do it by DB
+      self.recalculate_nested_interval!
     end
     
-    def ancestor_of?(node)
-      node.lftp == lftp && node.lftq == lftq ||
-        node.lftp > node.lftq * lftp / lftq &&
-        node.lftp <= node.lftq * rgtp / rgtq &&
-        (node.lftp != rgtp || node.lftq != rgtq)
-    end
-
-    def ancestors
-      nested_interval_scope.where("rgt >= CAST(:rgt AS FLOAT) AND lft < CAST(:lft AS FLOAT)", rgt: rgt, lft: lft)
-    end
-
-    #def ancestors
-      #sqls = ['0 = 1']
-      #p, q = lftp, lftq
-      #while p != 0
-        #x = p.inverse(q)
-        #p, q = (x * p - 1) / q, x
-        #sqls << "lftq = #{q} AND lftp = #{p}"
-      #end
-      #nested_interval_scope.where(sqls * ' OR ')
-    #end
-
     # Returns depth by counting ancestors up to 0 / 1.
     def depth
       if new_record?
-        if parent_id.nil?
+        if parent.nil?
           return 0
         else
           return parent.depth + 1
@@ -167,22 +93,39 @@ module ActsAsNestedInterval
     # Returns left end of interval for next child.
     def next_child_lft
       if child = children.order('lftq DESC').first
-        return lftp + child.lftp, lftq + child.lftq
+        return left.mediant( child.left )
       else
-        return lftp + rgtp, lftq + rgtq
+        return left.mediant( right )
       end
     end
     
     # Returns left end of interval for next root.
     def next_root_lft
-      vr = self.class.new # a virtual root
-      vr.set_nested_interval 0, 1
-      if child = nested_interval_scope.roots.order('lftq DESC').first
-        return vr.lftp + child.lftp, vr.lftq + child.lftq
-      else
-        return vr.lftp + vr.rgtp, vr.lftq + vr.rgtq
-      end
+      last_root = nested_interval_scope.roots.order( rgtp: :desc, rgtq: :desc ).first
+      raise Exception.new("Only one root allowed") if last_root.present? && !self.class.nested_interval.multiple_roots?
+      last_root.try(:right) || 0.to_r
     end
     
+    # Check if node is moved (parent changed)
+    def node_moved?
+      send(:"#{nested_interval.foreign_key}_changed?") # TODO: Check if parent moved?
+    end
+
+    def left
+      Rational(lftp, lftq)
+    end
+
+    def right
+      Rational(rgtp, rgtq)
+    end
+
+    protected
+
+    def disallow_circular_dependency
+      if parent == self
+        errors.add(self.class.nested_interval.foreign_key, 'cannot refer back to self')
+      end
+    end
+
   end
 end