acts_as_many_trees 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd3f337c1418d33c73887add48d5bec679c4dc93
-  data.tar.gz: a6e945638bc2e2351b76aa196a55c3e42a29f00c
+  metadata.gz: 2968bbb9d336c54e6d67fbcfa2693a7340dd73bf
+  data.tar.gz: b97258ba8b2bd548d842345d6f5640ee3aa8c412
 SHA512:
-  metadata.gz: 9ea378e205fa97476047c31a321d1af3a5ba268ce2152e1cb7e5de7e98db79461ede251b36503aac1d5cef484081eeb7f02b6108ec0d94ebde1e7b3aca5d588f
-  data.tar.gz: 0df35bdfc480744e0f89d2f48f666c86415e171946ff6e00ee07d18eb06518c4a0bf2565579bbac7e88028402953ad61f5c49d5fba64ee4f327eedbf1c933f3c
+  metadata.gz: 793df7daa449ca0ac8bfd911710314749ae1b7c6ee3b2b3a1f5331ed4ad76b6db2f92edd672175abc8099329afe1db1eba36dab4c0c87e3081bbf3d06c9b5fac
+  data.tar.gz: b0bff842b040b01c21d9d8019f9524b9e148caf0e6a58177f06ccb8e8932a5a4f2dca19c7a29f7ef66e58261f005ec0e8b8d4f7f295dbbaf732e68e9d747f1f7

data/lib/acts_as_many_trees/base.rb

@@ -26,7 +26,7 @@ module ActsAsManyTrees
     included do
       has_many :unscoped_descendant_links,
         ->{order(:position)},
-        class_name:hierarchy_class.to_s,
+        class_name: hierarchy_class.to_s,
         foreign_key: 'ancestor_id',
         dependent: :delete_all,
         inverse_of: :unscoped_ancestor
@@ -39,24 +39,43 @@ module ActsAsManyTrees
         inverse_of: :unscoped_descendant
 
       has_many :unscoped_ancestors,through: :unscoped_ancestor_links
-      has_many :unscoped_descendants, through: :unscoped_descendant_links
-      scope :roots , ->(hierarchy=''){
-        on = Arel::Nodes::On.new(Arel::Nodes::Equality.new(arel_table[:id],hierarchy_class.arel_table[:descendant_id])
-                                 .and(hierarchy_class.arel_table[:hierarchy_scope].eq(hierarchy))
-                                )
-        outer_join = Arel::Nodes::OuterJoin.new(hierarchy_class.arel_table,on)
-        joins(outer_join).merge(hierarchy_class.where(generation: 0))
-      }
+      has_many :unscoped_descendants,  {:through=>:unscoped_descendant_links, :source=>:unscoped_descendant}
+      has_many :self_and_siblings,  
+        {:through=>:unscoped_ancestor_links, 
+         :source=>:item_siblings
+        }
+      has_many :siblings_before,
+        ->{where('unscoped_ancestor_links_siblings_before_join.position > item_hierarchies.position').where('unscoped_ancestor_links_siblings_before_join.generation=1')},
+        {:through=>:unscoped_ancestor_links, 
+         :source=>:item_siblings
+        }
+      has_many :siblings_after,
+        ->{where('unscoped_ancestor_links_siblings_after_join.position < item_hierarchies.position').where('unscoped_ancestor_links_siblings_after_join.generation=1')},
+        {:through=>:unscoped_ancestor_links, 
+         :source=>:item_siblings
+        }
+
+        scope :roots , ->(hierarchy=''){
+          on = Arel::Nodes::On.new(Arel::Nodes::Equality.new(arel_table[:id],hierarchy_class.arel_table[:descendant_id])
+                                   .and(hierarchy_class.arel_table[:hierarchy_scope].eq(hierarchy))
+                                   .and(hierarchy_class.arel_table[:generation].not_eq(0))
+                                  )
+          outer_join = Arel::Nodes::OuterJoin.new(hierarchy_class.arel_table,on)
+          joins(outer_join).merge(hierarchy_class.where(ancestor_id: nil))
+        }
+        scope :not_this,->(this_id) { where.not(id: this_id)}
     end
     delegate :hierarchy_class, to: :class
     def parent=(inpt_parent)
       if inpt_parent.is_a?(Hash)
