Fixes the clone behaviour so that nodes have the correct graph reference when OnEnable/Init is called during a clone operation

Scripts/Node.cs

@@ -63,6 +63,9 @@ namespace XNode {
         protected void OnEnable() {
             UpdateStaticPorts();
             Init();
+            if (graph != null && !graph.CopyInProgress) {
+                OnEnableOverride();
+            }
         }
 
         /// <summary> Update static ports to reflect class fields. This happens automatically on enable. </summary>
@@ -73,6 +76,18 @@ namespace XNode {
         /// <summary> Initialize node. Called on creation. </summary>
         protected virtual void Init() { }
 
+
+        /// <summary>
+        /// Initialize node. Called on creation and after clone in the correct order.  
+        /// </summary>
+        // Implementation note: This method is called after a node has been instantiated, and also
+        // called directly when cloning a full graph. This simply calls Init(), which cannot be
+        // called from outside, as it is protected, not public, and making it public would break
+        // existing code.
+        public virtual void OnEnableOverride() {
+            Init();
+        }
+
         /// <summary> Checks all connections for invalid references, and removes them. </summary>
         public void VerifyConnections() {
             foreach (NodePort port in Ports) port.VerifyConnections();

Scripts/NodeGraph.cs

@@ -11,6 +11,11 @@ namespace XNode {
         /// See: <see cref="AddNode{T}"/> </summary>
         [SerializeField] public List<Node> nodes = new List<Node>();
 
+        // Non serialized flag to indicate a copy operation is currently underway.
+        // This stops nodes from calling OnEnableOverride before we updated the
+        // graph reference.
+        public bool CopyInProgress { get; protected set; }
+
         /// <summary> Add a node to the graph by type </summary>
         public T AddNode<T>() where T : Node {
             return AddNode(typeof(T)) as T;
@@ -21,17 +26,25 @@ namespace XNode {
             Node node = ScriptableObject.CreateInstance(type) as Node;
             nodes.Add(node);
             node.graph = this;
+            node.OnEnableOverride();
             return node;
         }
 
         /// <summary> Creates a copy of the original node in the graph </summary>
         public virtual Node CopyNode(Node original) {
+            this.CopyInProgress = true;
+            try {
                 Node node = ScriptableObject.Instantiate(original);
                 node.ClearConnections();
                 nodes.Add(node);
                 node.graph = this;
+                node.OnEnableOverride();
                 return node;
             }
+            finally {
+                this.CopyInProgress = false;
+            }
+        }
 
         /// <summary> Safely remove a node and all its connections </summary>
         /// <param name="node"> The node to remove </param>
@@ -55,6 +68,8 @@ namespace XNode {
         public XNode.NodeGraph Copy() {
             // Instantiate a new nodegraph instance
             NodeGraph graph = Instantiate(this);
+            graph.CopyInProgress = true;
+            try {
                 // Instantiate all nodes inside the graph
                 for (int i = 0; i < nodes.Count; i++) {
                     if (nodes[i] == null) continue;
@@ -71,6 +86,18 @@ namespace XNode {
                     }
                 }
                 
+                // Call the Enable notifier, which was not fired during the
+                // normal instantiation.
+                for (int i = 0; i < graph.nodes.Count; i++) {
+                    var node = graph.nodes[i];
+                    if (node == null) continue;
+                    node.OnEnableOverride();
+                }
+            }
+            finally {
+                graph.CopyInProgress = false;
+            }
+
             return graph;
         }