gdharness 0.5.7 → 0.5.9

package/build/godot/addons/gdharness_editor/bridge_client.gd

@@ -11,21 +11,57 @@ signal tool_requested(request_id: String, tool_name: String, args: Dictionary)
 const DEFAULT_URL: String = "ws://127.0.0.1:6505/godot"
 ## Written beside the addon by the install, so it names the version this copy came from.
 const VERSION_MARKER: String = "res://addons/gdharness_editor/.gdharness-version"
+## Written by the server that serves this project, saying where its bridge actually is. Kept in
+## step with `announcementPath` in src/bridge-announce.ts.
+const ANNOUNCEMENT: String = "res://.godot/gdharness-bridge.json"
+const ANNOUNCE_PROTOCOL: int = 1
 const RECONNECT_DELAY: float = 3.0
 const MAX_RECONNECT_DELAY: float = 30.0
 
+## How long one attempt is given before the address is called a bad one.
+##
+## A socket pointed at a port nothing holds gives up by itself, in thirty seconds on Windows. One
+## pointed at something that accepts and then never speaks WebSocket does not give up at all:
+## measured here, still connecting after forty-five seconds, because the peer has no handshake
+## timeout of its own in 4.7. A leftover announcement can be either, and a port that has been
+## reused by some other program is the second.
+const CONNECT_TIMEOUT: float = 10.0
+
+## How often the announcement is read again while connected, so a newer server is moved to
+## rather than waited for. A harness reconnect leaves the server it replaced running and holding
+## the old port, and an editor with no reason to look elsewhere stayed on it for the session.
+const FOLLOW_INTERVAL: float = 5.0
+
 var socket: WebSocketPeer = WebSocketPeer.new()
 var server_url: String = DEFAULT_URL
+
+## What this copy was when it loaded, which is what the editor is running until it is restarted.
+## See [method _loaded_version] for why it is held rather than read when it is wanted.
+var version_at_load: String = ""
+
 var _is_connected: bool = false
 var _reconnect_timer: Timer
 var _current_reconnect_delay: float = RECONNECT_DELAY
-var _should_reconnect: bool = true
+## Nothing reconnects until somebody has asked to connect once.
+var _should_reconnect: bool = false
 var _project_path: String
 var _initialized: bool = false
 
+## Whether the address came from a caller rather than from the project, in which case it is not
+## this node's to change.
+var _named_by_caller: bool = false
+var _since_looked: float = 0.0
+
+## The announced address that did not answer, so the fallback gets a turn. Cleared the moment
+## anything connects or the project names a different one.
+var _refused_url: String = ""
+var _tried_announced: bool = false
+var _connecting_for: float = 0.0
+
 
 func _ready() -> void:
 	_project_path = ProjectSettings.globalize_path("res://")
+	version_at_load = _loaded_version()
 
 	_reconnect_timer = Timer.new()
 	_reconnect_timer.one_shot = true
@@ -43,6 +79,13 @@ func _process(_delta: float) -> void:
 	if socket.get_ready_state() == WebSocketPeer.STATE_CLOSED:
 		if _is_connected:
 			_handle_disconnect()
+		elif _should_reconnect and _reconnect_timer.is_stopped():
+			# A connection refused never opened, so it reaches CLOSED without passing through
+			# _handle_disconnect and nothing would ask again. An editor opened before the server
+			# is the ordinary way that happens, and it then sat there for the rest of the day.
+			if _tried_announced:
+				_refused_url = server_url
+			_schedule_reconnect()
 		return
 
 	socket.poll()
@@ -51,11 +94,17 @@ func _process(_delta: float) -> void:
 		WebSocketPeer.STATE_OPEN:
 			if not _is_connected:
 				_handle_connect()
+			_follow_whoever_is_newest(_delta)
 
 			while socket.get_available_packet_count() > 0:
 				var packet: PackedByteArray = socket.get_packet()
 				_handle_message(packet.get_string_from_utf8())
 
+		WebSocketPeer.STATE_CONNECTING:
+			_connecting_for += _delta
+			if _connecting_for >= CONNECT_TIMEOUT:
+				_give_up_on_this_address()
+
 		WebSocketPeer.STATE_CLOSING:
 			pass
 
@@ -64,7 +113,38 @@ func _process(_delta: float) -> void:
 				_handle_disconnect()
 
 
+## Moves to the server the project now names, when that is not the one this is talking to.
+##
+## A harness reconnect leaves the server it replaced running, still holding the port it bound and
+## still answering: the editor has no reason to notice, and stayed on a server nothing was
+## speaking to for the rest of the session. The replacement announces where it landed, so the
+## editor can go to it rather than anybody ending a process.
+##
+## Only while connected by a URL this worked out for itself. A caller that named one is holding
+## this to that address, which is what every fixture does.
+func _follow_whoever_is_newest(delta: float) -> void:
+	if _named_by_caller:
+		return
+	_since_looked += delta
+	if _since_looked < FOLLOW_INTERVAL:
+		return
+	_since_looked = 0.0
+
+	var announced: String = announced_url()
+	if announced == "" or announced == server_url or announced == _refused_url:
+		return
+	server_url = announced
+	# Put down before it is picked up again, because the arrival is what tells a server who this
+	# editor is: left standing, the open socket on the new address would never be greeted and the
+	# server would report no editor while holding one.
+	_is_connected = false
+	disconnected.emit()
+	_current_reconnect_delay = RECONNECT_DELAY
+	_attempt_connection()
+
+
 func connect_to_server(url: String = "") -> void:
+	_named_by_caller = url != ""
 	server_url = _resolve_server_url(url)
 	_should_reconnect = true
 	_current_reconnect_delay = RECONNECT_DELAY
@@ -75,6 +155,12 @@ func _resolve_server_url(explicit_url: String) -> String:
 	if explicit_url != "":
 		return explicit_url
 
+	var announced: String = announced_url()
+	if announced != "" and announced != _refused_url:
+		_tried_announced = true
+		return announced
+	_tried_announced = false
+
 	# The same variable the server reads, so the two agree on the port by construction.
 	var raw: String = OS.get_environment("GDHARNESS_BRIDGE_PORT")
 	if raw != "":
@@ -85,6 +171,48 @@ func _resolve_server_url(explicit_url: String) -> String:
 	return DEFAULT_URL
 
 
+## Stops waiting on an address that is not answering, and asks again elsewhere.
+func _give_up_on_this_address() -> void:
+	if _tried_announced:
+		_refused_url = server_url
+	_connecting_for = 0.0
+	socket.close()
+	_schedule_reconnect()
+
+
+## Where the server says its bridge is, or "" when nothing has said.
+##
+## Written by a server that knows which project it serves, inside that project, so the two sides
+## agree by construction rather than by deriving a temporary directory the same way: they do not
+## share an environment, and the runtime's own announcement cost a session learning that.
+##
+## A leftover is found out by trying it rather than by asking whether its process is still there.
+## `OS.is_process_running` answers that only for a child of the caller on Unix, where it prints
+## "does not exist or is not a child of the calling process" and says no about every server there
+## is: it works on Windows and quietly disables the whole thing everywhere else. So an
+## announcement that does not answer is set aside, the fallback gets the next turn, and a
+## different announcement puts it back in play.
+func announced_url() -> String:
+	if not FileAccess.file_exists(ANNOUNCEMENT):
+		return ""
+	var file: FileAccess = FileAccess.open(ANNOUNCEMENT, FileAccess.READ)
+	if file == null:
+		return ""
+	var said: Variant = JSON.parse_string(file.get_as_text())
+	file.close()
+	if not said is Dictionary:
+		return ""
+
+	var announcement: Dictionary = said
+	if int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
+		return ""
+	var port: int = int(announcement.get("port", 0))
+	if port < 1 or port > 65535:
+		return ""
+	var host: String = str(announcement.get("host", "127.0.0.1"))
+	return "ws://%s:%d/godot" % [host, port]
+
+
 func disconnect_from_server() -> void:
 	_should_reconnect = false
 	if _reconnect_timer:
@@ -98,6 +226,7 @@ func _attempt_connection() -> void:
 	if socket.get_ready_state() != WebSocketPeer.STATE_CLOSED:
 		socket.close()
 
+	_connecting_for = 0.0
 	var err: Error = socket.connect_to_url(server_url)
 	if err != OK:
 		push_error("[gdharness] Failed to connect to %s: %s" % [server_url, error_string(err)])
@@ -107,6 +236,7 @@ func _attempt_connection() -> void:
 func _handle_connect() -> void:
 	_is_connected = true
 	_current_reconnect_delay = RECONNECT_DELAY
+	_refused_url = ""
 
 	# The version reported is the one this editor loaded at startup, not the one on disk: an
 	# upgrade replaces the files under a running editor, which goes on serving the old code until
@@ -117,7 +247,7 @@ func _handle_connect() -> void:
 		{
 			"type": "godot_ready",
 			"project_path": _project_path,
-			"addon_version": _loaded_version(),
+			"addon_version": version_at_load,
 			"editor_pid": OS.get_process_id()
 		}
 	)
@@ -126,6 +256,13 @@ func _handle_connect() -> void:
 
 
 ## The version marker beside this addon, or "" when the copy was not installed by gdharness.
+##
+## Read once, when this copy loads, and never again: an upgrade replaces the files under a
+## running editor and rewrites the marker with them, so reading it at connect time answers with
+## the version on disk rather than the one in memory. That is the wrong answer at the one moment
+## it matters. An upgrade ends with the harness reconnecting, the editor reconnecting behind it,
+## and `addonIsStale` reporting false over an editor still running the old code, which is exactly
+## what it exists to catch.
 func _loaded_version() -> String:
 	if not FileAccess.file_exists(VERSION_MARKER):
 		return ""
@@ -153,6 +290,10 @@ func _schedule_reconnect() -> void:
 
 
 func _on_reconnect_timer() -> void:
+	# Asked again rather than remembered: the reason a connection dropped is often that its server
+	# did, and the one that replaced it has said where it is since.
+	if not _named_by_caller:
+		server_url = _resolve_server_url("")
 	_attempt_connection()
 
 

package/build/godot/addons/gdharness_editor/bridge_client.gd.uid

@@ -0,0 +1 @@
+uid://t1telvjuccb0

package/build/godot/addons/gdharness_editor/plugin.gd.uid

@@ -0,0 +1 @@
+uid://bxebcmjteyrwl

package/build/godot/addons/gdharness_editor/tool_executor.gd.uid

@@ -0,0 +1 @@
+uid://dmjxtcqxfrure

package/build/godot/addons/gdharness_editor/tools/animation_tools.gd.uid

@@ -0,0 +1 @@
+uid://bbmtwsaoi4bh0

package/build/godot/addons/gdharness_editor/tools/play_tools.gd.uid

@@ -0,0 +1 @@
+uid://bpusjmmbajpxq

package/build/godot/addons/gdharness_editor/tools/resource_tools.gd.uid

@@ -0,0 +1 @@
+uid://d27rjl7bpjvss

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd.uid

@@ -0,0 +1 @@
+uid://bdfggiknkfi0f

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -66,6 +66,7 @@ func _init() -> void:
 		"capture_viewport": _capture.capture_viewport,
 		"inject_action": _input.inject_action,
 		"inject_key": _input.inject_key,
+		"inject_text": _input.inject_text,
 		"inject_mouse_click": _input.inject_mouse_click,
 		"inject_mouse_motion": _input.inject_mouse_motion,
 		"click": _input.click,

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd.uid

@@ -0,0 +1 @@
+uid://c5crv4n4t7c5

package/build/godot/addons/gdharness_runtime/runtime_capture.gd.uid

@@ -0,0 +1 @@
+uid://cxhjoq814ox42

package/build/godot/addons/gdharness_runtime/runtime_input.gd

@@ -5,6 +5,13 @@ extends RefCounted
 
 const Values = preload("runtime_values.gd")
 
+## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
+const TO_SMALL: int = 32
+
+## The two characters a field reads as keys rather than as text.
+const NEWLINE: int = 10
+const TAB: int = 9
+
 var _host: Node
 var _values: Values
 
@@ -69,6 +76,12 @@ func inject_key(params: Dictionary) -> Dictionary:
 	event.ctrl_pressed = bool(params.get("ctrl", false))
 	event.alt_pressed = bool(params.get("alt", false))
 
+	# The fourth thing a real event carries, and the only one a text field reads: LineEdit and
+	# TextEdit insert `unicode` and never consult the keycode, so an injected key could press any
+	# action in the map and still type nothing into a search box. Godot's keycodes for printable
+	# keys are the code points themselves, which is what makes this a mapping and not a table.
+	event.unicode = _glyph_of(event.keycode, event.shift_pressed)
+
 	Input.parse_input_event(event)
 
 	return {
@@ -79,10 +92,73 @@ func inject_key(params: Dictionary) -> Dictionary:
 		"shift": event.shift_pressed,
 		"ctrl": event.ctrl_pressed,
 		"alt": event.alt_pressed,
+		"unicode": event.unicode,
 		"pressed": pressed
 	}
 
 
+## Types [param text] wherever the focus is, one key event per character.
+##
+## A key on its own cannot do this and should not try: which character a key produces is the
+## keyboard layout's business, and shift over a digit is an exclamation mark on one layout and
+## something else on the next. Given the character instead there is nothing to guess, so a field
+## can be filled with anything a player could type, this project's own two typefaces included.
+##
+## A newline and a tab are the two characters a field reads as keys rather than as text, so they
+## are sent as those keys and carry no character of their own: typing a name and submitting it is
+## one call rather than two.
+##
+## Pushed into the viewport for the reason [method click] is, and it matters more here: the focus
+## is what decides where a character lands, so a caller that clicked a field and then typed would
+## otherwise have both waiting in the same queue with nothing said about the order.
+func inject_text(params: Dictionary) -> Dictionary:
+	var text: String = String(params.get("text", ""))
+	if text.is_empty():
+		return {"type": "error", "message": "text required"}
+
+	var viewport: Viewport = _host.get_tree().root
+	for index: int in text.length():
+		var down: InputEventKey = _typed(text.unicode_at(index))
+		viewport.push_input(down)
+		# The release as well, so nothing is left held down behind the caller.
+		var up: InputEventKey = down.duplicate()
+		up.pressed = false
+		viewport.push_input(up)
+
+	return {"type": "input_injected", "input_type": "text", "text": text, "characters": text.length()}
+
+
+## The key press that produces [param glyph], as a keyboard would send it.
+func _typed(glyph: int) -> InputEventKey:
+	var event: InputEventKey = InputEventKey.new()
+	event.pressed = true
+	if glyph == NEWLINE:
+		event.keycode = KEY_ENTER
+	elif glyph == TAB:
+		event.keycode = KEY_TAB
+	else:
+		var capital: int = String.chr(glyph).to_upper().unicode_at(0)
+		event.keycode = capital as Key
+		event.shift_pressed = capital != glyph
+		event.unicode = glyph
+	event.physical_keycode = event.keycode
+	event.key_label = event.keycode
+	return event
+
+
+## The character a key produces, or nothing for a key that produces none.
+##
+## Godot's keycodes below [constant KEY_SPECIAL] are the Unicode code points of the keys that
+## print something, so the mapping is the value itself. Letters are held as their capitals, which
+## is the one place the shift a caller asked for changes the answer rather than the key.
+func _glyph_of(keycode: Key, shifted: bool) -> int:
+	if keycode >= KEY_SPECIAL:
+		return 0
+	if keycode >= KEY_A and keycode <= KEY_Z and not shifted:
+		return keycode + TO_SMALL
+	return keycode
+
+
 ## A point the tool schema sends as two flat numbers, or the older form of one [x, y] value.
 ## Answers a Vector2, or the String that says what was wrong with it.
 func _read_point(params: Dictionary, x_key: String, y_key: String, pair_key: String) -> Variant:

package/build/godot/addons/gdharness_runtime/runtime_input.gd.uid

@@ -0,0 +1 @@
+uid://d1shdw1mlyig7

package/build/godot/addons/gdharness_runtime/runtime_queries.gd.uid

@@ -0,0 +1 @@
+uid://bueql5kulh1dm

package/build/godot/addons/gdharness_runtime/runtime_values.gd

@@ -28,7 +28,16 @@ const SERIALISERS: Dictionary = {
 
 ## Converts a Godot value into something JSON can carry. A type with no entry in the table
 ## passes through as itself, which is what the JSON-native ones want.
+##
+## A method or property typed as a class answers a null with a Variant of type OBJECT that has
+## nothing behind it, and so does one whose object has been freed. Asking either for its class is
+## a script error, and a script error here costs far more than the one answer: the request is
+## never replied to at all, and an editor playing the game stops it dead on the error, so every
+## question after it times out as well. `find_child` for a name nothing has cost a whole session
+## that way.
 func serialize(value: Variant) -> Variant:
+	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
+		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
 	return call(serialiser, value) if not serialiser.is_empty() else value
 

package/build/godot/addons/gdharness_runtime/runtime_values.gd.uid

@@ -0,0 +1 @@
+uid://bamdnyhpw2umv

package/build/godot/addons/gdharness_runtime/runtime_waits.gd.uid

@@ -0,0 +1 @@
+uid://cpx5hgxdn8dwd

package/build/godot/operations/serialisation.gd

@@ -27,7 +27,15 @@ const SERIALISERS: Dictionary = {
 
 # Converts a Godot value into something JSON can carry. A type with no entry in the table
 # passes through as itself, which is what the JSON-native ones want.
+#
+# A property that holds no object is Object-typed and null rather than nil, which is most of what
+# a node's property list is, and an object that has been freed is the same shape again. Both are
+# refused here rather than inside _serialize_object, because a freed one never reaches it: the
+# call itself fails on the argument, with "previously freed is not a subclass of the expected
+# argument class", and a guard behind that is a guard that never runs.
 func serialize_value(value: Variant) -> Variant:
+	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
+		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
 	return call(serialiser, value) if not serialiser.is_empty() else value
 
@@ -140,12 +148,7 @@ func _serialize_dictionary(value: Dictionary) -> Dictionary:
 
 
 # A pathless Resource says so rather than inventing an empty path for the caller to load.
-#
-# A property that holds no object is Object-typed and null rather than nil, which is most of
-# what a node's property list is, so this is the branch that runs the most.
 func _serialize_object(value: Object) -> Variant:
-	if not is_instance_valid(value):
-		return null
 	if not value is Resource:
 		return {"_type": "Object", "class": value.get_class()}
 	var resource: Resource = value