Removed the new inserted node from the get_children call since we can…

…'t parent the inserted node to itself!

In transform added initialization kwargs t, r, s since I realized I only had reference_object in there...

Added all new tests for the insertion functions of HierarchyChain.

anvil/grouping/traversal.py

@@ -2,11 +2,11 @@
 import nomenclate.core.tools as ts
 import anvil
 import anvil.config as cfg
-import anvil.runtime as rt
 import anvil.objects as ob
 import anvil.utils.generic as gc
 import anvil.utils.scene as sc
 from anvil.log import LogMixin, obtainLogger
+import anvil.runtime as rt
 
 
 class HierarchyChain(LogMixin):
@@ -87,10 +87,11 @@ def insert_node(self, index_target, node, beneath=False, pre_hooks=None, post_ho
         if pre_hooks:
             for pre_hook in pre_hooks:
                 pre_hook()
+
         index_target = self.find_child(index_target)
         node.parent(index_target if beneath else (index_target.get_parent() or None))
-        index_target = self.find_child(index_target)
-        map(lambda node: node.parent(node), index_target.get_children() if beneath else [index_target])
+        map(lambda child_node: child_node.parent(node),
+            [c for c in index_target.get_children() if c != node] if beneath else [index_target])
 
         # If user specified the head we need to set it to the new head which is the buffer node.
         if index_target == self.head:

anvil/objects/transform.py

@@ -32,6 +32,7 @@ def get_children(self, **kwargs):
     def reset_transform(self):
         self.translate.set((0, 0, 0))
         self.rotate.set((0, 0, 0))
+        self.scale.set((1,1,1))
 
     def parent(self, new_parent):
         top_node, new_parent = self, new_parent
@@ -45,11 +46,17 @@ def parent(self, new_parent):
             raise KeyError('Node %s or %s does not exist.' % (self, new_parent))
 
     @classmethod
-    def build(cls, reference_object=None, parent=None, **kwargs):
-        node = super(Transform, cls).build(**kwargs)
-        node.parent(parent)
-        node.match_position(reference_object)
-        return node
+    def build(cls, t=None, r=None, s=None, reference_object=None, parent=None, **kwargs):
+        transform_instance = super(Transform, cls).build(**kwargs)
+        transform_instance.parent(parent)
+        if reference_object:
+            transform_instance.match_position(reference_object)
+        else:
+            transform_instance.translate_node(t)
+            transform_instance.rotate_node(r)
+            transform_instance.scale_node(s)
+
+        return transform_instance
 
     def get_world_position(self, **kwargs):
         kwargs[cfg.WORLD_SPACE] = True
@@ -119,10 +126,16 @@ def move(self, value, mode=cfg.TRANSLATE, **kwargs):
             self.rotate_node(value, **kwargs)
 
     def scale_node(self, value, **kwargs):
-        rt.dcc.scene.position(self, scale=value, **kwargs)
+        if value:
+            self._position(scale=value, **kwargs)
 
     def translate_node(self, value, **kwargs):
-        rt.dcc.scene.position(self, translation=value, **kwargs)
+        if value:
+            self._position(translation=value, **kwargs)
 
     def rotate_node(self, value, **kwargs):
-        rt.dcc.scene.position(self, rotation=value, **kwargs)
+        if value:
+            self._position(rotation=value, **kwargs)
+
+    def _position(self, **kwargs):
+        rt.dcc.scene.position(self.name(), **kwargs)

tests/test_hierarchy_chain.py

@@ -1,7 +1,7 @@
 import anvil.node_types as nt
 import anvil.runtime as rt
 import anvil
-from base_test import TestBase
+from base_test import TestBase, cleanup_nodes
 import anvil.config as cfg
 
 
@@ -179,3 +179,145 @@ def test_with_filter(self):
         chain = nt.HierarchyChain(self.joints_total[0], node_filter=filter)
         self.assertDictEqual(chain.get_level(8),
                              nt.HierarchyChain(self.joints_total[8], node_filter=filter).get_hierarchy())
+
+
+class TestHierarchyInsertNode(TestBaseHierarchyChain):
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        chain.insert_node(4, insert_me)
+        self.assertEqual(chain[4], insert_me)
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_parent_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        chain.insert_node(4, insert_me)
+        self.assertEqual(chain[3], insert_me.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_parent_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        old_parent = chain[4].get_parent()
+        chain.insert_node(4, insert_me)
+        self.assertEqual(old_parent, insert_me.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_children_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        old_index_target = chain[4]
+        chain.insert_node(4, insert_me)
+        self.assertEqual([old_index_target], insert_me.get_children())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_index_children(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        chain.insert_node(4, insert_me)
+        self.assertEqual([chain[5]], insert_me.get_children())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        chain.insert_node(4, insert_me, beneath=True)
+        self.assertEqual(chain[5], insert_me)
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_parent_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        chain.insert_node(4, insert_me, beneath=True)
+        self.assertEqual(chain[4], insert_me.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_parent_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        old_parent = chain[4].get_parent()
+        chain.insert_node(4, insert_me, beneath=True)
+        self.assertNotEqual(old_parent, insert_me.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_children_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        old_index_target_children = chain[4].get_children()
+        chain.insert_node(4, insert_me, beneath=True)
+        self.assertEqual(old_index_target_children, insert_me.get_children())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_index_children(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        insert_me = nt.Joint.build()
+        chain.insert_node(4, insert_me, beneath=True)
+        self.assertEqual([chain[6]], insert_me.get_children())
+
+
+class TestHierarchyInsertAndCreateBuffer(TestBaseHierarchyChain):
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        buffer = chain.insert_and_build_buffer(4)
+        self.assertEqual(chain[4], buffer)
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_parent_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        buffer = chain.insert_and_build_buffer(4)
+        self.assertEqual(chain[3], buffer.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_parent_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        old_parent = chain[4].get_parent()
+        buffer = chain.insert_and_build_buffer(4)
+        self.assertEqual(old_parent, buffer.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_children_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        old_index_target = chain[4]
+        buffer = chain.insert_and_build_buffer(4)
+        self.assertEqual([old_index_target], buffer.get_children())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_default_insert_check_index_children(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        buffer = chain.insert_and_build_buffer(4)
+        self.assertEqual([chain[5]], buffer.get_children())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        buffer = chain.insert_and_build_buffer(4, beneath=True)
+        self.assertEqual(chain[5], buffer)
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_parent_index(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        buffer = chain.insert_and_build_buffer(4, beneath=True)
+        self.assertEqual(chain[4], buffer.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_parent_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        old_parent = chain[4].get_parent()
+        buffer = chain.insert_and_build_buffer(4, beneath=True)
+        self.assertNotEqual(old_parent, buffer.get_parent())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_children_swap(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        old_index_target_children = chain[4].get_children()
+        buffer = chain.insert_and_build_buffer(4, beneath=True)
+        self.assertEqual(old_index_target_children, buffer.get_children())
+
+    @TestBase.delete_created_nodes
+    def test_joints_only_beneath_insert_check_index_children(self):
+        chain = nt.HierarchyChain(self.joints[0])
+        buffer = chain.insert_and_build_buffer(4, beneath=True)
+        self.assertEqual([chain[6]], buffer.get_children())