-         new_parent=inpt_parent[:new_parent]
-         after_node=inpt_parent[:after_node]
-         before_node=inpt_parent[:before_node]
-         hierarchy_scope=inpt_parent[:hierarchy_scope] || ''
+        new_parent=inpt_parent[:new_parent]
+        after_node=inpt_parent[:after_node] 
+        before_node=inpt_parent[:before_node] 
+        hierarchy_scope=inpt_parent[:hierarchy_scope] || ''
       else
         new_parent=inpt_parent
+        after_node=inpt_parent.children.last unless inpt_parent.nil?
+        before_node=inpt_parent.next_sibling unless inpt_parent.nil?
         hierarchy_scope = ''
       end  
       hierarchy_class.set_parent_of(self,new_parent,hierarchy_scope,after_node,before_node)
@@ -78,23 +97,37 @@ module ActsAsManyTrees
       descendants(hierarchy_scope).where('generation=1')
     end
 
-    def siblings(hierarchy_scope='')
-        parent(hierarchy_scope).children(hierarchy_scope).where.not(id: id)
+    def self_and_ancestors(hierarchy='')
+      unscoped_ancestors.merge(hierarchy_class.scope_hierarchy(hierarchy))
     end
 
-    def self_and_siblings(hierarchy_scope='')
-        parent(hierarchy_scope).children(hierarchy_scope)
+    def ancestors(hierarchy='')
+      self_and_ancestors(hierarchy).not_this(self.id)
     end
 
+    def self_and_descendants(hierarchy='')
+      unscoped_descendants.merge(hierarchy_class.scope_hierarchy(hierarchy))
+    end
 
-    def ancestors(hierarchy='')
-      unscoped_ancestors.merge(hierarchy_class.scope_hierarchy(hierarchy))
+    def siblings
+      self_and_siblings.where.not(id: id)
+    end
+
+    def previous_sibling
+      siblings_before.last
+    end
+
+    def next_sibling
+      siblings_after.first
     end
 
     def descendants(hierarchy='')
-      unscoped_descendants.merge(hierarchy_class.scope_hierarchy(hierarchy))
+      self_and_descendants(hierarchy).not_this(self.id)
     end
-  end
 
+    def position(hierarchy='')
+       unscoped_ancestor_links.where(ancestor_id: id,hierarchy_scope: hierarchy).first.position
+    end
+  end
 end
 ActiveRecord::Base.send :include, ActsAsManyTrees::Base

data/lib/acts_as_many_trees/hierarchy_table.rb

@@ -4,6 +4,7 @@ module ActsAsManyTrees
     extend ActiveSupport::Concern
 
     included do
+      UPPER_BOUND=10**20
       class_attribute :item_class_name
       self.item_class_name = self.to_s.gsub('Hierarchy','')
       class_attribute :item_class
@@ -19,6 +20,44 @@ module ActsAsManyTrees
         foreign_key: 'descendant_id', 
         inverse_of: :unscoped_ancestor_links
 
+      has_many :self_and_ancestors,
+        ->(rec){where(hierarchy_scope: rec.hierarchy_scope)},
+        class_name: self.name,
+        foreign_key: 'descendant_id',
+        primary_key: 'ancestor_id'
+
+      has_many :ancestors,
+        ->(rec){where(hierarchy_scope: rec.hierarchy_scope).where.not(generation:0)},
+        class_name: self.name,
+        foreign_key: 'descendant_id',
+        primary_key: 'ancestor_id'
+
+      has_many :self_and_descendants,
+        ->(rec){where(hierarchy_scope: rec.hierarchy_scope).where.order(:position)}, 
+        class_name: self.name,
+        foreign_key: 'ancestor_id',
+        primary_key: 'descendant_id'
+
+      has_many :descendants,
+        ->(rec){where(hierarchy_scope: rec.hierarchy_scope).where.not(generation:0).order(:position)}, 
+        class_name: self.name,
+        foreign_key: 'ancestor_id',
+        primary_key: 'descendant_id'
+
+      has_many :siblings,
+        ->{where(generation: 1)}, 
+        class_name: self.name,
+        foreign_key: 'ancestor_id',
+        primary_key: 'ancestor_id'
+
+      has_many :children,
+        ->(rec){where(hierarchy_scope: rec.hierarchy_scope,generation: 1).order(:position)}, 
+        class_name: self.name,
+        foreign_key: 'ancestor_id',
+        primary_key: 'descendant_id'
+
+      has_many :item_siblings,{through: :siblings, source: :unscoped_descendant}
+
       scope :scope_hierarchy,->(scope_hierarchy=''){ where hierarchy_scope: scope_hierarchy}
       # select t1.* from item_trees t1 left outer join item_trees t2 on t1.ancestor_id = t2.descendant_id and t1.tree_scope = t2.tree_scope where t2.ancestor_id is null
       scope :roots,->do
@@ -32,30 +71,122 @@ module ActsAsManyTrees
            )
         .where(t2[:ancestor_id].eq(nil)
               )
-
+      end
+      scope :self_and_siblings, ->(item,hierarchy_scope='')do
+        joins(:siblings)
+      end
+      scope :siblings_before_this,->(rec) do
+        joins(:siblings).where(:position,lt(rec.position))
       end
 
       def self.set_parent_of(item,new_parent,hierarchy_scope='',after_node=nil,before_node=nil)
-        self.delete_ancestors(item,hierarchy_scope) if item
-        self.fill_in_parent_for(new_parent,item,hierarchy_scope,after_node,before_node) if item || new_parent
-        self.fill_in_ancestors_for(new_parent,item,hierarchy_scope) if item && new_parent
-        self.delete_ancestors_of_item_children(item,hierarchy_scope) if item
-        self.set_new_ancestors_of_item_children(item,hierarchy_scope) if item
+        if new_parent
+          wrk_parent = self.find_by(descendant_id:new_parent.id,ancestor_id:new_parent.id,generation: 0,hierarchy_scope: hierarchy_scope) 
+          unless wrk_parent
+            position = (after_this(nil,nil,hierarchy_scope)+before_this(nil,hierarchy_scope))/2.0
+            wrk_parent=self.create(descendant_id:new_parent.id,ancestor_id:new_parent.id,generation: 0,hierarchy_scope: hierarchy_scope,position: position)
+          end
+        end
+        if item
+          after_position  = after_this(wrk_parent,after_node,hierarchy_scope)
+          before_position = before_this(before_node,hierarchy_scope)
+          position = (after_position+before_position)/2.0
+          wrk_item = self.find_by(descendant_id:item.id,ancestor_id:item.id,generation: 0,hierarchy_scope: hierarchy_scope)
+          if wrk_item
+            wrk_item.position = position
+          else
+            wrk_item=self.create(descendant_id:item.id,ancestor_id:item.id,generation: 0,hierarchy_scope: hierarchy_scope,position: position)
+          end
+          temp_name = SecureRandom.hex
+          create_tree(wrk_item,wrk_parent,temp_name)
+          delete_item_ancestors(wrk_item)
+          delete_ancestors_of_item_children(wrk_item,hierarchy_scope)
+          reset_descendant_position(wrk_item,before_position,temp_name)
+          rename_tree(temp_name,hierarchy_scope)
+        end
       end
 
       private
+      # the new position is after the maximum of the after_node, the parent, the current maximum of all
+      def self.after_this(wrk_parent,after_node,hierarchy_scope)
+        if after_node
+          position = after_node.position(hierarchy_scope)
+        elsif wrk_parent
+          position = wrk_parent.position
+        else
+          position = self.where(hierarchy_scope: hierarchy_scope).maximum(:position) || 0
+        end
+        position
+      end
+
+      # and before the minimum of the before_node, the parent's next sibling or 10**20
+      def self.before_this(before_node,hierarchy_scope)
+        if before_node
+          position = before_node.position(hierarchy_scope)
+        else
+          position = UPPER_BOUND
+        end
+        position
+      end
+
+      def self.create_tree(wrk_item,wrk_parent,temp_name)
+        if wrk_parent
+          sql=<<-SQL
+        insert into #{table_name}(ancestor_id,descendant_id,generation,hierarchy_scope,position)
+        select a.ancestor_id,b.descendant_id,a.generation+b.generation+1,'#{temp_name}',b.position
+          from #{table_name} a, #{table_name} b
+          where a.descendant_id=#{wrk_parent.descendant_id}
+          and b.ancestor_id=#{wrk_item.ancestor_id}
+          and a.hierarchy_scope = b.hierarchy_scope
+          and a.hierarchy_scope = '#{wrk_item.hierarchy_scope}'
+        union
+        select c.ancestor_id,c.descendant_id,c.generation,'#{temp_name}',c.position
+          from #{table_name} c
+          where c.ancestor_id = #{wrk_item.descendant_id}
+          and c.hierarchy_scope = '#{wrk_item.hierarchy_scope}'
+          SQL
+        else
+          sql=<<-SQL
+        insert into #{table_name}(ancestor_id,descendant_id,generation,hierarchy_scope,position)
+        select c.ancestor_id,c.descendant_id,c.generation,'#{temp_name}',c.position
+          from #{table_name} c
+          where c.ancestor_id = #{wrk_item.descendant_id}
+          and c.hierarchy_scope = '#{wrk_item.hierarchy_scope}'
+          SQL
+        end
+        connection.execute(sql)
+      end
+
+      def self.delete_item_ancestors(wrk_item)
+        sql=<<-SQL
+          delete from #{table_name}
+          where hierarchy_scope='#{wrk_item.hierarchy_scope}'
+          and descendant_id=#{wrk_item.descendant_id}
+        SQL
+        connection.execute(sql)
+      end
+
+      def self.rename_tree(old_name,new_name)
+        sql=<<-SQL
+          update #{table_name}
+          set hierarchy_scope='#{new_name}'
+          where hierarchy_scope='#{old_name}'
+        SQL
+        connection.execute(sql)
+      end
+
       def self.delete_ancestors(item,hierarchy_scope)
-        delete_all(descendant_id: item.id,hierarchy_scope: hierarchy_scope )
+        delete.where(descendant_id: item.id,hierarchy_scope: hierarchy_scope ).where.not(generation: 0)
       end
 
       def self.delete_ancestors_of_item_children(item,hierarchy_scope)
         sql = <<-SQL
     delete from #{table_name} as p using #{table_name} as p1 
     where p.descendant_id = p1.descendant_id 
-    and p1.ancestor_id = #{item.id} 
-    and p.generation > p1.generation 
+    and p1.ancestor_id = #{item.descendant_id} 
     and p.hierarchy_scope = p1.hierarchy_scope
     and p1.hierarchy_scope = '#{hierarchy_scope}'
+    and p.generation > 0
         SQL
         connection.execute(sql)
       end
@@ -74,65 +205,46 @@ module ActsAsManyTrees
         connection.execute(sql)
       end
 
