From b749a27f864869eab519ef3f61165a8021bda37d Mon Sep 17 00:00:00 2001
From: Kunihiko Toumura <kunihiko.toumura.yv@hitachi.com>
Date: Mon, 5 Aug 2019 10:20:46 +0900
Subject: [PATCH] Eliminate snake_case and use camelCase, and change assignment
 of keyboard shortcut

---
 .../@node-red/editor-client/src/js/history.js | 186 +++++++++---------
 .../editor-client/src/js/keymap.json          |   6 +-
 2 files changed, 93 insertions(+), 99 deletions(-)

diff --git a/packages/node_modules/@node-red/editor-client/src/js/history.js b/packages/node_modules/@node-red/editor-client/src/js/history.js
index d8a3ae1e7..c015716c2 100644
--- a/packages/node_modules/@node-red/editor-client/src/js/history.js
+++ b/packages/node_modules/@node-red/editor-client/src/js/history.js
@@ -14,8 +14,8 @@
  * limitations under the License.
  **/
 RED.history = (function() {
-    var undo_history = [];
-    var redo_history = [];
+    var undoHistory = [];
+    var redoHistory = [];
 
     function undoEvent(ev) {
         var i;
@@ -23,20 +23,20 @@ RED.history = (function() {
         var node;
         var subflow;
         var modifiedTabs = {};
-        var inv_ev;
+        var inverseEv;
         if (ev) {
             if (ev.t == 'multi') {
-                inv_ev = {
+                inverseEv = {
                     t: 'multi',
                     events: []
                 };                
                 len = ev.events.length;
                 for (i=len-1;i>=0;i--) {
                     var r = undoEvent(ev.events[i]);
-                    inv_ev.events.push(r);
+                    inverseEv.events.push(r);
                 }
             } else if (ev.t == 'replace') {
-                inv_ev = {
+                inverseEv = {
                     t: 'replace',
                     config: RED.nodes.createCompleteNodeSet(),
                     changed: [],
@@ -47,57 +47,57 @@ RED.history = (function() {
                 imported[0].forEach(function(n) {
                     if (ev.changed[n.id]) {
                         n.changed = true;
-                        inv_ev.changed[n.id] = true;
+                        inverseEv.changed[n.id] = true;
                     }
                 })
 
                 RED.nodes.version(ev.rev);
             } else if (ev.t == 'add') {
-                inv_ev = {
+                inverseEv = {
                     t: "delete",
                 };
                 if (ev.nodes) {
-                    inv_ev.nodes = [];
+                    inverseEv.nodes = [];
                     for (i=0;i<ev.nodes.length;i++) {
                         node = RED.nodes.node(ev.nodes[i]);
                         if (node.z) {
                             modifiedTabs[node.z] = true;
                         }
-                        inv_ev.nodes.push(node);
+                        inverseEv.nodes.push(node);
                         RED.nodes.remove(ev.nodes[i]);
                     }
                 }
                 if (ev.links) {
-                    inv_ev.links = [];
+                    inverseEv.links = [];
                     for (i=0;i<ev.links.length;i++) {
-                        inv_ev.links.push(ev.links[i]);
+                        inverseEv.links.push(ev.links[i]);
                         RED.nodes.removeLink(ev.links[i]);
                     }
                 }
                 if (ev.workspaces) {
-                    inv_ev.workspaces = [];
+                    inverseEv.workspaces = [];
                     for (i=0;i<ev.workspaces.length;i++) {
                         var workspaceOrder = RED.nodes.getWorkspaceOrder();
                         ev.workspaces[i]._index = workspaceOrder.indexOf(ev.workspaces[i].id);
-                        inv_ev.workspaces.push(ev.workspaces[i]);
+                        inverseEv.workspaces.push(ev.workspaces[i]);
                         RED.nodes.removeWorkspace(ev.workspaces[i].id);
                         RED.workspaces.remove(ev.workspaces[i]);
                     }
                 }
                 if (ev.subflows) {
-                    inv_ev.subflows = [];
+                    inverseEv.subflows = [];
                     for (i=0;i<ev.subflows.length;i++) {
-                        inv_ev.subflows.push(ev.subflows[i]);
+                        inverseEv.subflows.push(ev.subflows[i]);
                         RED.nodes.removeSubflow(ev.subflows[i]);
                         RED.workspaces.remove(ev.subflows[i]);
                     }
                 }
                 if (ev.subflow) {
-                    inv_ev.subflow = {};
+                    inverseEv.subflow = {};
                     if (ev.subflow.instances) {
-                        inv_ev.subflow.instances = [];
+                        inverseEv.subflow.instances = [];
                         ev.subflow.instances.forEach(function(n) {
-                            inv_ev.subflow.instances.push(n);
+                            inverseEv.subflow.instances.push(n);
                             var node = RED.nodes.node(n.id);
                             if (node) {
                                 node.changed = n.changed;
@@ -113,30 +113,30 @@ RED.history = (function() {
                     }
                 }
                 if (ev.removedLinks) {
-                    inv_ev.createdLinks = [];
+                    inverseEv.createdLinks = [];
                     for (i=0;i<ev.removedLinks.length;i++) {
-                        inv_ev.createdLinks.push(ev.removedLinks[i]);
+                        inverseEv.createdLinks.push(ev.removedLinks[i]);
                         RED.nodes.addLink(ev.removedLinks[i]);
                     }
                 }
 
             } else if (ev.t == "delete") {
-                inv_ev = {
+                inverseEv = {
                     t: "add"
                 };
                 if (ev.workspaces) {
-                    inv_ev.workspaces = [];
+                    inverseEv.workspaces = [];
                     for (i=0;i<ev.workspaces.length;i++) {
-                        inv_ev.workspaces.push(ev.workspaces[i]);
+                        inverseEv.workspaces.push(ev.workspaces[i]);
                         RED.nodes.addWorkspace(ev.workspaces[i],ev.workspaces[i]._index);
                         RED.workspaces.add(ev.workspaces[i],undefined,ev.workspaces[i]._index);
                         delete ev.workspaces[i]._index;
                     }
                 }
                 if (ev.subflows) {
-                    inv_ev.subflows = [];
+                    inverseEv.subflows = [];
                     for (i=0;i<ev.subflows.length;i++) {
-                        inv_ev.subflows.push(ev.subflows[i]);
+                        inverseEv.subflows.push(ev.subflows[i]);
                         RED.nodes.addSubflow(ev.subflows[i]);
                     }
                 }
@@ -165,11 +165,11 @@ RED.history = (function() {
                     }
                 }
                 if (ev.subflow) {
-                    inv_ev.subflow = {};
+                    inverseEv.subflow = {};
                     if (ev.subflow.hasOwnProperty('instances')) {
-                        inv_ev.subflow.instances = [];
+                        inverseEv.subflow.instances = [];
                         ev.subflow.instances.forEach(function(n) {
-                            inv_ev.subflow.instances.push(n);
+                            inverseEv.subflow.instances.push(n);
                             var node = RED.nodes.node(n.id);
                             if (node) {
                                 node.changed = n.changed;
@@ -194,24 +194,24 @@ RED.history = (function() {
                     });
                 }
                 if (ev.nodes) {
-                    inv_ev.nodes = [];
+                    inverseEv.nodes = [];
                     for (i=0;i<ev.nodes.length;i++) {
                         RED.nodes.add(ev.nodes[i]);
                         modifiedTabs[ev.nodes[i].z] = true;
-                        inv_ev.nodes.push(ev.nodes[i].id);
+                        inverseEv.nodes.push(ev.nodes[i].id);
                     }
                 }
                 if (ev.links) {
-                    inv_ev.links = [];
+                    inverseEv.links = [];
                     for (i=0;i<ev.links.length;i++) {
                         RED.nodes.addLink(ev.links[i]);
-                        inv_ev.links.push(ev.links[i]);
+                        inverseEv.links.push(ev.links[i]);
                     }
                 }
                 if (ev.createdLinks) {
-                    inv_ev.removedLinks = [];
+                    inverseEv.removedLinks = [];
                     for (i=0;i<ev.createdLinks.length;i++) {
-                        inv_ev.removedLinks.push(ev.createdLinks[i]);
+                        inverseEv.removedLinks.push(ev.createdLinks[i]);
                         RED.nodes.removeLink(ev.createdLinks[i]);
                     }
                 }
@@ -232,14 +232,14 @@ RED.history = (function() {
 
                 }
             } else if (ev.t == "move") {
-                inv_ev = {
+                inverseEv = {
                     t: 'move',
                     nodes: []
                 };
                 for (i=0;i<ev.nodes.length;i++) {
                     var n = ev.nodes[i];
                     var rn = {n: n.n, ox: n.n.x, oy: n.n.y, dirty: true, moved: n.moved};
-                    inv_ev.nodes.push(rn);
+                    inverseEv.nodes.push(rn);
                     n.n.x = n.ox;
                     n.n.y = n.oy;
                     n.n.dirty = true;
@@ -247,28 +247,28 @@ RED.history = (function() {
                 }
                 // A move could have caused a link splice
                 if (ev.links) {
-                    inv_ev.removedLinks = [];
+                    inverseEv.removedLinks = [];
                     for (i=0;i<ev.links.length;i++) {
-                        inv_ev.removedLinks.push(ev.links[i]);
+                        inverseEv.removedLinks.push(ev.links[i]);
                         RED.nodes.removeLink(ev.links[i]);
                     }
                 }
                 if (ev.removedLinks) {
-                    inv_ev.links = [];
+                    inverseEv.links = [];
                     for (i=0;i<ev.removedLinks.length;i++) {
-                        inv_ev.links.push(ev.removedLinks[i]);
+                        inverseEv.links.push(ev.removedLinks[i]);
                         RED.nodes.addLink(ev.removedLinks[i]);
                     }
                 }
             } else if (ev.t == "edit") {
-                inv_ev = {
+                inverseEv = {
                     t: "edit",
                     changes: {}
                 };
-                inv_ev.node = ev.node;
+                inverseEv.node = ev.node;
                 for (i in ev.changes) {
                     if (ev.changes.hasOwnProperty(i)) {
-                        inv_ev.changes[i] = ev.node[i];
+                        inverseEv.changes[i] = ev.node[i];
                         if (ev.node._def.defaults && ev.node._def.defaults[i] && ev.node._def.defaults[i].type) {
                             // This is a config node property
                             var currentConfigNode = RED.nodes.node(ev.node[i]);
@@ -288,29 +288,29 @@ RED.history = (function() {
                     $("#red-ui-workspace").toggleClass("red-ui-workspace-disabled",!!ev.node.disabled);
                 }
                 if (ev.subflow) {
-                    inv_ev.subflow = {};
+                    inverseEv.subflow = {};
                     if (ev.subflow.hasOwnProperty('inputCount')) {
-                        inv_ev.subflow.inputCount = ev.node.in.length;
+                        inverseEv.subflow.inputCount = ev.node.in.length;
                         if (ev.node.in.length > ev.subflow.inputCount) {
-                            inv_ev.subflow.inputs = ev.node.in.slice(ev.subflow.inputCount);
+                            inverseEv.subflow.inputs = ev.node.in.slice(ev.subflow.inputCount);
                             ev.node.in.splice(ev.subflow.inputCount);
                         } else if (ev.subflow.inputs.length > 0) {
                             ev.node.in = ev.node.in.concat(ev.subflow.inputs);
                         }
                     }
                     if (ev.subflow.hasOwnProperty('outputCount')) {
-                        inv_ev.subflow.outputCount = ev.node.out.length;
+                        inverseEv.subflow.outputCount = ev.node.out.length;
                         if (ev.node.out.length > ev.subflow.outputCount) {
-                            inv_ev.subflow.outputs = ev.node.out.slice(ev.subflow.outputCount);
+                            inverseEv.subflow.outputs = ev.node.out.slice(ev.subflow.outputCount);
                             ev.node.out.splice(ev.subflow.outputCount);
                         } else if (ev.subflow.outputs.length > 0) {
                             ev.node.out = ev.node.out.concat(ev.subflow.outputs);
                         }
                     }
                     if (ev.subflow.hasOwnProperty('instances')) {
-                        inv_ev.subflow.instances = [];
+                        inverseEv.subflow.instances = [];
                         ev.subflow.instances.forEach(function(n) {
-                            inv_ev.subflow.instances.push(n);
+                            inverseEv.subflow.instances.push(n);
                             var node = RED.nodes.node(n.id);
                             if (node) {
                                 node.changed = n.changed;
@@ -334,11 +334,11 @@ RED.history = (function() {
                     var outputMap;
                     if (ev.outputMap) {
                         outputMap = {};
-                        inv_ev.outputMap = {};
+                        inverseEv.outputMap = {};
                         for (var port in ev.outputMap) {
                             if (ev.outputMap.hasOwnProperty(port) && ev.outputMap[port] !== "-1") {
                                 outputMap[ev.outputMap[port]] = port;
-                                inv_ev.outputMap[ev.outputMap[port]] = port;
+                                inverseEv.outputMap[ev.outputMap[port]] = port;
                             }
                         }
                     }
@@ -346,84 +346,78 @@ RED.history = (function() {
                     RED.editor.validateNode(ev.node);
                 }
                 if (ev.links) {
-                    inv_ev.createdLinks = [];
+                    inverseEv.createdLinks = [];
                     for (i=0;i<ev.links.length;i++) {
                         RED.nodes.addLink(ev.links[i]);
-                        inv_ev.createdLinks.push(ev.links[i]);
+                        inverseEv.createdLinks.push(ev.links[i]);
                     }
                 }
                 if (ev.createdLinks) {
-                    inv_ev.links = [];
+                    inverseEv.links = [];
                     for (i=0;i<ev.createdLinks.length;i++) {
                         RED.nodes.removeLink(ev.createdLinks[i]);
-                        inv_ev.links.push(ev.createdLinks[i]);
+                        inverseEv.links.push(ev.createdLinks[i]);
                     }
                 }
                 ev.node.dirty = true;
                 ev.node.changed = ev.changed;
             } else if (ev.t == "createSubflow") {
-                inv_ev = {
+                inverseEv = {
                     t: "deleteSubflow",
                     activeWorkspace: ev.activeWorkspace,
                     dirty: RED.nodes.dirty()
                 };
                 if (ev.nodes) {
-<<<<<<< HEAD
-                    inv_ev.movedNodes = [];
-=======
+                    inverseEv.movedNodes = [];
                     var z = ev.activeWorkspace;
->>>>>>> upstream/dev
                     RED.nodes.filterNodes({z:ev.subflow.subflow.id}).forEach(function(n) {
                         n.x += ev.subflow.offsetX;
                         n.y += ev.subflow.offsetY;
                         n.z = ev.activeWorkspace;
                         n.dirty = true;
-<<<<<<< HEAD
-                        inv_ev.movedNodes.push(n.id);
-=======
+                        inverseEv.movedNodes.push(n.id);
                         RED.nodes.moveNodeToTab(n, z);
->>>>>>> upstream/dev
                     });
-                    inv_ev.subflows = [];
+                    inverseEv.subflows = [];
                     for (i=0;i<ev.nodes.length;i++) {
-                        inv_ev.subflows.push(RED.nodes.node(ev.nodes[i]));
+                        inverseEv.subflows.push(RED.nodes.node(ev.nodes[i]));
                         RED.nodes.remove(ev.nodes[i]);
                     }
                 }
                 if (ev.links) {
-                    inv_ev.links = [];
+                    inverseEv.links = [];
                     for (i=0;i<ev.links.length;i++) {
-                        inv_ev.links.push(ev.links[i]);
+                        inverseEv.links.push(ev.links[i]);
                         RED.nodes.removeLink(ev.links[i]);
                     }
                 }
 
-                inv_ev.subflow = ev.subflow;
+                inverseEv.subflow = ev.subflow;
                 RED.nodes.removeSubflow(ev.subflow.subflow);
                 RED.workspaces.remove(ev.subflow.subflow);
 
                 if (ev.removedLinks) {
-                    inv_ev.createdLinks = [];
+                    inverseEv.createdLinks = [];
                     for (i=0;i<ev.removedLinks.length;i++) {
-                        inv_ev.createdLinks.push(ev.removedLinks[i]);
+                        inverseEv.createdLinks.push(ev.removedLinks[i]);
                         RED.nodes.addLink(ev.removedLinks[i]);
                     }
                 }
             } else if (ev.t == "deleteSubflow") {
-                inv_ev = {
+                inverseEv = {
                     t: "createSubflow",
                     activeWorkspace: ev.activeWorkspace,
                     ditry: RED.nodes.dirty(),
                 };
                 if (ev.subflow) {
                     RED.nodes.addSubflow(ev.subflow.subflow);
-                    inv_ev.subflow = ev.subflow;
+                    inverseEv.subflow = ev.subflow;
                 }
                 if (ev.subflows) {
-                    inv_ev.nodes = [];
+                    inverseEv.nodes = [];
                     for (i=0;i<ev.subflows.length;i++) {
                         RED.nodes.add(ev.subflows[i]);
-                        inv_ev.nodes.push(ev.subflows[i].id);
+                        inverseEv.nodes.push(ev.subflows[i].id);
                     }
                 }
                 if (ev.movedNodes) {
@@ -436,21 +430,21 @@ RED.history = (function() {
                     });
                 }
                 if (ev.links) {
-                    inv_ev.links = [];
+                    inverseEv.links = [];
                     for (i=0;i<ev.links.length;i++) {
-                        inv_ev.links.push(ev.links[i]);
+                        inverseEv.links.push(ev.links[i]);
                         RED.nodes.addLink(ev.links[i]);
                     }
                 }
                 if  (ev.createdLinks) {
-                    inv_ev.removedLinks = [];
+                    inverseEv.removedLinks = [];
                     for (i=0;i<ev.createdLinks.length;i++) {
-                        inv_ev.removedLinks.push(ev.createdLinks[i]);
+                        inverseEv.removedLinks.push(ev.createdLinks[i]);
                         RED.nodes.removeLink(ev.createdLinks[i]);
                     }
                 }
             } else if (ev.t == "reorder") {
-                inv_ev = {
+                inverseEv = {
                     t: 'reorder',
                     order: RED.nodes.getWorkspaceOrder()
                 };                
@@ -474,7 +468,7 @@ RED.history = (function() {
             RED.sidebar.config.refresh();
             RED.subflow.refresh();
 
-            return inv_ev;
+            return inverseEv;
         }
 
     }
@@ -482,40 +476,40 @@ RED.history = (function() {
     return {
         //TODO: this function is a placeholder until there is a 'save' event that can be listened to
         markAllDirty: function() {
-            for (var i=0;i<undo_history.length;i++) {
-                undo_history[i].dirty = true;
+            for (var i=0;i<undoHistory.length;i++) {
+                undoHistory[i].dirty = true;
             }
         },
         list: function() {
-            return undo_history;
+            return undoHistory;
         },
         depth: function() {
-            return undo_history.length;
+            return undoHistory.length;
         },
         push: function(ev) {
-            undo_history.push(ev);
-            redo_history = [];
+            undoHistory.push(ev);
+            redoHistory = [];
         },
         pop: function() {
-            var ev = undo_history.pop();
+            var ev = undoHistory.pop();
             var rev = undoEvent(ev);
             if (rev) {
-                redo_history.push(rev);
+                redoHistory.push(rev);
             }
         },
         peek: function() {
-            return undo_history[undo_history.length-1];
+            return undoHistory[undoHistory.length-1];
         },
         clear: function() {
-            undo_history = [];
-            redo_history = [];
+            undoHistory = [];
+            redoHistory = [];
         },
         redo: function() {
-            var ev = redo_history.pop();
+            var ev = redoHistory.pop();
             if (ev) {
                 var uev = undoEvent(ev);
                 if (uev) {
-                    undo_history.push(uev);
+                    undoHistory.push(uev);
                 }
             }
         }
diff --git a/packages/node_modules/@node-red/editor-client/src/js/keymap.json b/packages/node_modules/@node-red/editor-client/src/js/keymap.json
index 870cc89e6..2677321b7 100644
--- a/packages/node_modules/@node-red/editor-client/src/js/keymap.json
+++ b/packages/node_modules/@node-red/editor-client/src/js/keymap.json
@@ -31,7 +31,7 @@
         "delete": "core:delete-config-selection",
         "ctrl-a": "core:select-all-config-nodes",
         "ctrl-z": "core:undo",
-        "ctrl-shift-z": "core:redo"
+        "ctrl-y": "core:redo"
     },
     "red-ui-workspace": {
         "backspace": "core:delete-selection",
@@ -41,6 +41,7 @@
         "ctrl-x": "core:cut-selection-to-internal-clipboard",
         "ctrl-v": "core:paste-from-internal-clipboard",
         "ctrl-z": "core:undo",
+        "ctrl-y": "core:redo",
         "ctrl-a": "core:select-all-nodes",
         "shift-?": "core:show-help",
         "up": "core:move-selection-up",
@@ -52,7 +53,6 @@
         "shift-down": "core:step-selection-down",
         "shift-left": "core:step-selection-left",
         "ctrl-shift-j": "core:show-previous-tab",
-        "ctrl-shift-k": "core:show-next-tab",
-        "ctrl-shift-z": "core:redo"
+        "ctrl-shift-k": "core:show-next-tab"
      }
 }