acts_as_many_trees 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 470e6f4791e0acb15b9f6acffb5e576c2143f7f2
-  data.tar.gz: 291fc163aeffb728c54f176dffe70151ec16e7bf
+  metadata.gz: 633c463bad4d37f9c467cba4852ebcbdc10cb87b
+  data.tar.gz: e18295cde70abd5712d5bf316584ced556d321a9
 SHA512:
-  metadata.gz: 9b84921e9a4dc3de94d6cbe6e09c1ae5568df1a2dcdcbec8d488148bbfc0eafcddae0827d7ea70a3082c990526835dc1c0090dd56814e73c6716343b66456122
-  data.tar.gz: 839aa50646e2d2a56f13b1f5bbb1078f6bc87fe42ae5c0196bdcd9f1638c1baeccce494e6a5c4f3d82a41006435d729639122d59cd4f7825d45c4d161b3fdfc8
+  metadata.gz: 2319dc68f438895276c0d6072df2ec3cd56c79376958e3f338c97590a960a2241a6c455ae52b18c742eeed84a63a3fdf15115c2ff342dc0e1226f94e296c1aef
+  data.tar.gz: b3dd7f7a3720dcf927927d51d071a425017fc4276559cb5fb6a1f764e01fcbad7bc42305260e8545dcbd8e4575df890542624f47de3146436de03f587505d3b4

data/lib/acts_as_many_trees/base.rb

@@ -61,12 +61,19 @@ module ActsAsManyTrees
         }
 
         scope :roots , ->(tree_name=self.default_tree_name){
-          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(tree_name))
-                                   .and(hierarchy_class.arel_table[:generation].not_eq(0))
+        h1 = hierarchy_class.arel_table
+        h2 = hierarchy_class.arel_table.alias
+          on1 = Arel::Nodes::On.new(Arel::Nodes::Equality.new(arel_table[:id],h1[:descendant_id])
+                                   .and(h1[:hierarchy_scope].eq(tree_name))
+                                   .and(h1[:generation].eq(0))
                                   )
-          outer_join = Arel::Nodes::OuterJoin.new(hierarchy_class.arel_table,on)
-          joins(outer_join).merge(hierarchy_class.where(ancestor_id: nil))
+          on2 = Arel::Nodes::On.new(Arel::Nodes::Equality.new(h1[:ancestor_id],h2[:descendant_id])
+                                    .and(Arel::Nodes::Equality.new(h1[:hierarchy_scope],h2[:hierarchy_scope]))
+                                   .and(h2[:generation].not_eq(0))
+                                   )
+          inner_join = Arel::Nodes::InnerJoin.new(h1,on1)
+          outer_join = Arel::Nodes::OuterJoin.new(h2,on2)
+          joins(inner_join).joins(outer_join).merge(where(Arel::Nodes::Equality.new(h2[:ancestor_id],nil)))
         }
         scope :not_this,->(this_id) { where.not(id: this_id)}
     end
@@ -81,22 +88,24 @@ module ActsAsManyTrees
         new_parent=inpt_parent[:new_parent]
         after_node=inpt_parent[:after_node] 
         before_node=inpt_parent[:before_node] 
-        tree_name=inpt_parent[:tree_name] || ''
+        tree_name = inpt_parent[:tree_name] || (new_parent ? new_parent.default_tree_name : self.default_tree_name)
+        existing_tree_name = inpt_parent[:existing_tree_name] || self.default_tree_name
       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?
         tree_name = inpt_parent ? inpt_parent.default_tree_name : self.default_tree_name
+        existing_tree_name = self.default_tree_name
       end  
-      hierarchy_class.set_parent_of(self,new_parent,tree_name,after_node,before_node)
+      hierarchy_class.set_parent_of(item:self,new_parent:new_parent,hierarchy_scope:tree_name,existing_scope:existing_tree_name,after_node:after_node,before_node:before_node)
     end
 
-    def set_parent(new_parent,tree_name=self.default_tree_name)
-      hierarchy_class.set_parent_of(self,new_parent,tree_name)
+    def set_parent(new_parent:,tree_name:self.default_tree_name,existing_tree:self.default_tree_name,clone_sub_tree:false)
+      hierarchy_class.set_parent_of(item:self,new_parent:new_parent,hierarchy_scope:tree_name,existing_scope:existing_tree,clone_sub_tree:clone_sub_tree)
     end
 
     def add_child(new_child,tree_name=self.default_tree_name)
-      hierarchy_class.set_parent_of(new_child,self,tree_name)
+      hierarchy_class.set_parent_of(item:new_child,new_parent:self,hierarchy_scope:tree_name)
     end
 
     def parent(tree_name=self.default_tree_name)

data/lib/acts_as_many_trees/hierarchy_table.rb

@@ -63,7 +63,7 @@ module ActsAsManyTrees
       scope :roots,->do
         t1 = arel_table
         t2 = arel_table.alias