-      def self.fill_in_parent_for(new_parent,item,hierarchy_scope='',after_node=nil,before_node=nil)
-        if new_parent
-          p_rec = find_by(descendant_id: new_parent.id,hierarchy_scope: hierarchy_scope)
-          unless p_rec
-            p_rec=create!(ancestor_id: new_parent.id,descendant_id: new_parent.id,hierarchy_scope: hierarchy_scope,generation:0,position:Random.rand(1000000))
-          end
-          #          p "p_rec.position = #{p_rec.position}"
-          a_rec = nil
-          if after_node
-            a_rec = after_node
-            a_rec_h = find_by(ancestor_id: new_parent.id, descendant_id:a_rec.id,hierarchy_scope: hierarchy_scope)
-            a_rec_pos = a_rec_h.position
-          elsif new_parent.children.last
-            a_rec = new_parent.children.last
-            a_rec_h = find_by(ancestor_id: new_parent.id, descendant_id:a_rec.id,hierarchy_scope: hierarchy_scope)
-            a_rec_pos = a_rec_h.position
-          else
-            a_rec_pos = p_rec.position
-          end
-
-          if before_node 
-            b_rec = find_by(descendant_id: before_node.id,hierarchy_scope: hierarchy_scope,generation: 1)
-            if b_rec
-              b_position = b_rec.position
-            end
-          end
-          if b_position && !after_node
-            #            p "b_position #{b_position} parent position #{p_rec.position}"
-            new_position = (Random.rand(10)*(b_position - p_rec.position)/11)+p_rec.position
-          elsif b_position && after_node
-            #            p "b_position #{b_position}  after position #{a_rec_pos}"
-            new_position = (Random.rand(10)*(b_position - a_rec_pos)/11)+a_rec_pos
-          else
-            new_position = a_rec_pos + Random.rand(1000000)
-          end
-          #create(ancestor_id: item.id,descendant_id: item.id,hierarchy_scope: hierarchy_scope,position:new_position,generation:0)
-          if item
-            #          p "id = #{item.id} position=#{new_position}"
-            create(ancestor_id: new_parent.id,descendant_id: item.id,generation: 1,hierarchy_scope: hierarchy_scope,position:new_position)
-          end
-        end
-      end
-
-      def self.fill_in_ancestors_for(new_parent,item,hierarchy_scope)
-        if new_parent
-          sql=<<-SQL
-       insert into #{table_name}(ancestor_id,descendant_id,generation,hierarchy_scope,position)
-       select it.ancestor_id,new_itm.descendant_id,it.generation+1,it.hierarchy_scope,new_itm.position
-       from #{table_name} it 
-       join #{table_name} new_itm on it.descendant_id = new_itm.ancestor_id and it.hierarchy_scope=new_itm.hierarchy_scope
-       where new_itm.ancestor_id=#{new_parent.id}
-       and new_itm.descendant_id=#{item.id}
-       and (it.ancestor_id <> it.descendant_id)
-       and it.hierarchy_scope = '#{hierarchy_scope}'
-          SQL
-          ActiveRecord::Base.connection.execute(sql)
-        end
+      def self.reset_descendant_position(parent,before_position,hierarchy_scope='')
+        after_position = parent.position
+        gap = before_position - after_position
+#        p "before position: #{before_position}, after_position: #{after_position} gap: #{gap}"
+#        sql = <<-SQL
+#        select ancestor_id,descendant_id,hierarchy_scope,(#{after_position} + ( 
+#        (CAST ((rank() over (partition by ancestor_id order by position)-1) AS numeric))
+#        /( CAST (count(*) over (partition by ancestor_id) AS numeric)) * #{gap})) as position
+#        from #{table_name} 
+#        where ancestor_id=#{parent.descendant_id}
+#        and hierarchy_scope='#{hierarchy_scope}'
+#        SQL
+#        res = connection.execute(sql)
+#        res.each_row do |row|
+#          p row
+#        end
+        sql = <<-SQL
+        with new_position as (select ancestor_id,descendant_id,hierarchy_scope,(#{after_position} + ( 
+        (CAST ((rank() over (partition by ancestor_id order by position)-1) AS numeric))
+        /( CAST (count(*) over (partition by ancestor_id) AS numeric)) * #{gap})) as position
+        from #{table_name} 
+        where ancestor_id=#{parent.descendant_id}
+        and hierarchy_scope='#{hierarchy_scope}'
+        )
+        update  
+        #{table_name} as t 
+        set position = new_position.position
+        from new_position
+        where t.descendant_id = new_position.descendant_id
+        and t.hierarchy_scope = new_position.hierarchy_scope
+        SQL
+        connection.execute(sql)
+#        sql=<<-SQL
+#        select * from #{table_name} where hierarchy_scope='#{hierarchy_scope}' order by position
+#        SQL
+#        res = connection.execute(sql)
+#        res.each_row do |row|
+#          p row
+#        end
       end
-
     end
   end
 end

data/lib/acts_as_many_trees/version.rb

@@ -1,3 +1,3 @@
 module ActsAsManyTrees
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_many_trees
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - John Small
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-11 00:00:00.000000000 Z
+date: 2015-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -28,44 +28,44 @@ dependencies:
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.17.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.17.1
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: factory_girl_rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.5.0
 description: Uses the closure tree pattern with a scope field to maintain separate
   hierarchies
 email: