From 4e0ce5cf4cb2bf57f3502d732ccc8db7e3a956fa Mon Sep 17 00:00:00 2001
From: Philipp Schillinger <philsplus@gmail.com>
Date: Sun, 17 Dec 2017 11:35:20 +0100
Subject: [PATCH] Update states when source code changes (see #10)

---
 src/_model/state.js        | 143 +++++++++++++++++++++++++++++++++++--
 src/_model/statemachine.js |  15 ++++
 src/events.js              |   1 +
 src/io/io_packageparser.js |  60 +++++++++++-----
 src/prototype.js           |   5 ++
 5 files changed, 200 insertions(+), 24 deletions(-)

diff --git a/src/_model/state.js b/src/_model/state.js
index 75a612e..560a521 100644
--- a/src/_model/state.js
+++ b/src/_model/state.js
@@ -130,6 +130,9 @@ State = function(state_name, state_def) {
 		resolved_parameter_output_values_old = resolved_parameter_output_values;
 	}
 
+	var noMetaFilter = function(element) { return element[0] != '$'; };
+	var metaFilter = function(element) { return element[0] == '$'; };
+
 	var state_name = state_name;
 	var state_class = state_def.getStateClass();
 	var state_import = state_def.getStatePath();
@@ -139,22 +142,22 @@ State = function(state_name, state_def) {
 	var parameters = state_def.getParameters().clone();
 	var parameter_values = state_def.getDefaultParameterValues().clone();
 
-	var outcomes = state_def.getOutcomes().filter(function(element) { return element[0] != '$'; });
+	var outcomes = state_def.getOutcomes().filter(noMetaFilter);
 	var autonomy = state_def.getDefaultAutonomy().clone();
 
-	var meta_outcomes = state_def.getOutcomes().filter(function(element) { return element[0] == '$'; });
+	var meta_outcomes = state_def.getOutcomes().filter(metaFilter);
 	for (var i=0; i<meta_outcomes.length; ++i) meta_outcomes[i] = meta_outcomes[i].slice(1, meta_outcomes[i].length);
 
 	var outcomes_unc = outcomes.clone();
 	var outcomes_con = [];
 
-	var input_keys = state_def.getInputKeys().filter(function(element) { return element[0] != '$'; });
-	var output_keys = state_def.getOutputKeys().filter(function(element) { return element[0] != '$'; });
+	var input_keys = state_def.getInputKeys().filter(noMetaFilter);
+	var output_keys = state_def.getOutputKeys().filter(noMetaFilter);
 
-	var meta_input = state_def.getInputKeys().filter(function(element) { return element[0] == '$'; });
+	var meta_input = state_def.getInputKeys().filter(metaFilter);
 	for (var i=0; i<meta_input.length; ++i) meta_input[i] = meta_input[i].slice(1, meta_input[i].length);
 
-	var meta_output = state_def.getOutputKeys().filter(function(element) { return element[0] == '$'; });
+	var meta_output = state_def.getOutputKeys().filter(metaFilter);
 	for (var i=0; i<meta_output.length; ++i) meta_output[i] = meta_output[i].slice(1, meta_output[i].length);
 
 	var input_mapping = [];
@@ -357,4 +360,132 @@ State = function(state_name, state_def) {
 		return behavior;
 	}
 
+	this.updateStateDefinition = function(new_def) {
+		state_class = new_def.getStateClass();
+		state_import = new_def.getStatePath();
+		state_pkg = new_def.getStatePackage();
+
+		var updateKeys = function(old_keys, new_keys, old_values, new_values) {
+			var result = {keys: [], values: []};
+			for (var i=0; i<new_keys.length; i++) {
+				var j = old_keys.indexOf(new_keys[i]);
+				if (j != -1) {
+					result.keys.push(old_keys[j]);
+					result.values.push(old_values[j]);
+				} else {
+					result.keys.push(new_keys[i]);
+					result.values.push(new_values[i]);
+				}
+			}
+			return result;
+		}
+
+		// required for meta
+		var old_params = parameters;
+
+		if (!parameters.hasSameElements(new_def.getParameters())) {
+			var result = updateKeys(parameters, new_def.getParameters(), parameter_values, new_def.getDefaultParameterValues());
+			parameters = result.keys;
+			parameter_values = result.values;
+		}
+
+		if (!outcomes.hasSameElements(new_def.getOutcomes().filter(noMetaFilter))) {
+			var old_outcomes = outcomes;
+			var result = updateKeys(outcomes, new_def.getOutcomes().filter(noMetaFilter), autonomy, new_def.getDefaultAutonomy());
+			outcomes = result.keys;
+			autonomy = result.values;
+			for (var i=0; i<outcomes.length; i++) {
+				if (!old_outcomes.contains(outcomes[i])) {
+					outcomes_unc.push(outcomes[i]);
+				}
+			}
+			for (var i=0; i<old_outcomes.length; i++) {
+				if (!outcomes.contains(old_outcomes[i])) {
+					if (outcomes_con.contains(old_outcomes[i])) {
+						if (container != undefined) {
+							container.removeTransitionFrom(that, old_outcomes[i]);
+						}
+						outcomes_con.remove(old_outcomes[i]);
+					} else {
+						outcomes_unc.remove(old_outcomes[i]);
+					}
+				}
+			}
+		}
+
+		var new_meta_outcomes = new_def.getOutcomes().filter(metaFilter);
+		for (var i=0; i<new_meta_outcomes.length; ++i) new_meta_outcomes[i] = new_meta_outcomes[i].slice(1, new_meta_outcomes[i].length);
+		if (!meta_outcomes.hasSameElements(new_meta_outcomes)) {
+			for (var i=0; i<meta_outcomes.length; i++) {
+				if (!new_meta_outcomes.contains(meta_outcomes[i])) {
+					var pidx = old_params.indexOf(meta_outcomes[i]);
+					var remove_list = resolved_parameter_outcome_values_old[i];
+					remove_list.forEach(function(element) {
+						var idx = outcomes.indexOf(element);
+						outcomes.splice(idx, 1);
+						autonomy.splice(idx, 1);
+						if (outcomes_unc.contains(element)) {
+							outcomes_unc.remove(element);
+						} else if (outcomes_con.contains(element)) {
+							outcomes_con.remove(element);
+							if (container != undefined) {
+								container.removeTransitionFrom(that, element);
+							}
+						}
+					});
+				}
+			}
+			meta_outcomes = new_meta_outcomes;
+			updateGeneratedOutcomes(parameter_values);
+		}
+
+		if (!input_keys.hasSameElements(new_def.getInputKeys().filter(noMetaFilter))) {
+			var result = updateKeys(input_keys, new_def.getInputKeys().filter(noMetaFilter), input_mapping, new_def.getInputKeys().filter(noMetaFilter));
+			input_keys = result.keys;
+			input_mapping = result.values;
+		}
+
+		var new_meta_input = new_def.getInputKeys().filter(metaFilter);
+		for (var i=0; i<new_meta_input.length; ++i) new_meta_input[i] = new_meta_input[i].slice(1, new_meta_input[i].length);
+		if (!meta_input.hasSameElements(new_meta_input)) {
+			for (var i=0; i<meta_input.length; i++) {
+				if (!new_meta_input.contains(meta_input[i])) {
+					var pidx = old_params.indexOf(meta_input[i]);
+					var remove_list = resolved_parameter_input_values_old[i];
+					remove_list.forEach(function(element) {
+						var idx = input_keys.indexOf(element);
+						input_keys.splice(idx, 1);
+						input_mapping.splice(idx, 1);
+					});
+				}
+			}
+			meta_input = new_meta_input;
+			updateGeneratedInput(parameter_values);
+		}
+
+		if (!output_keys.hasSameElements(new_def.getOutputKeys().filter(noMetaFilter))) {
+			var result = updateKeys(output_keys, new_def.getOutputKeys().filter(noMetaFilter), output_mapping, new_def.getOutputKeys().filter(noMetaFilter));
+			output_keys = result.keys;
+			output_mapping = result.values;
+		}
+
+		var new_meta_output = new_def.getOutputKeys().filter(metaFilter);
+		for (var i=0; i<new_meta_output.length; ++i) new_meta_output[i] = new_meta_output[i].slice(1, new_meta_output[i].length);
+		if (!meta_output.hasSameElements(new_meta_output)) {
+			for (var i=0; i<meta_output.length; i++) {
+				if (!new_meta_output.contains(meta_output[i])) {
+					var pidx = old_params.indexOf(meta_output[i]);
+					var remove_list = resolved_parameter_output_values_old[i];
+					remove_list.forEach(function(element) {
+						var idx = output_keys.indexOf(element);
+						output_keys.splice(idx, 1);
+						output_mapping.splice(idx, 1);
+					});
+				}
+			}
+			meta_output = new_meta_output;
+			updateGeneratedOutput(parameter_values);
+		}
+	}
+
 };
\ No newline at end of file
diff --git a/src/_model/statemachine.js b/src/_model/statemachine.js
index ceaf522..c29591c 100644
--- a/src/_model/statemachine.js
+++ b/src/_model/statemachine.js
@@ -74,6 +74,21 @@ Statemachine = function(sm_name, sm_definition) {
 		}
 		return child.getStateByPath(path.slice(that.getStateName().length + 1));
 	}
+	this.traverseStates = function(_filter) {
+		var result = [];
+		for(var i=0; i<states.length; ++i) {
+			if (states[i] instanceof Statemachine) {
+				result = result.concat(states[i].traverseStates(_filter));
+				continue;
+			} else if (states[i] instanceof BehaviorState) {
+				continue;
+			}
+			if (_filter(states[i])) {
+				result.push(states[i]);
+			}
+		}
+		return result;
+	}
 
 	this.addState = function(state) {
 		states.push(state);
diff --git a/src/events.js b/src/events.js
index 6ecd912..30b4116 100644
--- a/src/events.js
+++ b/src/events.js
@@ -172,6 +172,7 @@ document.addEventListener('DOMContentLoaded', function() {
     process.on('exit', (code) => {
         RC.PubSub.shutdown();
         ROS.shutdown();
+        IO.PackageParser.stopWatching();
     });
 
     nw.App.on('open', () => {
diff --git a/src/io/io_packageparser.js b/src/io/io_packageparser.js
index 2f1b125..e588b53 100644
--- a/src/io/io_packageparser.js
+++ b/src/io/io_packageparser.js
@@ -38,6 +38,12 @@ IO.PackageParser = new (function() {
 		});
 	}
 
+	this.stopWatching = function() {
+		for (var state in watched_states) {
+			watched_states[state].close();
+		}
+	}
+
 	var checkForRelevance = function(pkg_path, callback) {
 		var data = fs.readFileSync(path.join(pkg_path, 'package.xml'));
 		var xml = dom_parser.parseFromString(String(data), "text/xml");
@@ -51,24 +57,42 @@ IO.PackageParser = new (function() {
 	var watchStateFolder = function(folder_path, import_path) {
 		if (watched_states[folder_path] != undefined) return;
 
-		// watched_states[folder_path] = fs.watch(folder_path,
-		// 	{persistent: false},
-		// 	(eventType, filename) => {
-		// 		if (eventType == 'change') {
-		// 			var entry = path.join(folder_path, filename);
-		// 			IO.Filesystem.readFile(entry, (content) => {
-		// 				var imports = entry.replace(import_path+"/", "").replace(/.py$/i, "").replace(/[\/]/g, ".");
-		// 				var state_def = IO.StateParser.parseState(content, imports);
-		// 				if (state_def != undefined) {
-		// 					state_def.setFilePath(entry);
-		// 					WS.Statelib.updateDef(state_def);
-		// 					T.logInfo("Updating changed definition for state: " + state_def.getStateClass());
-		// 					// TODO update defs for existing states and re-draw
-		// 				}
-		// 			});
-		// 		}
-		// 	}
-		// );
+		watched_states[folder_path] = fs.watch(folder_path,
+			{persistent: false},
+			(eventType, filename) => {
+				if(RC.Controller.isReadonly()) {
+					T.logWarn("A state definition source file changed while in read-only mode, ignoring the change for now!");
+					return;
+				}
+				if (eventType == 'change') {
+					var entry = path.join(folder_path, filename);
+					IO.Filesystem.readFile(entry, (content) => {
+						var imports = entry.replace(import_path+"/", "").replace(/.py$/i, "").replace(/[\/]/g, ".");
+						var state_def = IO.StateParser.parseState(content, imports);
+						if (state_def != undefined) {
+							state_def.setFilePath(entry);
+							WS.Statelib.updateDef(state_def);
+							T.logInfo("Updating changed definition for state: " + state_def.getStateClass());
+							var update_states = Behavior.getStatemachine().traverseStates(function(state) {
+								return state.getStateClass() == state_def.getStateClass();
+							});
+							update_states.forEach(function (state) {
+								state.updateStateDefinition(state_def);
+								if (state.getContainer() == UI.Statemachine.getDisplayedSM() 
+									&& UI.Panels.StateProperties.isCurrentState(state)) {
+									UI.Panels.StateProperties.hide();
+									UI.Panels.StateProperties.displayStateProperties(state);
+								}
+							});
+							if (UI.Menu.isPageStatemachine()) {
+								UI.Statemachine.refreshView();
+							}
+							RC.Controller.signalChanged();
+						}
+					});
+				}
+			}
+		);
 	}
 
 	this.parseStateFolder = function(folder, import_path, has_init) {
diff --git a/src/prototype.js b/src/prototype.js
index 66ff5dd..b88a91f 100644
--- a/src/prototype.js
+++ b/src/prototype.js
@@ -33,6 +33,11 @@ Array.prototype.contains = function(element) {
 	return this.indexOf(element) != -1;
 }
 
+Array.prototype.hasSameElements = function(other) {
+	var diff = this.filter(el => !other.contains(el));
+	return 0 == diff.concat(other.filter(el => !this.contains(el))).length;
+}
+
 
 //=====================
 //	String