-        t1.project(Arel::star).join(t2,Arel::Nodes::OuterJoin)
+        j=t1.project(Arel::star).join(t2,Arel::Nodes::OuterJoin)
         .on(t1[:ancestor_id]
             .eq(t2[:descendant_id])
             .and(t1[:hierarchy_scope].eq(t2[:hierarchy_scope])
@@ -71,6 +71,7 @@ module ActsAsManyTrees
            )
         .where(t2[:ancestor_id].eq(nil)
               )
+        joins(j)
       end
       scope :self_and_siblings, ->(item,hierarchy_scope='')do
         joins(:siblings)
@@ -79,7 +80,7 @@ module ActsAsManyTrees
         joins(:siblings).where(:position,lt(rec.position))
       end
 
-      def self.set_parent_of(item,new_parent,hierarchy_scope='',after_node=nil,before_node=nil)
+      def self.set_parent_of(item:,new_parent:,hierarchy_scope:'',existing_scope:'',clone_sub_tree:false,after_node:nil,before_node:nil)
         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
@@ -87,6 +88,9 @@ module ActsAsManyTrees
             wrk_parent=self.create(descendant_id:new_parent.id,ancestor_id:new_parent.id,generation: 0,hierarchy_scope: hierarchy_scope,position: position)
           end
         end
+        # puts 'ppppppppppp'
+        # debug_tree('')
+        # puts 'pppppppp'
         if item
           after_position  = after_this(wrk_parent,after_node,hierarchy_scope)
           before_position = before_this(before_node,hierarchy_scope)
@@ -100,14 +104,44 @@ module ActsAsManyTrees
           temp_name = SecureRandom.hex
           # BEWARE this works when added default trees and adding default trees to a new scope but it won't work when moving
           # items within a named tree or when adding items from one named scope to another
-          create_tree(wrk_item,wrk_parent,temp_name)
-          delete_item_ancestors(wrk_item)
-          delete_ancestors_of_item_children(wrk_item,hierarchy_scope)
+          # puts "hierarchy_scope #{hierarchy_scope} existing_scope #{existing_scope}"
+          if (hierarchy_scope != existing_scope)
+             # debug_tree(existing_scope)
+             # debug_tree(hierarchy_scope)
+             # debug_tree(temp_name)
+            if clone_sub_tree
+              clone_sub_tree(item:wrk_item,temp_name:temp_name,existing_name:existing_scope)
+            else
+              clone_item_only(item:wrk_item,new_parent:wrk_parent,hierarchy_scope:temp_name)
+            end
+            add_all_ancestors(wrk_item,wrk_parent,temp_name)
+            # debug_tree(temp_name)
+          else
+            # debug_tree
+            # debug_tree(temp_name)
+            # # add_all_ancestors(wrk_item,wrk_parent,temp_name)
+            # puts wrk_item.attributes
+            # puts wrk_parent.attributes
+            create_tree(wrk_item:wrk_item,wrk_parent:wrk_parent,temp_name:temp_name)
+             # debug_tree(temp_name)
+            # delete_item_ancestors(wrk_item)
+            #where({descendant_id: wrk_item.descendant_id,hierarchy_scope: hierarchy_scope }).delete_all
+            # delete_ancestors(wrk_item,wrk_item.hierarchy_scope)
+            delete_ancestors_of_item_children(wrk_item,hierarchy_scope)
+          end
           reset_descendant_position(wrk_item,before_position,temp_name)
           rename_tree(temp_name,hierarchy_scope)
+          # debug_tree('')
+          # puts "***************\n\n"
         end
       end
 
+      def self.debug_tree(hierarchy_scope='')
+        puts '======================'
+        self.where(hierarchy_scope:hierarchy_scope).order([:ancestor_id,:generation]).each{|r| puts r.attributes}
+        puts '**********************'
+      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)
@@ -131,51 +165,110 @@ module ActsAsManyTrees
         position
       end
 
