first enemy test

addons/gut/gui/script_text_editor_controls.gd

@@ -0,0 +1,239 @@
+# Holds weakrefs to a ScriptTextEditor and related children nodes
+# that might be useful.  Though the CodeEdit is really the only one, but
+# since the tree may change, the first TextEdit under a CodeTextEditor is
+# the one we use...so we hold a ref to the CodeTextEditor too.
+class ScriptEditorControlRef:
+	var _text_edit = null
+	var _script_editor = null
+	var _code_editor = null
+
+	func _init(script_edit):
+		_script_editor = weakref(script_edit)
+		_populate_controls()
+		# print("_script_editor = ", script_edit, ' vis = ', is_visible())
+
+
+	func _populate_controls():
+		# who knows if the tree will change so get the first instance of each
+		# type of control we care about.  Chances are there won't be more than
+		# one of these in the future, but their position in the tree may change.
+		_code_editor = weakref(_get_first_child_named('CodeTextEditor', _script_editor.get_ref()))
+		_text_edit = weakref(_get_first_child_named("CodeEdit", _code_editor.get_ref()))
+
+
+	func _get_first_child_named(obj_name, parent_obj):
+		if(parent_obj == null):
+			return null
+
+		var kids = parent_obj.get_children()
+		var index = 0
+		var to_return = null
+
+		while(index < kids.size() and to_return == null):
+			if(str(kids[index]).find(str("<", obj_name)) != -1):
+				to_return = kids[index]
+			else:
+				to_return = _get_first_child_named(obj_name, kids[index])
+				if(to_return == null):
+					index += 1
+
+		return to_return
+
+
+	func get_script_text_edit():
+		return _script_editor.get_ref()
+
+
+	func get_text_edit():
+		# ScriptTextEditors that are loaded when the project is opened
+		# do not have their children populated yet.  So if we may have to
+		# _populate_controls again if we don't have one.
+		if(_text_edit == null):
+			_populate_controls()
+		return _text_edit.get_ref()
+
+
+	func get_script_editor():
+		return _script_editor
+
+
+	func is_visible():
+		var to_return = false
+		if(_script_editor.get_ref()):
+			to_return = _script_editor.get_ref().visible
+		return to_return
+
+# ##############################################################################
+#
+# ##############################################################################
+
+# Used to make searching for the controls easier and faster.
+var _script_editors_parent = null
+# reference the ScriptEditor instance
+var _script_editor = null
+# Array of ScriptEditorControlRef containing all the opened ScriptTextEditors
+# and related controls at the time of the last refresh.
+var _script_editor_controls = []
+
+var _method_prefix = 'test_'
+var _inner_class_prefix = 'Test'
+
+func _init(script_edit):
+	_script_editor = script_edit
+	refresh()
+
+
+func _is_script_editor(obj):
+	return str(obj).find('<ScriptTextEditor') != -1
+
+
+# Find the first ScriptTextEditor and then get its parent.  Done this way
+# because who knows if the parent object will change.  This is somewhat
+# future proofed.
+func _find_script_editors_parent():
+	var _first_editor = _get_first_child_of_type_name("ScriptTextEditor", _script_editor)
+	if(_first_editor != null):
+		_script_editors_parent = _first_editor.get_parent()
+
+
+func _populate_editors():
+	if(_script_editors_parent == null):
+		return
+
+	_script_editor_controls.clear()
+	for child in _script_editors_parent.get_children():
+		if(_is_script_editor(child)):
+			var ref = ScriptEditorControlRef.new(child)
+			_script_editor_controls.append(ref)
+
+# Yes, this is the same as the one above but with a different name.  This was
+# easier than trying to find a place where it could be used by both.
+func _get_first_child_of_type_name(obj_name, parent_obj):
+	if(parent_obj == null):
+		# print('aborting search for ', obj_name, ' parent is null')
+		return null
+
+	var kids = parent_obj.get_children()
+	var index = 0
+	var to_return = null
+
+	var search_for = str("<", obj_name)
+	# print('searching for ', search_for, ' in ', parent_obj, ' kids ', kids.size())
+	while(index < kids.size() and to_return == null):
+		var this_one = str(kids[index])
+		# print(search_for, ' :: ', this_one)
+		if(this_one.find(search_for) != -1):
+			to_return = kids[index]
+		else:
+			to_return = _get_first_child_of_type_name(obj_name, kids[index])
+			if(to_return == null):
+				index += 1
+
+	return to_return
+
+
+func _get_func_name_from_line(text):
+	text = text.strip_edges()
+	var left = text.split("(")[0]
+	var func_name = left.split(" ")[1]
+	return func_name
+
+
+func _get_class_name_from_line(text):
+	text = text.strip_edges()
+	var right = text.split(" ")[1]
+	var the_name = right.rstrip(":")
+	return the_name
+
+func refresh():
+	if(_script_editors_parent == null):
+		_find_script_editors_parent()
+		# print("script editors parent = ", _script_editors_parent)
+
+	if(_script_editors_parent != null):
+		_populate_editors()
+
+	# print("script editor controls = ", _script_editor_controls)
+
+
+func get_current_text_edit():
+	var cur_script_editor = null
+	var idx = 0
+
+	while(idx < _script_editor_controls.size() and cur_script_editor == null):
+		if(_script_editor_controls[idx].is_visible()):
+			cur_script_editor = _script_editor_controls[idx]
+		else:
+			idx += 1
+
+	var to_return = null
+	if(cur_script_editor != null):
+		to_return = cur_script_editor.get_text_edit()
+
+	return to_return
+
+
+func get_script_editor_controls():
+	var to_return = []
+	for ctrl_ref in _script_editor_controls:
+		to_return.append(ctrl_ref.get_script_text_edit())
+
+	return to_return
+
+
+func get_line_info():
+	var editor = get_current_text_edit()
+	if(editor == null):
+		return
+
+	var info = {
+		script = null,
+		inner_class = null,
+		test_method = null
+	}
+
+	var line = editor.get_caret_line()
+	var done_func = false
+	var done_inner = false
+	while(line > 0 and (!done_func or !done_inner)):
+		if(editor.can_fold_line(line)):
+			var text = editor.get_line(line)
+			var strip_text = text.strip_edges(true, false) # only left
+
+			if(!done_func and strip_text.begins_with("func ")):
+				var func_name = _get_func_name_from_line(text)
+				if(func_name.begins_with(_method_prefix)):
+					info.test_method = func_name
+				done_func = true
+				# If the func line is left justified then there won't be any
+				# inner classes above it.
+				if(strip_text == text):
+					done_inner = true
+
+			if(!done_inner and strip_text.begins_with("class")):
+				var inner_name = _get_class_name_from_line(text)
+				if(inner_name.begins_with(_inner_class_prefix)):
+					info.inner_class = inner_name
+					done_inner = true
+					# if we found an inner class then we are already past
+					# any test the cursor could be in.
+					done_func = true
+		line -= 1
+
+	return info
+
+
+func get_method_prefix():
+	return _method_prefix
+
+
+func set_method_prefix(method_prefix):
+	_method_prefix = method_prefix
+
+
+func get_inner_class_prefix():
+	return _inner_class_prefix
+
+
+func set_inner_class_prefix(inner_class_prefix):
+	_inner_class_prefix = inner_class_prefix