-      def self.create_tree(wrk_item,wrk_parent,temp_name,existing_name='')
-        if wrk_parent
-          if existing_name != wrk_item.hierarchy_scope
-            sql=<<-SQL
+      def self.clone_item_only(item:,new_parent:,hierarchy_scope:)
+        sql=<<-SQL
+        insert into #{table_name}(ancestor_id,descendant_id,generation,hierarchy_scope,position)
+        select b.ancestor_id,a.descendant_id,b.generation+1,'#{hierarchy_scope}',a.position
+        from #{table_name} a,#{table_name} b 
+        where b.descendant_id = #{new_parent.descendant_id}
+        and a.descendant_id = #{item.descendant_id}
+        and a.hierarchy_scope = '#{item.hierarchy_scope}'
+        and a.hierarchy_scope = b.hierarchy_scope
+        and a.generation = 0
+        SQL
+        connection.execute(sql)
+      end
+
+      def self.clone_sub_tree(item:,temp_name:,existing_name:'')
+        sql=<<-SQL
+        insert into #{table_name}(ancestor_id,descendant_id,generation,hierarchy_scope,position)
+        WITH RECURSIVE sub_trees(ancestor_id,descendant_id,generation,hierarchy_scope,position) AS
+          (select ancestor_id,descendant_id,generation,'#{temp_name}',position from #{table_name}
+           where descendant_id = #{item.descendant_id} 
+           and hierarchy_scope = '#{existing_name}'
+        UNION
+           select s.ancestor_id,s.descendant_id,
+           s.generation,'#{temp_name}',s.position
+           from #{table_name} s, sub_trees st
+           where s.ancestor_id = st.descendant_id
+           and s.hierarchy_scope = '#{existing_name}'
+           )
+           select * from sub_trees;
+        SQL
+        connection.execute(sql)
+      end
+
+      def self.add_all_ancestors(item,parent,temp_name)
+        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}'
-        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.ancestor_id <> c.descendant_id
-          and c.hierarchy_scope = '#{existing_name}'
-        union
-        select #{wrk_parent.descendant_id},c.descendant_id,#{wrk_parent.generation}+c.generation+1,'#{temp_name}',c.position
-          from #{table_name} c
-          where c.ancestor_id = #{wrk_item.descendant_id}
-          and c.ancestor_id <> c.descendant_id
-          and c.hierarchy_scope = '#{existing_name}'
-            SQL
-          else
-            sql=<<-SQL
+          where a.descendant_id=#{parent.descendant_id}
+          and b.ancestor_id=#{item.descendant_id}
+          and b.hierarchy_scope = '#{temp_name}'
+          and a.hierarchy_scope = '#{parent.hierarchy_scope}'
+        SQL
+        connection.execute(sql)
+      end
+
+      def self.create_tree(wrk_item:,wrk_parent:,temp_name:)
+        if wrk_parent
+          # if existing_name != wrk_item.hierarchy_scope
+          #   puts 'new hierarchy'
+          #   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}'
+          # 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.ancestor_id <> c.descendant_id
+          # and c.hierarchy_scope = '#{existing_name}'
+          # union
+          # select #{wrk_parent.descendant_id},c.descendant_id,#{wrk_parent.generation}+c.generation+1,'#{temp_name}',c.position
+          # from #{table_name} c
+          # where c.ancestor_id = #{wrk_item.descendant_id}
+          # and c.ancestor_id <> c.descendant_id
+          # and c.hierarchy_scope = '#{existing_name}'
+          # /* add existing descendants of descendants in the new tree */
+          # union
+          # select c.ancestor_id,c.descendant_id,c.generation,'#{temp_name}',c.position
+          # from #{table_name} c, #{table_name} d
+          # where c.ancestor_id = d.descendant_id
+          # and d.ancestor_id =#{wrk_item.descendant_id}
+          # and d.hierarchy_scope = c.hierarchy_scope
+          # and c.ancestor_id != c.descendant_id
+          # and c.hierarchy_scope = '#{existing_name}'
+          #   SQL
+          # else
+          sql=<<-SQL
         insert into #{table_name}(ancestor_id,descendant_id,generation,hierarchy_scope,position)
+        /* add self and descendants to the new parent */
         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}'
+
+        /* add existing descendants in the new tree */
         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
-          end
+
+          SQL
         else
           sql=<<-SQL
         insert into #{table_name}(ancestor_id,descendant_id,generation,hierarchy_scope,position)
@@ -203,25 +296,33 @@ module ActsAsManyTrees
 
       def self.rename_tree(old_name,new_name)
         sql=<<-SQL
-          update #{table_name}
+          update #{table_name} h1
           set hierarchy_scope='#{new_name}'
           where hierarchy_scope='#{old_name}'
+          and not exists(select h2.ancestor_id from #{table_name} h2
+                         where h1.ancestor_id = h2.ancestor_id
+                         and h1.descendant_id = h2.descendant_id
+                         and h2.hierarchy_scope = '#{new_name}'
+                         )
         SQL
         connection.execute(sql)
       end
 
-      def self.delete_ancestors(item,hierarchy_scope)
-        delete.where(descendant_id: item.id,hierarchy_scope: hierarchy_scope ).where.not(generation: 0)
+      def self.delete_ancestors(item,hierarchy_scope='')
+        puts "#{item.id}"
+        self.delete(descendant_id: item.id,hierarchy_scope: hierarchy_scope )
       end
 
       def self.delete_ancestors_of_item_children(item,hierarchy_scope)
         sql = <<-SQL
-    delete from #{table_name} as p using #{table_name} as p1 
+    delete from #{table_name} as p using #{table_name} as p1, #{table_name} as p2 
     where p.descendant_id = p1.descendant_id 
-    and p1.ancestor_id = #{item.descendant_id} 
+    and p.ancestor_id = p2.ancestor_id
+    and p2.descendant_id = #{item.descendant_id}
+    and p1.ancestor_id = p2.descendant_id
+    and p2.hierarchy_scope = p1.hierarchy_scope
     and p.hierarchy_scope = p1.hierarchy_scope
     and p1.hierarchy_scope = '#{hierarchy_scope}'
-    and p.generation > 0
         SQL
         connection.execute(sql)
       end

data/lib/acts_as_many_trees/version.rb

@@ -1,3 +1,3 @@
 module ActsAsManyTrees
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_many_trees
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - John Small
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-07 00:00:00.000000000 Z
+date: 2016-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails