diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d56b387..cb8b1e7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -18,7 +18,7 @@ permissions: contents: read env: - GODOT_VERSION: "4.6" + GODOT_VERSION: "4.7" jobs: ci: diff --git a/README.md b/README.md index 6adf0ee..70db84b 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ [![CI](https://github.com/JavierIslas/Card-Combat-System/actions/workflows/ci.yml/badge.svg)](https://github.com/JavierIslas/Card-Combat-System/actions/workflows/ci.yml) -A turn-based **card combat engine** for Godot 4.6 / GDScript. It handles the +A turn-based **card combat engine** for Godot 4.7 / GDScript. It handles the *logic* of a card battle — turn FSM, mana, draw, attack/defense/block, damage resolution and pluggable AI — and stays **completely domain-agnostic**: it knows nothing about your GDD, rarities, abilities or loaders. Everything @@ -77,7 +77,7 @@ pattern live in the addon README: ## Testing -Tests run under [GUT](https://github.com/bitwes/Gut) 9.6 in `test/`: +Tests run under [GUT](https://github.com/bitwes/Gut) 9.7.1 in `test/`: ```bash godot --headless -s addons/gut/gut_cmdln.gd -gdir=res://test -ginclude_subdirs -gexit @@ -85,7 +85,7 @@ godot --headless -s addons/gut/gut_cmdln.gd -gdir=res://test -ginclude_subdirs - ### Continuous integration -Every push to `main` and every pull request runs three gates on Godot 4.6 +Every push to `main` and every pull request runs four gates on Godot 4.7 headless (see [`.github/workflows/ci.yml`](.github/workflows/ci.yml)): - **Compile gate** — `--check-only` over every engine script, so a parse/type @@ -93,6 +93,8 @@ headless (see [`.github/workflows/ci.yml`](.github/workflows/ci.yml)): - **Unit tests** — the full GUT suite above. - **Leak gate** — the benchmark's portable ObjectDB-leak detector (fails on a reference cycle). Its µs figures are hardware-specific and not asserted in CI. +- **Lint gate** — `gdlint` over the engine (naming/correctness smells the + compile gate cannot see; config in `.gdlintrc`). ## Showcase diff --git a/addons/card_combat/docs/integration_guide.md b/addons/card_combat/docs/integration_guide.md index 25fbee4..2ba2a3c 100644 --- a/addons/card_combat/docs/integration_guide.md +++ b/addons/card_combat/docs/integration_guide.md @@ -1,6 +1,6 @@ # Card Combat Engine — Integration Guide -A step-by-step guide to integrating the engine into your Godot 4.6 card game. +A step-by-step guide to integrating the engine into your Godot 4.7 card game. --- @@ -482,7 +482,7 @@ var session := TickCombatSession.new() # Recovery: the game defines what it means; the engine enforces the wait. session.recovery_fn = func(card: CardData, _owner: int) -> int: - return int(card.metadata.get("recovery", 0)) + return int(card.metadata.get("recovery", 0)) # Optional per-tick economy (defaults mirror the per-turn one). session.cards_drawn_per_tick = 1 diff --git a/addons/card_combat/docs/tutorial.md b/addons/card_combat/docs/tutorial.md index 5d0f554..bf77a56 100644 --- a/addons/card_combat/docs/tutorial.md +++ b/addons/card_combat/docs/tutorial.md @@ -9,7 +9,7 @@ If the [Integration Guide](integration_guide.md) is the reference manual, this i the guided first project. Read it top to bottom; every snippet builds on the previous one. -> **Prerequisites:** Godot 4.6, with the `card_combat` addon present under +> **Prerequisites:** Godot 4.7, with the `card_combat` addon present under > `res://addons/card_combat/`. The classes register by `class_name`, so no plugin > needs to be enabled in Project Settings to follow along. diff --git a/addons/gut/awaiter.gd b/addons/gut/awaiter.gd index 77e54a5..6c23442 100644 --- a/addons/gut/awaiter.gd +++ b/addons/gut/awaiter.gd @@ -1,6 +1,6 @@ extends Node -class AwaitLogger: +class GutAwaiterLogger: var _time_waited = 0.0 var logger = GutUtils.get_logger() var waiting_on = "nothing" @@ -31,7 +31,7 @@ class AwaitLogger: signal timeout signal wait_started -var await_logger = AwaitLogger.new() +var await_logger = GutAwaiterLogger.new() var _wait_time := 0.0 var _wait_process_frames := 0 var _wait_physics_frames := 0 @@ -196,6 +196,6 @@ func wait_while(predicate_function: Callable, max_time, time_between_calls:=0.0, func is_waiting(): - return _wait_time != 0.0 || \ - _wait_physics_frames != 0 || \ + return _wait_time != 0.0 or \ + _wait_physics_frames != 0 or \ _wait_process_frames != 0 diff --git a/addons/gut/cli/gut_cli.gd b/addons/gut/cli/gut_cli.gd index 66ec02d..4bc17de 100644 --- a/addons/gut/cli/gut_cli.gd +++ b/addons/gut/cli/gut_cli.gd @@ -15,7 +15,7 @@ var GutRunner = load('res://addons/gut/gui/GutRunner.tscn') # hash with null values for the other types of values. Lower precedented hashes # will punch through null values of higher precedented hashes. # ------------------------------------------------------------------------------ -class OptionResolver: +class GutCliOptionResolver: var base_opts = {} var cmd_opts = {} var config_opts = {} @@ -154,6 +154,7 @@ an immediate "=": opts.add('-gh', false, 'Print this help. You did this to see this, so you probably understand.') opts.add('-gpo', false, 'Print option values from all sources and the value used.') opts.add('-gprint_gutconfig_sample', false, 'Print out json that can be used to make a gutconfig file.') + opts.add("-gcheck_update", false, "Check for update") # run as in editor, for shelling out purposes through Editor. var o = opts.add('-graie', false, 'do not use') @@ -238,9 +239,18 @@ func _run_tests(opt_resolver): runner.run_tests() +var update_detector = null +func _check_for_update(): + print(str("Checking for update for GUT ", GutUtils.version_numbers.gut_version)) + update_detector = GutUtils.UpdateDetector.new() + add_child(update_detector) + await update_detector.check_for_update_with_fetch() + print(update_detector.get_update_string()) + + # parse options and run Gut func main(): - var opt_resolver = OptionResolver.new() + var opt_resolver = GutCliOptionResolver.new() opt_resolver.set_base_opts(_gut_config.default_options) var cli_opts = setup_options(_gut_config.default_options, _gut_config.valid_fonts) @@ -280,6 +290,9 @@ func main(): elif(cli_opts.get_value('-gprint_gutconfig_sample')): _print_gutconfigs(opt_resolver.get_resolved_values()) get_tree().quit(0) + elif(cli_opts.get_value('-gcheck_update')): + await _check_for_update() + get_tree().quit(0) else: _run_tests(opt_resolver) diff --git a/addons/gut/cli/optparse.gd b/addons/gut/cli/optparse.gd index 75dec1c..48ee9cc 100644 --- a/addons/gut/cli/optparse.gd +++ b/addons/gut/cli/optparse.gd @@ -135,7 +135,7 @@ # # value will return the default when it has not been set. #------------------------------------------------------------------------------- -class Option: +class OptParseOption: var _has_been_set = false var _value = null # REMEMBER that when this option is an array, you have to set the value @@ -221,7 +221,7 @@ class Option: #------------------------------------------------------------------------------- # A struct for organizing options by a heading #------------------------------------------------------------------------------- -class OptionHeading: +class OptParseOptionHeading: var options = [] var display = 'default' @@ -232,11 +232,11 @@ class OptionHeading: # Organizes options by order, heading, position. Also responsible for all # help related text generation. #------------------------------------------------------------------------------- -class Options: +class OptParseOptions: var options = [] var positional = [] - var default_heading = OptionHeading.new() - var script_option = Option.new('-s', '?', 'script option provided by Godot') + var default_heading = OptParseOptionHeading.new() + var script_option = OptParseOption.new('-s', '?', 'script option provided by Godot') var _options_by_name = {"--script": script_option, "-s": script_option} var _options_by_heading = [default_heading] @@ -244,7 +244,7 @@ class Options: func add_heading(display): - var heading = OptionHeading.new() + var heading = OptParseOptionHeading.new() heading.display = display _cur_heading = heading _options_by_heading.append(heading) @@ -347,7 +347,7 @@ class Options: # #------------------------------------------------------------------------------- ## @ignore -var options := Options.new() +var options := OptParseOptions.new() ## Set the banner property to any text you want to appear before the usage and ## options sections when printing the options help. var banner := '' @@ -474,10 +474,10 @@ func is_option(arg) -> bool: ## If the option is not successfully added (e.g. a name collision with another ## option occurs), an error message will be printed and [code]null[/code] ## will be returned. -func add(op_names, default, desc: String) -> Option: +func add(op_names, default, desc: String) -> OptParseOption: var op_name: String var aliases: Array[String] = [] - var new_op: Option = null + var new_op: OptParseOption = null if(typeof(op_names) == TYPE_STRING): op_name = op_names @@ -494,7 +494,7 @@ func add(op_names, default, desc: String) -> Option: elif bad_alias != -1: push_error(str('Option [', aliases[bad_alias], '] already exists.')) else: - new_op = Option.new(op_name, default, desc) + new_op = OptParseOption.new(op_name, default, desc) options.add(new_op, aliases) return new_op @@ -514,7 +514,7 @@ func add(op_names, default, desc: String) -> Option: ## If the option is not successfully added (e.g. a name collision with another ## option occurs), an error message will be printed and [code]null[/code] ## will be returned. -func add_required(op_names, default, desc: String) -> Option: +func add_required(op_names, default, desc: String) -> OptParseOption: var op := add(op_names, default, desc) if(op != null): op.required = true @@ -535,12 +535,12 @@ func add_required(op_names, default, desc: String) -> Option: ## If the option is not successfully added (e.g. a name collision with another ## option occurs), an error message will be printed and [code]null[/code] ## will be returned. -func add_positional(op_name, default, desc: String) -> Option: +func add_positional(op_name, default, desc: String) -> OptParseOption: var new_op = null if(options.get_by_name(op_name) != null): push_error(str('Positional option [', op_name, '] already exists.')) else: - new_op = Option.new(op_name, default, desc) + new_op = OptParseOption.new(op_name, default, desc) options.add_positional(new_op) return new_op @@ -561,7 +561,7 @@ func add_positional(op_name, default, desc: String) -> Option: ## If the option is not successfully added (e.g. a name collision with another ## option occurs), an error message will be printed and [code]null[/code] ## will be returned. -func add_positional_required(op_name, default, desc: String) -> Option: +func add_positional_required(op_name, default, desc: String) -> OptParseOption: var op = add_positional(op_name, default, desc) if(op != null): op.required = true @@ -582,7 +582,7 @@ func add_heading(display_text: String) -> void: ## If the option exists, the value assigned to it during parsing is returned. ## Otherwise, an error message is printed and [code]null[/code] is returned. func get_value(name: String): - var found_param: Option = options.get_by_name(name) + var found_param: OptParseOption = options.get_by_name(name) if(found_param != null): return found_param.value @@ -602,7 +602,7 @@ func get_value(name: String): ## then you do not want to get the default value for a command line option or ## it will overwrite the value in a config file. func get_value_or_null(name: String): - var found_param: Option = options.get_by_name(name) + var found_param: OptParseOption = options.get_by_name(name) if(found_param != null and found_param.has_been_set()): return found_param.value diff --git a/addons/gut/double_templates/function_template.txt b/addons/gut/double_templates/function_template.txt index f2abba1..2a41eb3 100644 --- a/addons/gut/double_templates/function_template.txt +++ b/addons/gut/double_templates/function_template.txt @@ -1,9 +1,9 @@ {func_decleration} if(__gutdbl == null): - return - - __gutdbl.spy_on('{method_name}', {param_array}) - if(__gutdbl.is_stubbed_to_call_super('{method_name}', {param_array})): {super_call} else: - return await __gutdbl.handle_other_stubs('{method_name}', {param_array}) + __gutdbl.spy_on('{method_name}', {param_array}) + if(__gutdbl.is_stubbed_to_call_super('{method_name}', {param_array})): + {super_call} + else: + {return_it}await __gutdbl.handle_other_stubs('{method_name}', {param_array}) diff --git a/addons/gut/doubler.gd b/addons/gut/doubler.gd index d70f32c..878b9e1 100644 --- a/addons/gut/doubler.gd +++ b/addons/gut/doubler.gd @@ -10,7 +10,7 @@ var _singleton_parser = GutUtils.SingletonParser.new() # used by tests for debugging purposes. var print_source = false -var inner_class_registry = GutUtils.InnerClassRegistry.new() +var inner_class_registry = GutUtils.inner_class_registry # ############### # Properties @@ -195,14 +195,14 @@ func _create_double(parsed, strategy, override_path, partial): for method in parsed.get_local_methods(): if(_is_method_eligible_for_doubling(parsed, method)): included_methods.append(method.meta.name) - dbl_src += _get_func_text(method.meta) + dbl_src += _method_maker.get_function_text(method) if(strategy == GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE): for method in parsed.get_super_methods(): if(_is_method_eligible_for_doubling(parsed, method)): included_methods.append(method.meta.name) _stub_to_call_super(parsed, method.meta.name) - dbl_src += _get_func_text(method.meta) + dbl_src += _method_maker.get_function_text(method) var base_script = _get_base_script_text(parsed, override_path, partial, included_methods) dbl_src = base_script + "\n\n" + dbl_src @@ -238,7 +238,7 @@ func _create_singleton_double(singleton, is_partial): var DblClass = GutUtils.create_script_from_source(dbl_src) if(_stubber != null): for key in parsed.methods_by_name: - var meta = parsed.methods_by_name[key] + var meta = parsed.methods_by_name[key].meta if(meta != {} and !meta.flags & METHOD_FLAG_VARARG): _stubber.stub_defaults_from_meta(singleton, meta) @@ -248,7 +248,7 @@ func _create_singleton_double(singleton, is_partial): func _stub_method_default_values(parsed): for method in parsed.get_local_methods(): if(method.is_eligible_for_doubling() and !_ignored_methods.has(parsed.resource, method.meta.name)): - _stubber.stub_defaults_from_meta(parsed.script_path, method.meta) + _stubber.stub_defaults_from_meta(parsed.resource, method.meta) func _double_scene_and_script(scene, strategy, partial): @@ -281,10 +281,6 @@ func _get_inst_id_ref_str(inst): return ref_str -func _get_func_text(method_hash): - return _method_maker.get_function_text(method_hash) + "\n" - - func _parse_script(obj): var parsed = null diff --git a/addons/gut/error_tracker.gd b/addons/gut/error_tracker.gd index 99ff731..c53c957 100644 --- a/addons/gut/error_tracker.gd +++ b/addons/gut/error_tracker.gd @@ -59,8 +59,8 @@ func _get_stack_data(current_test_name): stackTrace.remove_at(0) return { - "test_entry" = test_entry, - "full_stack" = stackTrace + "test_entry": test_entry, + "full_stack": stackTrace } @@ -75,6 +75,17 @@ func _is_error_failable(error : GutTrackedError): is_it = treat_engine_errors_as == GutUtils.TREAT_AS.FAILURE return is_it + +# Marks any errors that GUT should not fail a test for based on internal, +# non-alterable rules. This is idealogically differnet than _is_error_failable. +func _auto_handle_error(err : GutTrackedError): + # Issue 842, when the source has an await and a declared return type this + # error can occur when doubling. It does not appear to affect anything. + if(err.file == 'modules/gdscript/gdscript_byte_codegen.cpp' and err.function == 'write_return'): + err.handled = true + print("[GUT] \"Unresolved return\" has been ignored. See https://github.com/bitwes/Gut/issues/842 for details.") + + # ---------------- #endregion #region Godot's Logger Overrides @@ -186,7 +197,10 @@ func add_error(function: String, file: String, line: int, err.line = line errors.add(_current_test_id, err) + _auto_handle_error(err) _mutex.unlock() return err + + diff --git a/addons/gut/godot_singletons.gd b/addons/gut/godot_singletons.gd index 11b6871..2fab531 100644 --- a/addons/gut/godot_singletons.gd +++ b/addons/gut/godot_singletons.gd @@ -2,6 +2,7 @@ # This file is auto-generated as part of the release process. GUT maintainers # should not change this file manually. static var class_ref = [ + AccessibilityServer, AudioServer, CameraServer, ClassDB, @@ -10,6 +11,7 @@ static var class_ref = [ Engine, EngineDebugger, GDExtensionManager, + # excluded: GDScriptLanguageProtocol, Geometry2D, Geometry3D, IP, @@ -42,7 +44,7 @@ static var class_ref = [ WorkerThreadPool, XRServer ] -static var names = [] +static var names := [] static func _static_init(): for entry in class_ref: names.append(entry.get_class()) diff --git a/addons/gut/gui/GutBottomPanel.gd b/addons/gut/gui/GutBottomPanel.gd index 020f233..3918848 100644 --- a/addons/gut/gui/GutBottomPanel.gd +++ b/addons/gut/gui/GutBottomPanel.gd @@ -48,6 +48,7 @@ var menu_manager = null : settings_button = %ExtraButtons/Settings, shortcut_dialog = $ShortcutDialog, shortcuts_button = %ExtraButtons/Shortcuts, + sub_panels_split = $layout/RSplit, results = { bar = $layout/ControlBar2, @@ -356,6 +357,12 @@ func _on_vert_layout_pressed() -> void: results_vert_layout() +func _on_resized() -> void: + # This wouldn't work in ready or defrred after ready. the split's y position + # was alwasy 0. This also adapts to Editor font size changes. + custom_minimum_size.y = _ctrls.sub_panels_split.position.y + + # --------------- # Public # --------------- diff --git a/addons/gut/gui/GutBottomPanel.tscn b/addons/gut/gui/GutBottomPanel.tscn index f11677b..15cef48 100644 --- a/addons/gut/gui/GutBottomPanel.tscn +++ b/addons/gut/gui/GutBottomPanel.tscn @@ -16,7 +16,8 @@ [sub_resource type="ButtonGroup" id="ButtonGroup_bskl7"] [node name="GutBottomPanel" type="Control" unique_id=1136630421] -custom_minimum_size = Vector2(250, 250) +clip_contents = true +custom_minimum_size = Vector2(250, 0) layout_mode = 3 anchor_left = -0.0025866 anchor_top = -0.00176575 @@ -48,7 +49,7 @@ custom_minimum_size = Vector2(1, 2.08165e-12) layout_mode = 2 [node name="RunAtCursor" parent="layout/ControlBar" unique_id=1603612118 instance=ExtResource("3")] -custom_minimum_size = Vector2(237, 0) +custom_minimum_size = Vector2(488, 0) layout_mode = 2 [node name="CenterContainer2" type="CenterContainer" parent="layout/ControlBar" unique_id=269691286] @@ -270,7 +271,7 @@ size_flags_vertical = 3 [node name="RunResults" parent="layout/RSplit/CResults/HSplitResults" unique_id=1277406275 instance=ExtResource("5")] unique_name_in_owner = true -custom_minimum_size = Vector2(255, 255) +custom_minimum_size = Vector2(255, 0) layout_mode = 2 size_flags_horizontal = 3 size_flags_vertical = 3 @@ -303,6 +304,7 @@ visible = false size = Vector2i(1300, 1336) visible = false +[connection signal="resized" from="." to="." method="_on_resized"] [connection signal="pressed" from="layout/ControlBar/RunAll" to="." method="_on_RunAll_pressed"] [connection signal="run_tests" from="layout/ControlBar/RunAtCursor" to="." method="_on_RunAtCursor_run_tests"] [connection signal="pressed" from="layout/ControlBar/MakeFloating" to="." method="_on_to_window_pressed"] diff --git a/addons/gut/gui/OutputText.gd b/addons/gut/gui/OutputText.gd index ebd5a4f..fddd999 100644 --- a/addons/gut/gui/OutputText.gd +++ b/addons/gut/gui/OutputText.gd @@ -145,7 +145,7 @@ func _add_other_ctrls(): var fname = GutUtils.gut_fonts.DEFAULT_CUSTOM_FONT_NAME if(_user_prefs != null): fname = _user_prefs.output_font_name.value - _font_name_pctrl = PanelControls.SelectControl.new('Font', fname, GutUtils.avail_fonts, + _font_name_pctrl = PanelControls.GpcSelect.new('Font', fname, GutUtils.avail_fonts, "The font, you know, for the text below. Change it, see what it does.") _font_name_pctrl.changed.connect(_on_font_name_changed) _font_name_pctrl.label.size_flags_horizontal = SIZE_SHRINK_BEGIN @@ -155,7 +155,7 @@ func _add_other_ctrls(): var fsize = 30 if(_user_prefs != null): fsize = _user_prefs.output_font_size.value - _font_size_pctrl = PanelControls.NumberControl.new('Font Size', fsize , 5, 100, + _font_size_pctrl = PanelControls.GpcNumber.new('Font Size', fsize , 5, 100, "The size of 'The Font'.") _font_size_pctrl.changed.connect(_on_font_size_changed) _font_size_pctrl.label.size_flags_horizontal = SIZE_SHRINK_BEGIN diff --git a/addons/gut/gui/ResultsTree.tscn b/addons/gut/gui/ResultsTree.tscn index bc17425..8868f87 100644 --- a/addons/gut/gui/ResultsTree.tscn +++ b/addons/gut/gui/ResultsTree.tscn @@ -1,8 +1,8 @@ -[gd_scene load_steps=2 format=3 uid="uid://dls5r5f6157nq"] +[gd_scene format=3 uid="uid://dls5r5f6157nq"] [ext_resource type="Script" uid="uid://dehdhn78qv5tr" path="res://addons/gut/gui/ResultsTree.gd" id="1_b4uub"] -[node name="ResultsTree" type="Tree"] +[node name="ResultsTree" type="Tree" unique_id=1240770657] offset_right = 1082.0 offset_bottom = 544.0 size_flags_horizontal = 3 @@ -11,7 +11,7 @@ columns = 2 hide_root = true script = ExtResource("1_b4uub") -[node name="TextOverlay" type="Label" parent="."] +[node name="TextOverlay" type="Label" parent="." unique_id=1487654929] visible = false layout_mode = 1 anchors_preset = 15 @@ -20,7 +20,7 @@ anchor_bottom = 1.0 grow_horizontal = 2 grow_vertical = 2 -[node name="ResultsTree" type="VBoxContainer" parent="."] +[node name="ResultsTree" type="VBoxContainer" parent="." unique_id=87055617] custom_minimum_size = Vector2(10, 10) layout_mode = 1 anchors_preset = 15 diff --git a/addons/gut/gui/ShortcutButton.gd b/addons/gut/gui/ShortcutButton.gd index 85b0de6..f6afafc 100644 --- a/addons/gut/gui/ShortcutButton.gd +++ b/addons/gut/gui/ShortcutButton.gd @@ -124,7 +124,7 @@ func get_input_event(): return _source_event func set_shortcut(sc): - if(sc == null or sc.events == null || sc.events.size() <= 0): + if(sc == null or sc.events == null or sc.events.size() <= 0): clear_shortcut() else: _source_event = sc.events[0] @@ -144,8 +144,8 @@ func disable_set(should): func disable_clear(should): _ctrls.clear_button.disabled = should - - + + func cancel(): if(_editing): _edit_mode(false) diff --git a/addons/gut/gui/about.gd b/addons/gut/gui/about.gd index 5094e14..b982207 100644 --- a/addons/gut/gui/about.gd +++ b/addons/gut/gui/about.gd @@ -5,15 +5,13 @@ var GutEditorGlobals = load('res://addons/gut/gui/editor_globals.gd') var _bbcode = \ """ -[center]GUT {gut_version}[/center] - [center][b]GUT Links[/b] {gut_link_table}[/center] [center][b]VSCode Extension Links[/b] {vscode_link_table}[/center] -[center]You can support GUT development at +[center]You can support GUT development at: {donate_link} Thanks for using GUT! @@ -33,17 +31,19 @@ var _vscode_links = [ ] var _donate_link = "https://buymeacoffee.com/bitwes" - @onready var _logo = $Logo - +@onready var rtl = $HBox/VBoxContainer/Scroll/RichTextLabel +@onready var check_for_update = $HBox/VBoxContainer/CheckForUpdate func _ready(): if(get_parent() is SubViewport): return - + elif(get_parent() == get_tree().root): + size = Vector2(100, 100) + title = str("GUT ", GutUtils.version_numbers.gut_version) _vert_center_logo() - $Logo.disabled = true - $HBox/Scroll/RichTextLabel.text = _make_text() + _logo.disabled = true + rtl.text = _make_text() func _color_link(link_text): @@ -62,6 +62,13 @@ func _link_table(entries): return str('[table=2]', text, '[/table]') +func url_bbcode(url, link_text=null): + if(link_text == null): + link_text = url + var text = str("[url=", url, "]", link_text, "[/url]") + return _color_link(text) + + func _make_text(): var gut_link_table = _link_table(_gut_links) var vscode_link_table = _link_table(_vscode_links) @@ -70,7 +77,6 @@ func _make_text(): "gut_link_table":gut_link_table, "vscode_link_table":vscode_link_table, "donate_link":_color_link(str('[url]', _donate_link, '[/url]')), - "gut_version":GutUtils.version_numbers.gut_version, }) return text @@ -123,3 +129,8 @@ func _on_rich_text_label_meta_hover_ended(meta: Variant) -> void: func _on_logo_pressed() -> void: _logo.disabled = !_logo.disabled + + +func _on_check_for_update_verbose_enabled() -> void: + check_for_update.size_flags_vertical = check_for_update.SIZE_EXPAND_FILL + check_for_update.z_index = 100 diff --git a/addons/gut/gui/about.tscn b/addons/gut/gui/about.tscn index d13904f..bddb852 100644 --- a/addons/gut/gui/about.tscn +++ b/addons/gut/gui/about.tscn @@ -1,6 +1,7 @@ -[gd_scene load_steps=5 format=3 uid="uid://dqbkylpsatcqm"] +[gd_scene format=3 uid="uid://dqbkylpsatcqm"] [ext_resource type="Script" uid="uid://g7qu8ihdt3pd" path="res://addons/gut/gui/about.gd" id="1_bg86c"] +[ext_resource type="PackedScene" uid="uid://c5om15m2e70qp" path="res://addons/gut/gui/check_for_update.tscn" id="2_kpic4"] [ext_resource type="PackedScene" uid="uid://bjkn8mhx2fmt1" path="res://addons/gut/gui/GutLogo.tscn" id="3_kpic4"] [sub_resource type="StyleBoxFlat" id="StyleBoxFlat_q8rky"] @@ -8,7 +9,7 @@ bg_color = Color(0, 0, 0, 0.49803922) [sub_resource type="StyleBoxEmpty" id="StyleBoxEmpty_kpic4"] -[node name="About" type="AcceptDialog"] +[node name="About" type="AcceptDialog" unique_id=1150745302] oversampling_override = 1.0 title = "About GUT" position = Vector2i(0, 36) @@ -17,22 +18,32 @@ visible = true min_size = Vector2i(800, 800) script = ExtResource("1_bg86c") -[node name="HBox" type="HBoxContainer" parent="."] +[node name="HBox" type="HBoxContainer" parent="." unique_id=1875890740] offset_left = 8.0 offset_top = 8.0 offset_right = 1492.0 offset_bottom = 751.0 alignment = 1 -[node name="MakeRoomForLogo" type="CenterContainer" parent="HBox"] +[node name="MakeRoomForLogo" type="CenterContainer" parent="HBox" unique_id=1274652102] custom_minimum_size = Vector2(200, 0) layout_mode = 2 -[node name="Scroll" type="ScrollContainer" parent="HBox"] +[node name="VBoxContainer" type="VBoxContainer" parent="HBox" unique_id=1594624944] layout_mode = 2 size_flags_horizontal = 3 +theme_override_constants/separation = 0 -[node name="RichTextLabel" type="RichTextLabel" parent="HBox/Scroll"] +[node name="CheckForUpdate" parent="HBox/VBoxContainer" unique_id=381385621 instance=ExtResource("2_kpic4")] +custom_minimum_size = Vector2(0, 76) +layout_mode = 2 + +[node name="Scroll" type="ScrollContainer" parent="HBox/VBoxContainer" unique_id=1684204946] +layout_mode = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 + +[node name="RichTextLabel" type="RichTextLabel" parent="HBox/VBoxContainer/Scroll" unique_id=1217183710] layout_mode = 2 size_flags_horizontal = 3 size_flags_vertical = 3 @@ -41,7 +52,7 @@ theme_override_styles/focus = SubResource("StyleBoxEmpty_kpic4") bbcode_enabled = true fit_content = true -[node name="Logo" parent="." instance=ExtResource("3_kpic4")] +[node name="Logo" parent="." unique_id=2097718136 instance=ExtResource("3_kpic4")] modulate = Color(0.74509805, 0.74509805, 0.74509805, 1) position = Vector2(151, 265) scale = Vector2(0.8, 0.8) @@ -50,7 +61,8 @@ disabled = true [connection signal="mouse_entered" from="." to="." method="_on_mouse_entered"] [connection signal="mouse_exited" from="." to="." method="_on_mouse_exited"] -[connection signal="meta_clicked" from="HBox/Scroll/RichTextLabel" to="." method="_on_rich_text_label_meta_clicked"] -[connection signal="meta_hover_ended" from="HBox/Scroll/RichTextLabel" to="." method="_on_rich_text_label_meta_hover_ended"] -[connection signal="meta_hover_started" from="HBox/Scroll/RichTextLabel" to="." method="_on_rich_text_label_meta_hover_started"] +[connection signal="verbose_enabled" from="HBox/VBoxContainer/CheckForUpdate" to="." method="_on_check_for_update_verbose_enabled"] +[connection signal="meta_clicked" from="HBox/VBoxContainer/Scroll/RichTextLabel" to="." method="_on_rich_text_label_meta_clicked"] +[connection signal="meta_hover_ended" from="HBox/VBoxContainer/Scroll/RichTextLabel" to="." method="_on_rich_text_label_meta_hover_ended"] +[connection signal="meta_hover_started" from="HBox/VBoxContainer/Scroll/RichTextLabel" to="." method="_on_rich_text_label_meta_hover_started"] [connection signal="pressed" from="Logo" to="." method="_on_logo_pressed"] diff --git a/addons/gut/gui/check_for_update.gd b/addons/gut/gui/check_for_update.gd new file mode 100644 index 0000000..821baf8 --- /dev/null +++ b/addons/gut/gui/check_for_update.gd @@ -0,0 +1,152 @@ +@tool +extends Control + +static var fetch_count = 0 +static var max_fetches = 5 + +var update_detector = null +@onready var rtl = $Output +var _log_entries = [] +var _verbose = false : + set(val): + if(!_verbose and val): + verbose_enabled.emit() + _verbose = val +var _mouse_down_duration = 0.0 +var _mouse_down = false +var _mouse_down_time_to_show_verbose := 4.0 + +signal verbose_enabled + +func _debug_ready(): + _verbose = true + +func _ready(): + update_detector = GutUtils.UpdateDetector.new() + add_child(update_detector) + update_detector.updated.connect(_on_update_detector_updated) + update_detector.download_completed.connect(_on_update_detector_download) + + check_for_update(false, false) + _log(update_detector.get_summary_string()) + _populate_text() + + if(get_parent() == get_tree().root): + _debug_ready() + + +func _process(delta: float) -> void: + if(_mouse_down_duration < _mouse_down_time_to_show_verbose and _mouse_down): + _mouse_down_duration += delta + if(_mouse_down_duration >= _mouse_down_time_to_show_verbose): + _verbose = true + rtl.append_text("\nVERBOSE ENABLED\n") + rtl.append_text(_get_check_for_update_link()) + + +# ---------------- +# Private +# ---------------- + +func _log(text): + if(_verbose): + _log_entries.append(str(text)) + + +func _log_file(path): + if(_verbose): + var file_text = FileAccess.get_file_as_string(path) + if(file_text == ""): + file_text = "--Missing or empty file--" + _log(str(path, ":\n[code]", file_text, "[/code]")) + + +func _get_check_for_update_link(): + if(_verbose or update_detector.fetch_limit_wait_time() <= 0.0): + return str("[center]", _url_bbcode("_check_for_update", "Check for Update", "ORANGE"), "[/center]") + else: + return '' + + +func check_for_update(use_fetch, force=false): + _log_entries.clear() + rtl.text = "" + update_detector.check_for_update() + if(use_fetch): + fetch_count += 1 + rtl.text = "Checking..." + _log("fetching remote file " + update_detector.REMOTE_FILE_URL) + update_detector.check_for_update_with_fetch(force) + else: + _log("local check") + update_detector.check_for_update() + + +func _populate_text(): + var txt = "" + if(!update_detector.is_empty()): + txt = str("[center]", update_detector.get_update_string(_url_bbcode), "[/center]") + if(_verbose): + txt = txt + "\n\n" + "\n".join(_log_entries) + rtl.text = txt + "\n" + _get_check_for_update_link() + _post_populate.call_deferred() + + +func _post_populate(): + custom_minimum_size.y = min(rtl.get_content_height() + 30, 400) + + +func _url_bbcode(url, link_text=null, color_name="ROYAL_BLUE"): + if(link_text == null): + link_text = url + var text = str("[url=", url, "]", link_text, "[/url]") + return str("[color=", color_name, "]", text, "[/color]") + + +# ----------------- +# Events +# ----------------- +func _on_update_detector_updated(): + _log_file(update_detector.REMOTE_FILE_PATH) + _log_file(update_detector.LOCAL_FILE_PATH) + _log(str("Local:\n[code]", JSON.stringify(update_detector.local_data.get_data(), " "), "[/code]")) + _log(str("Local Issues:\n", update_detector.local_data.data_issues)) + _log(str("Remote:\n[code]", JSON.stringify(update_detector.remote_data.get_data(), " "), "[/code]")) + _log(str("Remote Issues:\n", update_detector.remote_data.data_issues)) + + _log(update_detector.get_summary_string()) + _populate_text() + + +func _on_btn_check_button_up() -> void: + check_for_update(true, true) + + +func _on_update_detector_download(): + _log("Download completed") + + +func _on_output_meta_clicked(meta: Variant) -> void: + if(meta == "_check_for_update"): + check_for_update(true, true) + else: + OS.shell_open(str(meta)) + + +func _on_output_gui_input(event: InputEvent) -> void: + if(event is InputEventMouseButton): + if(event.pressed): + _mouse_down = true + else: + _mouse_down = false + _mouse_down_duration = 0.0 + + +func _on_output_resized() -> void: + if(rtl != null): + custom_minimum_size.y = rtl.get_visible_content_rect().size.y + 20 + + +func _on_mouse_exited() -> void: + _mouse_down = false + _mouse_down = 0.0 diff --git a/addons/gut/gui/check_for_update.tscn b/addons/gut/gui/check_for_update.tscn new file mode 100644 index 0000000..3b1fca7 --- /dev/null +++ b/addons/gut/gui/check_for_update.tscn @@ -0,0 +1,45 @@ +[gd_scene format=3 uid="uid://c5om15m2e70qp"] + +[ext_resource type="Script" uid="uid://bomsutomy3pdy" path="res://addons/gut/gui/check_for_update.gd" id="1_70x43"] +[ext_resource type="FontFile" uid="uid://bnh0lslf4yh87" path="res://addons/gut/fonts/CourierPrime-Regular.ttf" id="2_lsin2"] + +[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_lsin2"] +content_margin_left = 20.0 +content_margin_top = 20.0 +content_margin_right = 20.0 +content_margin_bottom = 20.0 +bg_color = Color(0.09239707, 0.09239706, 0.09239706, 0.49803922) +corner_radius_top_left = 20 +corner_radius_top_right = 20 + +[node name="CheckForUpdate" type="Control" unique_id=381385621] +custom_minimum_size = Vector2(0, 53) +layout_mode = 3 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +size_flags_horizontal = 3 +script = ExtResource("1_70x43") + +[node name="Output" type="RichTextLabel" parent="." unique_id=1256208807] +layout_mode = 1 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +size_flags_horizontal = 3 +size_flags_vertical = 3 +focus_mode = 2 +theme_override_fonts/mono_font = ExtResource("2_lsin2") +theme_override_styles/normal = SubResource("StyleBoxFlat_lsin2") +bbcode_enabled = true +text = "[center][color=ROYAL_BLUE][url=https://github.com/bitwes/Gut/releases/tag/v0.0.0]GUT 0.0.0[/url][/color] is now available![/center] +" +selection_enabled = true + +[connection signal="gui_input" from="Output" to="." method="_on_output_gui_input"] +[connection signal="meta_clicked" from="Output" to="." method="_on_output_meta_clicked"] +[connection signal="resized" from="Output" to="." method="_on_output_resized"] diff --git a/addons/gut/gui/editor_globals.gd b/addons/gut/gui/editor_globals.gd index 97d33bb..da64eb4 100644 --- a/addons/gut/gui/editor_globals.gd +++ b/addons/gut/gui/editor_globals.gd @@ -1,7 +1,7 @@ @tool static var GutUserPreferences = load("res://addons/gut/gui/gut_user_preferences.gd") -static var temp_directory = 'user://gut_temp_directory' +static var temp_directory = 'user://gut_temp_directory/' static var editor_run_gut_config_path = 'gut_editor_config.json': # This avoids having to use path_join wherever we want to reference this diff --git a/addons/gut/gui/gut_config_gui.gd b/addons/gut/gui/gut_config_gui.gd index e7b943c..52e3867 100644 --- a/addons/gut/gui/gut_config_gui.gd +++ b/addons/gut/gui/gut_config_gui.gd @@ -18,7 +18,7 @@ func _init(cont): func _add_save_load(): - var ctrl = PanelControls.SaveLoadControl.new('Config', '', '') + var ctrl = PanelControls.GpcSaveLoad.new('Config', '', '') ctrl.save_path_chosen.connect(_on_save_path_chosen) ctrl.load_path_chosen.connect(_on_load_path_chosen) diff --git a/addons/gut/gui/gut_logo.gd b/addons/gut/gui/gut_logo.gd index d576a71..1d88b0d 100644 --- a/addons/gut/gui/gut_logo.gd +++ b/addons/gut/gui/gut_logo.gd @@ -1,7 +1,7 @@ @tool extends Node2D -class Eyeball: +class GutEyeball: extends Node2D var _should_draw_laser = false @@ -139,8 +139,8 @@ var GutEditorGlobals = load('res://addons/gut/gui/editor_globals.gd') @onready var _reset_timer = $ResetTimer @onready var _face_button = $FaceButton -@onready var left_eye : Eyeball = Eyeball.new($BaseLogo/LeftEye) -@onready var right_eye : Eyeball = Eyeball.new($BaseLogo/RightEye) +@onready var left_eye : GutEyeball = GutEyeball.new($BaseLogo/LeftEye) +@onready var right_eye : GutEyeball = GutEyeball.new($BaseLogo/RightEye) var _no_shine = load("res://addons/gut/images/GutIconV2_no_shine.png") var _normal = load("res://addons/gut/images/GutIconV2_base.png") diff --git a/addons/gut/gui/option_maker.gd b/addons/gut/gui/option_maker.gd index 43f31a5..a2b1473 100644 --- a/addons/gut/gui/option_maker.gd +++ b/addons/gut/gui/option_maker.gd @@ -27,48 +27,48 @@ func add_ctrl(key, ctrl): func add_number(key, value, disp_text, v_min, v_max, hint=''): - var ctrl = PanelControls.NumberControl.new(disp_text, value, v_min, v_max, hint) + var ctrl = PanelControls.GpcNumber.new(disp_text, value, v_min, v_max, hint) add_ctrl(key, ctrl) return ctrl func add_float(key, value, disp_text, step, v_min, v_max, hint=''): - var ctrl = PanelControls.FloatControl.new(disp_text, value, step, v_min, v_max, hint) + var ctrl = PanelControls.GpcFloat.new(disp_text, value, step, v_min, v_max, hint) add_ctrl(key, ctrl) return ctrl func add_select(key, value, values, disp_text, hint=''): - var ctrl = PanelControls.SelectControl.new(disp_text, value, values, hint) + var ctrl = PanelControls.GpcSelect.new(disp_text, value, values, hint) add_ctrl(key, ctrl) return ctrl func add_value(key, value, disp_text, hint=''): - var ctrl = PanelControls.StringControl.new(disp_text, value, hint) + var ctrl = PanelControls.GpcString.new(disp_text, value, hint) add_ctrl(key, ctrl) return ctrl func add_multiline_text(key, value, disp_text, hint=''): - var ctrl = PanelControls.MultiLineStringControl.new(disp_text, value, hint) + var ctrl = PanelControls.GpcMultiLineString.new(disp_text, value, hint) add_ctrl(key, ctrl) return ctrl func add_boolean(key, value, disp_text, hint=''): - var ctrl = PanelControls.BooleanControl.new(disp_text, value, hint) + var ctrl = PanelControls.GpcBoolean.new(disp_text, value, hint) add_ctrl(key, ctrl) return ctrl func add_directory(key, value, disp_text, hint=''): - var ctrl = PanelControls.DirectoryControl.new(disp_text, value, hint) + var ctrl = PanelControls.GpcDirectory.new(disp_text, value, hint) add_ctrl(key, ctrl) ctrl.dialog.title = disp_text return ctrl func add_file(key, value, disp_text, hint=''): - var ctrl = PanelControls.DirectoryControl.new(disp_text, value, hint) + var ctrl = PanelControls.GpcDirectory.new(disp_text, value, hint) add_ctrl(key, ctrl) ctrl.dialog.file_mode = ctrl.dialog.FILE_MODE_OPEN_FILE ctrl.dialog.title = disp_text @@ -76,7 +76,7 @@ func add_file(key, value, disp_text, hint=''): func add_save_file_anywhere(key, value, disp_text, hint=''): - var ctrl = PanelControls.DirectoryControl.new(disp_text, value, hint) + var ctrl = PanelControls.GpcDirectory.new(disp_text, value, hint) add_ctrl(key, ctrl) ctrl.dialog.file_mode = ctrl.dialog.FILE_MODE_SAVE_FILE ctrl.dialog.access = ctrl.dialog.ACCESS_FILESYSTEM @@ -85,7 +85,7 @@ func add_save_file_anywhere(key, value, disp_text, hint=''): func add_color(key, value, disp_text, hint=''): - var ctrl = PanelControls.ColorControl.new(disp_text, value, hint) + var ctrl = PanelControls.GpcColor.new(disp_text, value, hint) add_ctrl(key, ctrl) return ctrl diff --git a/addons/gut/gui/panel_controls.gd b/addons/gut/gui/panel_controls.gd index a3d5ffe..227322e 100644 --- a/addons/gut/gui/panel_controls.gd +++ b/addons/gut/gui/panel_controls.gd @@ -52,7 +52,7 @@ class BaseGutPanelControl: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class NumberControl: +class GpcNumber: extends BaseGutPanelControl var value_ctrl = SpinBox.new() @@ -80,8 +80,8 @@ class NumberControl: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class FloatControl: - extends NumberControl +class GpcFloat: + extends GpcNumber func _init(title, val, step, v_min, v_max, hint=""): super._init(title, val, v_min, v_max, hint) @@ -91,7 +91,7 @@ class FloatControl: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class StringControl: +class GpcString: extends BaseGutPanelControl var value_ctrl = LineEdit.new() @@ -120,7 +120,7 @@ class StringControl: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class MultiLineStringControl: +class GpcMultiLineString: extends BaseGutPanelControl var value_ctrl = TextEdit.new() @@ -150,7 +150,7 @@ class MultiLineStringControl: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class BooleanControl: +class GpcBoolean: extends BaseGutPanelControl var value_ctrl = CheckBox.new() @@ -176,7 +176,7 @@ class BooleanControl: # value is "selected" and is gettable and settable # text is the text value of the selected item, it is gettable only # ------------------------------------------------------------------------------ -class SelectControl: +class GpcSelect: extends BaseGutPanelControl var value_ctrl = OptionButton.new() @@ -210,7 +210,7 @@ class SelectControl: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class ColorControl: +class GpcColor: extends BaseGutPanelControl var value_ctrl = ColorPickerButton.new() @@ -230,7 +230,7 @@ class ColorControl: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class DirectoryControl: +class GpcDirectory: extends BaseGutPanelControl var value_ctrl := LineEdit.new() @@ -300,7 +300,7 @@ class DirectoryControl: # Features: # Buttons to pick res://, user://, or anywhere on the OS. # ------------------------------------------------------------------------------ -class FileDialogSuperPlus: +class GpcFileDialogSuperPlus: extends FileDialog var show_diretory_types = true : @@ -371,14 +371,14 @@ class FileDialogSuperPlus: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class SaveLoadControl: +class GpcSaveLoad: extends BaseGutPanelControl var btn_load = Button.new() var btn_save = Button.new() - var dlg_load := FileDialogSuperPlus.new() - var dlg_save := FileDialogSuperPlus.new() + var dlg_load := GpcFileDialogSuperPlus.new() + var dlg_save := GpcFileDialogSuperPlus.new() signal save_path_chosen(path) signal load_path_chosen(path) diff --git a/addons/gut/gui/update_required.gd b/addons/gut/gui/update_required.gd new file mode 100644 index 0000000..55edfc3 --- /dev/null +++ b/addons/gut/gui/update_required.gd @@ -0,0 +1,30 @@ +@tool +extends AcceptDialog + +var should_continue = false +var _check_for_update_ctrl = null + +signal closed + +func _ready(): + add_cancel_button("Cancel Loading GUT") + + +func _on_confirmed() -> void: + should_continue = true + closed.emit.call_deferred() + + +func _on_canceled() -> void: + should_continue = false + closed.emit.call_deferred() + + +func _on_close_requested() -> void: + should_continue = false + closed.emit.call_deferred() + + +func set_check_for_update_control(ctrl): + _check_for_update_ctrl = ctrl + add_child(ctrl) diff --git a/addons/gut/gui/update_required.tscn b/addons/gut/gui/update_required.tscn new file mode 100644 index 0000000..bfd21a9 --- /dev/null +++ b/addons/gut/gui/update_required.tscn @@ -0,0 +1,17 @@ +[gd_scene format=3 uid="uid://sduiv3grt5h4"] + +[ext_resource type="Script" uid="uid://bpj4k0w6ft550" path="res://addons/gut/gui/update_required.gd" id="1_rmy01"] + +[node name="UpdateRequired" type="AcceptDialog" unique_id=125541884] +oversampling_override = 1.0 +title = "Invalid GUT Version" +position = Vector2i(0, 36) +size = Vector2i(600, 300) +visible = true +exclusive = false +ok_button_text = "Continue" +script = ExtResource("1_rmy01") + +[connection signal="canceled" from="." to="." method="_on_canceled"] +[connection signal="close_requested" from="." to="." method="_on_close_requested"] +[connection signal="confirmed" from="." to="." method="_on_confirmed"] diff --git a/addons/gut/gut.gd b/addons/gut/gut.gd index 0a1774c..cd8f198 100644 --- a/addons/gut/gut.gd +++ b/addons/gut/gut.gd @@ -2,7 +2,7 @@ extends 'res://addons/gut/gut_to_move.gd' class_name GutMain ## The GUT brains. ## -## Most of this class is for internal use only. Features that can be used are +## Most of this class is for internal use only. Features that can be used ## have descriptions and can be accessed through the [member GutTest.gut] variable ## in your test scripts (extends [GutTest]). ## The wiki page for this class contains only the usable features. @@ -30,9 +30,16 @@ signal end_pause_before_teardown signal start_run signal end_run +## Emitted before every test script instance is created. +## Emitted before [method GutTest.before_all] hook on test is run. +## test_script_obj is an instance of addons/gut/collected_script.gd. signal start_script(test_script_obj) +## Emitted after every test script is run. Emitted after [method GutTest.after_all] hook on test is run. signal end_script +## Emitted before every test method is run. Emitted after [method GutTest.before_each] hook on test is run. +## test_name is the string name of the current test about to be started. signal start_test(test_name) +## Emitted after every test method is run. Emitted after [method GutTest.after_each] hook on test is run. signal end_test @@ -644,10 +651,18 @@ func _run_test(script_inst, test_name, param_index = -1): func get_current_test_orphans(): - var sname = get_current_test_object().collected_script.get_ref().get_filename_and_inner() - var tname = get_current_test_object().name - _orphan_counter.record_orphans(sname, tname) - return _orphan_counter.get_orphan_ids(sname, tname) + var to_return = [] + var ct = get_current_test_object() + if(ct.collected_script != null): + var sname = ct.collected_script.get_ref().get_filename_and_inner() + if(ct.name == &'after_all' or ct.name == &'before_all'): + _orphan_counter.record_orphans(sname) + to_return = _orphan_counter.get_orphan_ids(sname) + to_return.append_array(_orphan_counter.get_orphan_ids(ct.collected_script.get_ref().get_full_name())) + else: + to_return = _orphan_counter.record_orphans(sname, ct.name) + + return to_return # ------------------------------------------------------------------------------ @@ -663,6 +678,7 @@ func _call_before_all(test_script, collected_script): collected_script.setup_teardown_tests.append(before_all_test_obj) _current_test = before_all_test_obj + _current_test.collected_script = weakref(collected_script) _lgr.inc_indent() await test_script.before_all() @@ -688,6 +704,7 @@ func _call_after_all(test_script, collected_script): collected_script.setup_teardown_tests.append(after_all_test_obj) _current_test = after_all_test_obj + _current_test.collected_script = weakref(collected_script) _lgr.inc_indent() await test_script.after_all() diff --git a/addons/gut/gut_cmdln.gd b/addons/gut/gut_cmdln.gd index de6cec8..51c2937 100644 --- a/addons/gut/gut_cmdln.gd +++ b/addons/gut/gut_cmdln.gd @@ -20,7 +20,8 @@ func _init() -> void: var max_iter := 20 var iter := 0 - var Loader : Object = load("res://addons/gut/gut_loader.gd") + # Make a reference to gut_loader so its _static_init is run. + var Laoder : Object = load("res://addons/gut/gut_loader.gd") # Not seen this wait more than 1. while(Engine.get_main_loop() == null and iter < max_iter): diff --git a/addons/gut/gut_constants.gd b/addons/gut/gut_constants.gd new file mode 100644 index 0000000..e1b964d --- /dev/null +++ b/addons/gut/gut_constants.gd @@ -0,0 +1,130 @@ +class_name GutConstants + +const TYPE_STRINGS = { + TYPE_NIL : 'TYPE_NIL', + TYPE_BOOL : 'TYPE_BOOL', + TYPE_INT : 'TYPE_INT', + TYPE_FLOAT : 'TYPE_FLOAT', + TYPE_STRING : 'TYPE_STRING', + TYPE_VECTOR2 : 'TYPE_VECTOR2', + TYPE_VECTOR2I : 'TYPE_VECTOR2I', + TYPE_RECT2 : 'TYPE_RECT2', + TYPE_RECT2I : 'TYPE_RECT2I', + TYPE_VECTOR3 : 'TYPE_VECTOR3', + TYPE_VECTOR3I : 'TYPE_VECTOR3I', + TYPE_TRANSFORM2D : 'TYPE_TRANSFORM2D', + TYPE_VECTOR4 : 'TYPE_VECTOR4', + TYPE_VECTOR4I : 'TYPE_VECTOR4I', + TYPE_PLANE : 'TYPE_PLANE', + TYPE_QUATERNION : 'TYPE_QUATERNION', + TYPE_AABB : 'TYPE_AABB', + TYPE_BASIS : 'TYPE_BASIS', + TYPE_TRANSFORM3D : 'TYPE_TRANSFORM3D', + TYPE_PROJECTION : 'TYPE_PROJECTION', + TYPE_COLOR : 'TYPE_COLOR', + TYPE_STRING_NAME : 'TYPE_STRING_NAME', + TYPE_NODE_PATH : 'TYPE_NODE_PATH', + TYPE_RID : 'TYPE_RID', + TYPE_OBJECT : 'TYPE_OBJECT', + TYPE_CALLABLE : 'TYPE_CALLABLE', + TYPE_SIGNAL : 'TYPE_SIGNAL', + TYPE_DICTIONARY : 'TYPE_DICTIONARY', + TYPE_ARRAY : 'TYPE_ARRAY', + TYPE_PACKED_BYTE_ARRAY : 'TYPE_PACKED_BYTE_ARRAY', + TYPE_PACKED_INT32_ARRAY : 'TYPE_PACKED_INT32_ARRAY', + TYPE_PACKED_INT64_ARRAY : 'TYPE_PACKED_INT64_ARRAY', + TYPE_PACKED_FLOAT32_ARRAY : 'TYPE_PACKED_FLOAT32_ARRAY', + TYPE_PACKED_FLOAT64_ARRAY : 'TYPE_PACKED_FLOAT64_ARRAY', + TYPE_PACKED_STRING_ARRAY : 'TYPE_PACKED_STRING_ARRAY', + TYPE_PACKED_VECTOR2_ARRAY : 'TYPE_PACKED_VECTOR2_ARRAY', + TYPE_PACKED_VECTOR3_ARRAY : 'TYPE_PACKED_VECTOR3_ARRAY', + TYPE_PACKED_COLOR_ARRAY : 'TYPE_PACKED_COLOR_ARRAY', + TYPE_PACKED_VECTOR4_ARRAY : 'TYPE_PACKED_VECTOR4_ARRAY', + TYPE_MAX : 'TYPE_MAX', +} + +# Values should not be referenced outside of this script. +# Use get_default_return_value. The functions look weird, but they are here +# so that each call to a doubled method returns a unique instance of things for +# anything that would be passed by reference. +static var _default_returns = { + TYPE_NIL : null, + TYPE_BOOL : false, + TYPE_INT : 0, + TYPE_FLOAT : 0.0, + TYPE_STRING : '', + TYPE_VECTOR2 : Vector2.ZERO, + TYPE_VECTOR2I : Vector2i.ZERO, + TYPE_RECT2 : func(): return Rect2(0, 0, 0, 0), + TYPE_RECT2I : func(): return Rect2i(0, 0, 0, 0), + TYPE_VECTOR3 : Vector3.ZERO, + TYPE_VECTOR3I : Vector3i.ZERO, + TYPE_TRANSFORM2D : Transform2D.IDENTITY, + TYPE_VECTOR4 : Vector4.ZERO, + TYPE_VECTOR4I : Vector4i.ZERO, + TYPE_PLANE : Plane.PLANE_XY, + TYPE_QUATERNION : Quaternion.IDENTITY, + TYPE_AABB : func(): return AABB(), + TYPE_BASIS : Basis.IDENTITY, + TYPE_TRANSFORM3D : Transform3D.IDENTITY, + TYPE_PROJECTION : Projection.IDENTITY, + TYPE_COLOR : Color.WHITE, + TYPE_STRING_NAME : &'', + TYPE_NODE_PATH : func(): return NodePath(), + TYPE_RID : func(): return RID(), + TYPE_OBJECT : null, + TYPE_CALLABLE : func(): return Callable(), + TYPE_SIGNAL : null, + TYPE_DICTIONARY : func(): return {}, + TYPE_ARRAY : func(): return [], + TYPE_PACKED_BYTE_ARRAY : func(): return PackedByteArray(), + TYPE_PACKED_INT32_ARRAY : func(): return PackedInt32Array(), + TYPE_PACKED_INT64_ARRAY : func(): return PackedInt64Array(), + TYPE_PACKED_FLOAT32_ARRAY : func(): return PackedFloat32Array(), + TYPE_PACKED_FLOAT64_ARRAY : func(): return PackedFloat64Array(), + TYPE_PACKED_STRING_ARRAY : func(): return PackedStringArray(), + TYPE_PACKED_VECTOR2_ARRAY : func(): return PackedVector2Array(), + TYPE_PACKED_VECTOR3_ARRAY : func(): return PackedVector3Array(), + TYPE_PACKED_COLOR_ARRAY : func(): return PackedColorArray(), + TYPE_PACKED_VECTOR4_ARRAY : func(): return PackedVector4Array(), + # TYPE_MAX : 'TYPE_MAX', +} + +# Seeded with any type constant where the constant name can't be converted to +# a string using pascal case and/or the values need manual conversion. The +# rest are added in _static_init. +static var TYPE_KEYWORDS = { + TYPE_NIL : 'null', + TYPE_BOOL : 'bool', + TYPE_INT : 'int', + TYPE_FLOAT : 'float', +} + + +static var NOT_SET := &"___NOT__SET___" + + +static func _static_init() -> void: + for key in TYPE_STRINGS: + if(!TYPE_KEYWORDS.has(key)): + var n : String = TYPE_STRINGS[key].to_lower() + n = n.lstrip("type_") + TYPE_KEYWORDS[key] = n.to_pascal_case() + + +static func is_not_set(val): + return typeof(val) == TYPE_STRING_NAME and val == NOT_SET + + +static func get_default_return_value(type=null): + if(type == null or typeof(type) != TYPE_INT): + return null + var to_return = null + if(is_not_set(type)): + to_return = null + elif(_default_returns.has(type)): + to_return = _default_returns[type] + if(to_return is Callable): + to_return = to_return.call() + + return to_return \ No newline at end of file diff --git a/addons/gut/gut_plugin.gd b/addons/gut/gut_plugin.gd index a7daeeb..01b2f41 100644 --- a/addons/gut/gut_plugin.gd +++ b/addons/gut/gut_plugin.gd @@ -6,6 +6,8 @@ var MenuManager = load("res://addons/gut/gut_menu.gd") var BottomPanelScene = preload('res://addons/gut/gui/GutBottomPanel.tscn') var GutEditorGlobals = load('res://addons/gut/gui/editor_globals.gd') var GutDock = load('res://addons/gut/gui/gut_dock.gd') +var UpdateRequiredDialog = load('res://addons/gut/gui/update_required.tscn') +var CheckForUpdateControl = load("res://addons/gut/gui/check_for_update.tscn") var _bottom_panel : Control = null var _menu_mgr = null @@ -13,6 +15,8 @@ var _gut_button = null var _gut_window = null var _dock_mode = 'none' var _gut_dock = null +var _update_required = null +var _check_for_update = null func _init(): @@ -20,10 +24,39 @@ func _init(): return +# This checks the Remote file or Local file. This will not download the +# remote file. I don't want to delay startup for any reason. Downloading +# the remote file ocassionally is handled elsewhere. +func _should_continue_loading_gut(): + _check_for_update = CheckForUpdateControl.instantiate() + var to_return = true + + _update_required = UpdateRequiredDialog.instantiate() + get_tree().root.add_child(_update_required) + _update_required.set_check_for_update_control(_check_for_update) + + if(!_check_for_update.update_detector.is_gut_version_valid()): + _update_required.popup_centered() + await(_update_required.closed) + + if(!_update_required.should_continue): + to_return = false + + _update_required.remove_child(_check_for_update) + _update_required.queue_free() + + return to_return + + func _enter_tree(): if(!_version_conversion()): return + var should_continue = await _should_continue_loading_gut() + if(!should_continue): + print("GUT loading canceled. Restart editor to try loading again.") + return + _bottom_panel = BottomPanelScene.instantiate() gut_as_panel() @@ -42,6 +75,14 @@ func _enter_tree(): await get_tree().create_timer(1).timeout # --- + # Kick off a download of the remote versions file if it's been more than + # some number of days since we've downloaded it. + _check_for_update.visible = false + _bottom_panel.add_child(_check_for_update) + var days_since = _check_for_update.update_detector.get_days_since_last_fetch() + if(days_since >= 1): + _check_for_update.update_detector.check_for_update_with_fetch(true) + _bottom_panel.set_interface(get_editor_interface()) _bottom_panel.set_plugin(self) _bottom_panel.load_shortcuts() @@ -54,7 +95,6 @@ func _enter_tree(): GutEditorGlobals.gut_plugin = self - func _version_conversion(): var EditorGlobals = load("res://addons/gut/gui/editor_globals.gd") EditorGlobals.create_temp_directory() @@ -81,20 +121,24 @@ func gut_as_panel(): func toggle_windowed(): - push_warning("You have to right click the GUT tab and choos 'floating'. I cannot do this from a menu anymore.") + push_warning("You have to right click the GUT tab and choose 'floating'. I cannot do this from a menu anymore.") func _exit_tree(): remove_tool_menu_item("GUT") _menu_mgr = null GutEditorGlobals.user_prefs.save_it() + + if(_bottom_panel != null): + _bottom_panel.menu_manager = null - _bottom_panel.menu_manager = null - - remove_dock(_gut_dock) - _gut_dock.queue_free() + if(_gut_dock != null): + remove_dock(_gut_dock) + _gut_dock.queue_free() remove_tool_menu_item("GUT") # made by _menu_mgr + _check_for_update.queue_free() + func show_output_panel(): if(_gut_dock == null or !_gut_dock.is_inside_tree()): diff --git a/addons/gut/gut_tracked_error.gd b/addons/gut/gut_tracked_error.gd index 23725ee..729a26f 100644 --- a/addons/gut/gut_tracked_error.gd +++ b/addons/gut/gut_tracked_error.gd @@ -36,6 +36,8 @@ func to_s() -> String: file, '->', function, '@', line, "\n", "handled: ", handled, "\n", "gut type: ", get_error_type_name(),"\n", + "error_type: ", error_type, "\n", + "editor_notify:", editor_notify, "\n", backtrace, "\n") diff --git a/addons/gut/hook_script.gd b/addons/gut/hook_script.gd index f56bf88..cbc9fd1 100644 --- a/addons/gut/hook_script.gd +++ b/addons/gut/hook_script.gd @@ -33,7 +33,6 @@ func run(): gut.logger.error("Run method not overloaded. Create a 'run()' method in your hook script to run your code.") ## Register inner classes from one or more scripts for doubling. -## `scripts` may be either a script or an array of scripts. ## Only worth calling from pre-run hook, not post-run. func register_inner_classes(script: Script): gut.get_doubler().inner_class_registry.register(script) diff --git a/addons/gut/inner_class_registry.gd b/addons/gut/inner_class_registry.gd index df83bb9..cf17a74 100644 --- a/addons/gut/inner_class_registry.gd +++ b/addons/gut/inner_class_registry.gd @@ -59,6 +59,12 @@ func get_base_resource(inner_class): if(_registry.has(inner_class)): return _registry[inner_class].base_resource +func get_full_path(inner_class): + if(_registry.has(inner_class)): + var entry = _registry[inner_class] + return str(entry.base_path.get_file(), entry.subpath.replace('.', '/')) + else: + return "/Unregistered-Inner-Class" func to_s(): var text = "" diff --git a/addons/gut/input_sender.gd b/addons/gut/input_sender.gd index a94e842..5ea623d 100644 --- a/addons/gut/input_sender.gd +++ b/addons/gut/input_sender.gd @@ -40,7 +40,7 @@ class_name GutInputSender # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class InputQueueItem: +class InputSenderQueueItem: extends Node var events = [] @@ -86,7 +86,7 @@ class InputQueueItem: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class MouseDraw: +class InputSenderMouseDraw: extends Node2D var down_color = Color(1, 1, 1, .25) @@ -214,7 +214,7 @@ func _init(r=null): _tree_items_parent = Node.new() Engine.get_main_loop().root.add_child(_tree_items_parent) - _mouse_draw = MouseDraw.new() + _mouse_draw = InputSenderMouseDraw.new() _tree_items_parent.add_child(_mouse_draw) _mouse_draw.disabled = false @@ -572,14 +572,14 @@ func release_all(): ## Same as [method wait] but only accepts a number of frames to wait. func wait_frames(num_frames): - var item = InputQueueItem.new(0, num_frames) + var item = InputSenderQueueItem.new(0, num_frames) _add_queue_item(item) return self ## Same as [method wait] but only accepts a number of seconds to wait. func wait_secs(num_secs): - var item = InputQueueItem.new(num_secs, 0) + var item = InputSenderQueueItem.new(num_secs, 0) _add_queue_item(item) return self diff --git a/addons/gut/logger.gd b/addons/gut/logger.gd index aab68ab..d9ce723 100644 --- a/addons/gut/logger.gd +++ b/addons/gut/logger.gd @@ -26,18 +26,18 @@ var fmts = { } var _type_data = { - types.debug: {disp='DEBUG', enabled=true, fmt=fmts.bold}, - types.deprecated: {disp='DEPRECATED', enabled=true, fmt=fmts.none}, - types.error: {disp='ERROR', enabled=true, fmt=fmts.red}, + types.debug: {disp='DEBUG', enabled=true, fmt=fmts.bold}, + types.deprecated: {disp='DEPRECATED', enabled=true, fmt=fmts.none}, + types.error: {disp='GUT ERROR', enabled=true, fmt=fmts.red}, types.expected_error: {disp="ExpectedError", enabled=true, fmt=fmts.blue}, - types.failed: {disp='Failed', enabled=true, fmt=fmts.red}, - types.info: {disp='INFO', enabled=true, fmt=fmts.bold}, - types.normal: {disp='NORMAL', enabled=true, fmt=fmts.none}, - types.orphan: {disp='Orphans', enabled=true, fmt=fmts.yellow}, - types.passed: {disp='Passed', enabled=true, fmt=fmts.green}, - types.pending: {disp='Pending', enabled=true, fmt=fmts.yellow}, - types.risky: {disp='Risky', enabled=true, fmt=fmts.yellow}, - types.warn: {disp='WARNING', enabled=true, fmt=fmts.yellow}, + types.failed: {disp='Failed', enabled=true, fmt=fmts.red}, + types.info: {disp='INFO', enabled=true, fmt=fmts.bold}, + types.normal: {disp='NORMAL', enabled=true, fmt=fmts.none}, + types.orphan: {disp='Orphans', enabled=true, fmt=fmts.yellow}, + types.passed: {disp='Passed', enabled=true, fmt=fmts.green}, + types.pending: {disp='Pending', enabled=true, fmt=fmts.yellow}, + types.risky: {disp='Risky', enabled=true, fmt=fmts.yellow}, + types.warn: {disp='GUT WARNING', enabled=true, fmt=fmts.yellow}, } var _logs = { @@ -68,8 +68,8 @@ var _last_yield_text = '' func _init(): - _printers.terminal = GutUtils.Printers.TerminalPrinter.new() - _printers.console = GutUtils.Printers.ConsolePrinter.new() + _printers.terminal = GutUtils.Printers.GutTerminalPrinter.new() + _printers.console = GutUtils.Printers.GutConsolePrinter.new() # There were some problems in the timing of disabling this at the right # time in gut_cmdln so it is disabled by default. This is enabled # by plugin_control.gd based on settings. diff --git a/addons/gut/method_maker.gd b/addons/gut/method_maker.gd index 98a1047..540982d 100644 --- a/addons/gut/method_maker.gd +++ b/addons/gut/method_maker.gd @@ -1,4 +1,4 @@ -class CallParameters: +class MethodMakerCallParameters: var p_name = null var default = null var vararg = false @@ -14,6 +14,8 @@ class CallParameters: return str(p_name, "=", default) + + # ------------------------------------------------------------------------------ # This class will generate method declaration lines based on method meta # data. It will create defaults that match the method data. @@ -32,93 +34,17 @@ class CallParameters: # (usage:7) # }] # default_args [] - -var _lgr = GutUtils.get_logger() const PARAM_PREFIX = 'p_' -# ------------------------------------------------------ -# _supported_defaults -# -# This array contains all the data types that are supported for default values. -# If a value is supported it will contain either an empty string or a prefix -# that should be used when setting the parameter default value. -# For example int, real, bool do not need anything func(p1=1, p2=2.2, p3=false) -# but things like Vectors and Colors do since only the parameters to create a -# new Vector or Color are included in the metadata. -# ------------------------------------------------------ - # TYPE_NIL = 0 — Variable is of type nil (only applied for null). - # TYPE_BOOL = 1 — Variable is of type bool. - # TYPE_INT = 2 — Variable is of type int. - # TYPE_FLOAT = 3 — Variable is of type float/real. - # TYPE_STRING = 4 — Variable is of type String. - # TYPE_VECTOR2 = 5 — Variable is of type Vector2. - # TYPE_RECT2 = 6 — Variable is of type Rect2. - # TYPE_VECTOR3 = 7 — Variable is of type Vector3. - # TYPE_COLOR = 14 — Variable is of type Color. - # TYPE_OBJECT = 17 — Variable is of type Object. - # TYPE_DICTIONARY = 18 — Variable is of type Dictionary. - # TYPE_ARRAY = 19 — Variable is of type Array. - # TYPE_PACKED_VECTOR2_ARRAY = 24 — Variable is of type PackedVector2Array. - # TYPE_TRANSFORM3D = 13 — Variable is of type Transform3D. - # TYPE_TRANSFORM2D = 8 — Variable is of type Transform2D. - # TYPE_RID = 16 — Variable is of type RID. - # TYPE_PACKED_INT32_ARRAY = 21 — Variable is of type PackedInt32Array. - # TYPE_PACKED_FLOAT32_ARRAY = 22 — Variable is of type PackedFloat32Array. - # TYPE_PACKED_STRING_ARRAY = 23 — Variable is of type PackedStringArray. - - -# TYPE_PLANE = 9 — Variable is of type Plane. -# TYPE_QUATERNION = 10 — Variable is of type Quaternion. -# TYPE_AABB = 11 — Variable is of type AABB. -# TYPE_BASIS = 12 — Variable is of type Basis. -# TYPE_NODE_PATH = 15 — Variable is of type NodePath. -# TYPE_PACKED_BYTE_ARRAY = 20 — Variable is of type PackedByteArray. -# TYPE_PACKED_VECTOR3_ARRAY = 25 — Variable is of type PackedVector3Array. -# TYPE_PACKED_COLOR_ARRAY = 26 — Variable is of type PackedColorArray. -# TYPE_MAX = 27 — Marker for end of type constants. -# ------------------------------------------------------ -var _supported_defaults = [] - -func _init(): - for _i in range(TYPE_MAX): - _supported_defaults.append(null) - - # These types do not require a prefix for defaults - _supported_defaults[TYPE_NIL] = '' - _supported_defaults[TYPE_BOOL] = '' - _supported_defaults[TYPE_INT] = '' - _supported_defaults[TYPE_FLOAT] = '' - _supported_defaults[TYPE_OBJECT] = '' - _supported_defaults[TYPE_ARRAY] = '' - _supported_defaults[TYPE_STRING] = '' - _supported_defaults[TYPE_STRING_NAME] = '' - _supported_defaults[TYPE_DICTIONARY] = '' - _supported_defaults[TYPE_PACKED_VECTOR2_ARRAY] = '' - _supported_defaults[TYPE_RID] = '' - - # These require a prefix for whatever default is provided - _supported_defaults[TYPE_VECTOR2] = 'Vector2' - _supported_defaults[TYPE_VECTOR2I] = 'Vector2i' - _supported_defaults[TYPE_RECT2] = 'Rect2' - _supported_defaults[TYPE_RECT2I] = 'Rect2i' - _supported_defaults[TYPE_VECTOR3] = 'Vector3' - _supported_defaults[TYPE_COLOR] = 'Color' - _supported_defaults[TYPE_TRANSFORM2D] = 'Transform2D' - _supported_defaults[TYPE_TRANSFORM3D] = 'Transform3D' - _supported_defaults[TYPE_PACKED_INT32_ARRAY] = 'PackedInt32Array' - _supported_defaults[TYPE_PACKED_FLOAT32_ARRAY] = 'PackedFloat32Array' - _supported_defaults[TYPE_PACKED_STRING_ARRAY] = 'PackedStringArray' + +var _lgr = GutUtils.get_logger() +static var _func_template = GutUtils.get_file_as_text('res://addons/gut/double_templates/function_template.txt') +static var _init_template = GutUtils.get_file_as_text('res://addons/gut/double_templates/init_template.txt') # ############### # Private # ############### -var _func_text = GutUtils.get_file_as_text('res://addons/gut/double_templates/function_template.txt') -var _init_text = GutUtils.get_file_as_text('res://addons/gut/double_templates/init_template.txt') - -func _is_supported_default(type_flag): - return type_flag >= 0 and type_flag < _supported_defaults.size() and _supported_defaults[type_flag] != null - func _make_stub_default(method, index): return str('__gutdbl.default_val("', method, '",', index, ')') @@ -127,19 +53,17 @@ func _make_stub_default(method, index): func _make_arg_array(method_meta): var to_return = [] - var has_unsupported_defaults = false - for i in range(method_meta.args.size()): var pname = method_meta.args[i].name var dflt_text = _make_stub_default(method_meta.name, i) - to_return.append(CallParameters.new(PARAM_PREFIX + pname, dflt_text)) + to_return.append(MethodMakerCallParameters.new(PARAM_PREFIX + pname, dflt_text)) if(method_meta.flags & METHOD_FLAG_VARARG): - var cp = CallParameters.new("args", "") + var cp = MethodMakerCallParameters.new("args", "") cp.vararg = true to_return.append(cp) - return [has_unsupported_defaults, to_return]; + return to_return # Creates a list of parameters with defaults of null unless a default value is @@ -160,20 +84,28 @@ func _get_arg_text(arg_array): # creates a call to the function in meta in the super's class. -func _get_super_call_text(meta, args, singleton): - if meta.flags & MethodFlags.METHOD_FLAG_VIRTUAL_REQUIRED != 0: - return '__gutdbl.gut_ref.get_ref().get_logger().error("Cannot call super() because method %s is abstract."); return null' \ - % meta.name +func _get_super_call_text(parsed_method, singleton): + var return_it = '' + if(parsed_method.return_type_text != 'void'): + return_it = 'return ' + + if parsed_method.meta.flags & MethodFlags.METHOD_FLAG_VIRTUAL_REQUIRED != 0: + if(return_it != ''): + return_it = '; return null' + return '__gutdbl.gut_ref.get_ref().get_logger().error(' + \ + '"Cannot call super() because method %s is abstract.")%s' \ + % [parsed_method.meta.name, return_it] var params = '' - for i in range(args.size()): - params += args[i].p_name - if(i != args.size() -1): + for i in range(parsed_method.args.size()): + params += PARAM_PREFIX + parsed_method.args[i].name + if(i != parsed_method.args.size() -1): params += ', ' + if(singleton != null): - return str('return await __gutdbl.get_singleton().', meta.name, '(', params, ')') + return str(return_it, 'await __gutdbl.get_singleton().', parsed_method.meta.name, '(', params, ')') else: - return str('return await super(', params, ')') + return str(return_it, 'await super(', params, ')') func _get_spy_call_parameters_text(args): @@ -190,10 +122,6 @@ func _get_spy_call_parameters_text(args): return called_with -# ############### -# Public -# ############### - func _get_init_text(meta, args, method_params, param_array): var text = null @@ -205,7 +133,7 @@ func _get_init_text(meta, args, method_params, param_array): if(i != args.size() -1): super_params += ', ' - text = _init_text.format({ + text = _init_template.format({ "func_decleration":decleration, "super_params":super_params, "param_array":param_array, @@ -214,26 +142,22 @@ func _get_init_text(meta, args, method_params, param_array): return text +# ############### +# Public +# ############### + + # Creates a delceration for a function based off of function metadata. All # types whose defaults are supported will have their values. If a datatype # is not supported and the parameter has a default, a warning message will be # printed and the declaration will return null. -func get_function_text(meta, singleton=null): - var method_params = '' +func get_function_text(parsed_method, singleton=null): + var meta = parsed_method.meta var text = null - var result = _make_arg_array(meta) - var has_unsupported = result[0] - var args = result[1] - + var args = _make_arg_array(meta) var param_array = _get_spy_call_parameters_text(args) - if(has_unsupported): - # This will cause a runtime error. This is the most convenient way to - # to stop running before the error gets more obscure. _make_arg_array - # generates a gut error when unsupported defaults are found. - method_params = null - else: - method_params = _get_arg_text(args); + var method_params = _get_arg_text(args); if(param_array == 'null'): param_array = '[]' @@ -242,12 +166,17 @@ func get_function_text(meta, singleton=null): if(meta.name == '_init'): text = _get_init_text(meta, args, method_params, param_array) else: + var return_it = '' + if(parsed_method.return_type_text != 'void'): + return_it = 'return ' + var decleration = str('func ', meta.name, '(', method_params, '):') - text = _func_text.format({ + text = _func_template.format({ "func_decleration": decleration, "method_name": meta.name, "param_array": param_array, - "super_call": _get_super_call_text(meta, args, singleton), + "super_call": _get_super_call_text(parsed_method, singleton), + "return_it": return_it }) return text @@ -261,6 +190,3 @@ func set_logger(logger): _lgr = logger -func get_arg_text(meta): - var parsed = _make_arg_array(meta) - return _get_arg_text(parsed[1]) \ No newline at end of file diff --git a/addons/gut/orphan_counter.gd b/addons/gut/orphan_counter.gd index 313f8b6..ea9057c 100644 --- a/addons/gut/orphan_counter.gd +++ b/addons/gut/orphan_counter.gd @@ -1,7 +1,7 @@ # ------------------------------------------------------------------------------ # It keeps track of the orphans...so this is best name it could ever have. # ------------------------------------------------------------------------------ -class Orphanage: +class GutOrphanage: const UNGROUPED = "Outside Tests" const SUBGROUP_SEP = '->' @@ -82,7 +82,7 @@ class Orphanage: # ------------------------------------------------------------------------------ var _strutils = GutStringUtils.new() -var orphanage : Orphanage = Orphanage.new() +var orphanage : GutOrphanage = GutOrphanage.new() var logger = GutUtils.get_logger() var autofree = GutUtils.AutoFree.new() diff --git a/addons/gut/plugin.cfg b/addons/gut/plugin.cfg index 33adf24..64cd593 100644 --- a/addons/gut/plugin.cfg +++ b/addons/gut/plugin.cfg @@ -3,5 +3,5 @@ name="Gut" description="Unit Testing tool for Godot." author="Butch Wesley" -version="9.6.0" +version="9.7.1" script="gut_plugin.gd" diff --git a/addons/gut/printers.gd b/addons/gut/printers.gd index 1b78b4f..9742356 100644 --- a/addons/gut/printers.gd +++ b/addons/gut/printers.gd @@ -1,7 +1,7 @@ # ------------------------------------------------------------------------------ # Interface and some basic functionality for all printers. # ------------------------------------------------------------------------------ -class Printer: +class GutPrinter: var _format_enabled = true var _disabled = false var _printer_name = 'NOT SET' @@ -45,7 +45,7 @@ class Printer: # Responsible for sending text to a GUT gui. # ------------------------------------------------------------------------------ class GutGuiPrinter: - extends Printer + extends GutPrinter var _textbox = null var _colors = { @@ -127,8 +127,8 @@ class GutGuiPrinter: # result in duplicate output. printraw does not print to the console so i had # to make another one. # ------------------------------------------------------------------------------ -class ConsolePrinter: - extends Printer +class GutConsolePrinter: + extends GutPrinter var _buffer = '' func _init(): @@ -146,8 +146,8 @@ class ConsolePrinter: # ------------------------------------------------------------------------------ # Prints text to terminal, formats some words. # ------------------------------------------------------------------------------ -class TerminalPrinter: - extends Printer +class GutTerminalPrinter: + extends GutPrinter var escape = PackedByteArray([0x1b]).get_string_from_ascii() var cmd_colors = { diff --git a/addons/gut/script_parser.gd b/addons/gut/script_parser.gd index dfac16d..ffde399 100644 --- a/addons/gut/script_parser.gd +++ b/addons/gut/script_parser.gd @@ -3,16 +3,17 @@ const BLACKLIST = [ 'get_script', 'has_method', + '_to_string', ] # ------------------------------------------------------------------------------ -# Combins the meta for the method with additional information. +# Combines the meta for the method with additional information. # * flag for whether the method is local # * adds a 'default' property to all parameters that can be easily checked per # parameter # ------------------------------------------------------------------------------ -class ParsedMethod: +class GutParsedMethod: const NO_DEFAULT = '__no__default__' var _meta = {} @@ -21,7 +22,8 @@ class ParsedMethod: set(val): return; var is_local = false - var _parameters = [] + var args = [] + var return_type_text = 'void' func _init(metadata): _meta = metadata @@ -34,7 +36,22 @@ class ParsedMethod: arg['default'] = _meta.default_args[start_default - i] else: arg['default'] = NO_DEFAULT - _parameters.append(arg) + args.append(arg) + + return_type_text = _get_return_type(metadata) + + func _get_return_type(meta): + var r_meta = meta["return"] + var return_keyword = GutConstants.TYPE_KEYWORDS[r_meta.type] + + if(r_meta.type != 0): + return_keyword = return_keyword + elif(r_meta.usage & PROPERTY_USAGE_NIL_IS_VARIANT != 0): + return_keyword = 'Variant' + else: + return_keyword = 'void' + + return return_keyword func is_eligible_for_doubling(): @@ -72,7 +89,7 @@ class ParsedMethod: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ -class ParsedScript: +class GutParsedScript: # All methods indexed by name. var _methods_by_name = {} @@ -157,7 +174,7 @@ class ParsedScript: methods = _get_native_methods(base_type) for m in methods: - var parsed = ParsedMethod.new(m) + var parsed = GutParsedMethod.new(m) _methods_by_name[m.name] = parsed # _init must always be included so that we can initialize # double_tools @@ -172,7 +189,7 @@ class ParsedScript: methods = thing.get_script_method_list() methods.reverse() for m in methods: - var parsed_method = ParsedMethod.new(m) + var parsed_method = GutParsedMethod.new(m) parsed_method.is_local = true _methods_by_name[m.name] = parsed_method @@ -274,10 +291,13 @@ class ParsedScript: return text + + # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ var scripts = {} + func _get_instance_id(thing): var inst_id = null @@ -312,7 +332,7 @@ func parse(thing, inner_thing=null): inner = instance_from_id(_get_instance_id(inner_thing)) if(obj is Resource or GutUtils.is_native_class(obj)): - parsed = ParsedScript.new(obj, inner) + parsed = GutParsedScript.new(obj, inner) scripts[key] = parsed return parsed diff --git a/addons/gut/singleton_parser.gd b/addons/gut/singleton_parser.gd index 39ce10e..2c5f002 100644 --- a/addons/gut/singleton_parser.gd +++ b/addons/gut/singleton_parser.gd @@ -1,4 +1,4 @@ -class ParsedSingleton: +class GutParsedSingleton: var methods_by_name = {} var enums = {} var properties = {} @@ -14,7 +14,8 @@ class ParsedSingleton: singleton_id = singleton.get_instance_id() for method in ClassDB.class_get_method_list(sname, true): - methods_by_name[method.name] = method + var pm = GutUtils.ScriptCollector.GutParsedMethod.new(method) + methods_by_name[method.name] = pm for e in ClassDB.class_get_enum_list(sname, true): for c in ClassDB.class_get_enum_constants(sname, e): @@ -82,6 +83,6 @@ var singletons = {} func parse(singleton): if(!singletons.has(singleton)): - singletons[singleton] = ParsedSingleton.new(singleton) + singletons[singleton] = GutParsedSingleton.new(singleton) return singletons[singleton] \ No newline at end of file diff --git a/addons/gut/strutils.gd b/addons/gut/strutils.gd index dfef6c6..d9450a0 100644 --- a/addons/gut/strutils.gd +++ b/addons/gut/strutils.gd @@ -83,10 +83,10 @@ func _get_obj_filename(thing): # we do nothing. This just reads better. pass elif(!GutUtils.is_native_class(thing)): - var dict = inst_to_dict(thing) - filename = _get_filename(dict['@path']) - if(str(dict['@subpath']) != ''): - filename += str('/', dict['@subpath']) + if(GutUtils.is_inner_class(thing.get_script())): + filename = GutUtils.inner_class_registry.get_full_path(thing.get_script()) + else: + filename = thing.get_script().resource_path.get_file() return filename diff --git a/addons/gut/stub_params.gd b/addons/gut/stub_params.gd index 145499c..8c7157a 100644 --- a/addons/gut/stub_params.gd +++ b/addons/gut/stub_params.gd @@ -10,7 +10,13 @@ var logger = _lgr : set(val): _lgr = val -var return_val = null +var return_val = GutConstants.NOT_SET : + get(): + if(GutConstants.is_not_set(return_val)): + return null + else: + return return_val +var return_type = TYPE_NIL var stub_target = null var parameters = null # the parameter values to match method call on. var stub_method = null @@ -66,12 +72,15 @@ func _init(target=null, method=null, _subpath=null): _load_defaults_from_metadata(method) is_script_default = true elif(stub_target != null and stub_method != null and typeof(stub_target) != TYPE_STRING): - if(!GutUtils.is_native_class(stub_target)): - var method_list = stub_target.get_method_list() - if(method_list != null): - var meta = GutUtils.find_method_meta(method_list, stub_method) - if(meta != null): - _method_meta = meta + var method_list = null + if(typeof(stub_target) == TYPE_OBJECT and stub_target is GDScript): + method_list = stub_target.get_script_method_list() + elif(!GutUtils.is_native_class(stub_target)): + method_list = stub_target.get_method_list() + if(method_list != null): + var meta = GutUtils.find_method_meta(method_list, stub_method) + if(meta != null): + _method_meta = meta func _load_defaults_from_metadata(meta): @@ -81,6 +90,8 @@ func _load_defaults_from_metadata(meta): values.push_front(null) param_defaults(values) + return_type = meta.return.type + return_val = GutConstants.get_default_return_value(meta.return.type) func _get_method_meta(): @@ -98,10 +109,29 @@ func _error_if_locked(): else: return false +func _is_return_value_valid(val): + var is_valid = true + var meta = _get_method_meta() + if((meta.return.type != 0 or (meta.return.type == 0 and !(meta.return.usage && PROPERTY_USAGE_NIL_IS_VARIANT))) and \ + meta.return.type != typeof(return_val)): + is_valid = false + return is_valid # ------------------------- # Public # ------------------------- +func validate() -> bool: + var meta = _get_method_meta() + var to_return = true + + if(stub_method != '_init' and meta != {} and call_this == null): + if(!_is_return_value_valid(return_val)): + _lgr.error(str("Method [", stub_method, "] was stubbed to return invalid value [", return_val, "].")) + to_return = false + + return to_return + + func to_return(val): if(_error_if_locked()): return @@ -113,7 +143,9 @@ func to_return(val): func to_do_nothing(): - to_return(null) + var meta = _get_method_meta() + if(meta != {}): + to_return(GutConstants.get_default_return_value(meta.return.type)) return self diff --git a/addons/gut/stubber.gd b/addons/gut/stubber.gd index 9a0bd27..eda7ee9 100644 --- a/addons/gut/stubber.gd +++ b/addons/gut/stubber.gd @@ -12,7 +12,7 @@ var _strutils = GutUtils.Strutils.new() var _stub_cache = [] -func _add_cache(): +func _flush_cache(): for stub_params in _stub_cache: stub_params.logger = _lgr @@ -22,6 +22,8 @@ func _add_cache(): if(!stub_params.is_default_override_only()): action_stubs.add_stub(stub_params) + if(!stub_params.is_script_default): + stub_params.validate() # lock the params so that any changes that would affect which bucket # the params were put in can't be changed. stub_params.locked = true @@ -33,7 +35,7 @@ func _add_cache(): # # obj can be an instance, class, or a path. func _find_action_stub(obj, method, parameters=null): - _add_cache() + _flush_cache() var to_return = null var matches = action_stubs.get_all_stubs(obj, method) @@ -77,11 +79,6 @@ func _find_action_stub(obj, method, parameters=null): elif(null_match != null): to_return = null_match - # if(to_return != null): - # print(" USING ", to_return, ' = ', to_return.to_s()) - # else: - # print(" USING null") - return to_return @@ -114,8 +111,15 @@ func get_return(obj, method, parameters=null): if(stub_info != null): return stub_info.return_val else: - _lgr.info(str('Call to [', method, '] was not stubbed for the supplied parameters ', parameters, '. Null was returned.')) - return null + var default = parameter_stubs.get_default_stub(obj, method) + var to_return = null + if(default != null): + # This ensures that the values are unique and that any changes made + # to them in a test are not propigated to future calls of the same + # method. + to_return = GutConstants.get_default_return_value(default.return_type) + _lgr.info(str('Call to [', method, '] was not stubbed for the supplied parameters ', parameters, '. [', to_return, '] was returned.')) + return to_return func should_call_super(obj, method, parameters=null): @@ -146,7 +150,7 @@ func get_call_this(obj, method, parameters=null): func get_parameter_defaults(obj, method): - _add_cache() + _flush_cache() var the_defaults = [] var script_defaults = [] var matches = parameter_stubs.get_all_stubs(obj, method) @@ -190,8 +194,8 @@ func set_logger(logger): func to_s(): - return str("Parameters:\n", parameter_stubs.to_s(), - "\nActions:\n" , action_stubs.to_s()) + return str("Parameter Stubs:\n", parameter_stubs.to_s(), + "\nAction Stubs:\n" , action_stubs.to_s()) func stub_defaults_from_meta(target, method_meta): diff --git a/addons/gut/stubs.gd b/addons/gut/stubs.gd index 1e802b7..4fe2589 100644 --- a/addons/gut/stubs.gd +++ b/addons/gut/stubs.gd @@ -1,10 +1,10 @@ # ------------- # { -# object(script or instance):{ +# object(script or instance) or StringName(native class name):{ # method_name1: [StubParams, StubParams], # method_name2: [StubParams, StubParams] # }, -# object(script or instance):{ +# object(script or instance) or StringName(native class name):{ # method_name1: [StubParams, StubParams], # method_name2: [StubParams, StubParams] # } @@ -13,9 +13,11 @@ var stubs = {} func _normalize_stub_target(target): var to_return = null - if(typeof(target) == TYPE_OBJECT or GutUtils.is_native_class(target)): + if(GutUtils.is_native_class(target)): + to_return = GutUtils.strutils.type2str(target) + elif(typeof(target) == TYPE_OBJECT): to_return = target - if(typeof(target) == TYPE_STRING): + elif(typeof(target) == TYPE_STRING): if(FileAccess.file_exists(target)): to_return = load(target) else: @@ -42,8 +44,8 @@ func _get_entries_matching_target(target): match_on.push_front(trav) else: var type_name = current.get_instance_base_type() - trav = GutUtils.class_ref_by_name[type_name] - match_on.push_front(trav) + match_on.push_front(type_name) + trav = null done = true if(trav == null): @@ -81,6 +83,18 @@ func get_all_stubs(thing, method): return matches +func get_default_stub(thing, method): + var obj = _normalize_stub_target(thing) + var match_on = _get_entries_matching_target(obj) + var to_return = null + for entry in match_on: + if(stubs.has(entry) and stubs[entry].has(method)): + var method_stubs = stubs[entry][method] + for stub in method_stubs: + if(stub.is_script_default): + to_return = stub + return to_return + func to_s(): var text = '' for thing in stubs: diff --git a/addons/gut/summary.gd b/addons/gut/summary.gd index c95982d..0b862c0 100644 --- a/addons/gut/summary.gd +++ b/addons/gut/summary.gd @@ -192,6 +192,15 @@ func get_totals(gut=_gut): return totals +func log_version_update(gut): + var ud = GutUtils.UpdateDetector.new() + ud.check_for_update() + var recommended = ud.get_gut_version_for_godot_version() + if(recommended != GutUtils.version_numbers.gut_version): + gut.get_logger().log(ud.get_update_string()) + ud.free() + + func log_end_run(gut=_gut): var totals = get_totals(gut) if(totals.tests == 0): @@ -207,4 +216,5 @@ func log_end_run(gut=_gut): _log_what_was_run(gut) log_the_final_line(totals, gut) + log_version_update(gut) lgr.log("") diff --git a/addons/gut/test.gd b/addons/gut/test.gd index af976bf..fd41caa 100644 --- a/addons/gut/test.gd +++ b/addons/gut/test.gd @@ -259,6 +259,9 @@ func _get_bad_method_message(inst, method_name, what_you_cant_do): to_return = str("You cannot ", what_you_cant_do, " [", method_name, "] because the method does not exist. ", "This can happen if the method is virtual and not overloaded (i.e. _ready) ", "or you have mistyped the name of the method.") + elif(GutUtils.ScriptCollector.BLACKLIST.has(method_name)): + to_return = str("Method '", method_name, "' cannot be stubbed because it ", + "is excluded by GUT when creating doubles.") elif(!inst.__gutdbl_values.doubled_methods.has(method_name)): to_return = str("You cannot ", what_you_cant_do, " [", method_name, "] because ", _str(inst), ' does not overload it or it was ignored with ', @@ -2086,9 +2089,7 @@ func assert_no_new_orphans(text=''): var msg = '' if(text != ''): msg = ': ' + text - # Note that get_counter will return -1 if the counter does not exist. This - # can happen with a misplaced assert_no_new_orphans. Checking for > 0 - # ensures this will not cause some weird failure. + if(count > 0): msg += str("\n", _strutils.indent_text(gut.get_orphan_counter().get_orphan_list_text(orphan_ids), 1, ' ')) _fail(str('Expected no orphans, but found ', count, msg)) diff --git a/addons/gut/test_collector.gd b/addons/gut/test_collector.gd index a5a6682..c934c3e 100644 --- a/addons/gut/test_collector.gd +++ b/addons/gut/test_collector.gd @@ -77,6 +77,7 @@ func _parse_script(test_script): test_script.path, GutUtils.warnings_when_loading_test_scripts) + GutUtils.inner_class_registry.register(loaded) if(_does_inherit_from_test(loaded)): _populate_tests(test_script) scripts_found.append(test_script.path) diff --git a/addons/gut/update_detector.gd b/addons/gut/update_detector.gd new file mode 100644 index 0000000..0fce023 --- /dev/null +++ b/addons/gut/update_detector.gd @@ -0,0 +1,346 @@ +extends Node +## ----------------------------------------------------------------------------- +## Checks to see if there is a better version of GUT available for a version of +## Godot. The data used to validate the GUT version includes lower and upper +## Godot versions +## +## There are 3 places where version information is located. +## * LOCAL_FILE_PATH: This is the version information that is packed with this +## release of GUT. It serves as a fallback if remote data is not available. +## This is most useful in detecting that GUT is being used with an earlier +## release of Godot and remote data is not available. +## * REMOTE_FILE_URL: This is where the the version information exists outside +## of the local copy of GUT. This data will be downlaoded to REMOTE_FILE_PATH +## whenever remote data is fetched. +## * REMOTE_FILE_PATH: This is where REMOTE_FILE_URL is downloaded to. When +## the file is downloaded, timetamp information is added to the data so that +## we can avoid downloading the file too often. This file is used whenever +## it exists. If it does not exist and we don't fetch it, LOCAL_FILE_PATH +## will be used. +## +## REMOTE_FILE_URL Location +## Currently this file points to a file on the main branch. This is the same +## file that will be shipped with each version of GUT. This allows the file to +## be updated and still be shipped with each version of GUT. +## ----------------------------------------------------------------------------- +var Vnt = load("res://addons/gut/version_numbers.gd").VerNumTools + + +const REMOTE_FILE_URL = "https://api.github.com/repos/bitwes/gut/contents/addons/gut/versions.json" +const LOCAL_FILE_PATH = "res://addons/gut/versions.json" +const REMOTE_FILE_PATH = "user://gut_temp_directory/versions.json" +const VERSION_ZERO = "0.0.0" + +class VersionData: + var _data := {} + var data_issues = [] + const VERSION_ZERO = "0.0.0" + + var Vnt = load("res://addons/gut/version_numbers.gd").VerNumTools + + + func is_gut_version_valid(gut_v, godot_v): + if(_data.releases.has(gut_v)): + var entry = _data.releases[gut_v] + return Vnt.is_version_gte(godot_v, entry.godot_min) and Vnt.is_version_lte(godot_v, entry.godot_max) + else: + return false + + + func parse_data(new_data): + data_issues.clear() + _data = {} + if(typeof(new_data) == TYPE_STRING): + _data = JSON.parse_string(new_data) + elif(typeof(new_data) == TYPE_DICTIONARY): + _data = new_data + + if(!_data.has('asset_library')): + data_issues.append("asset_library entry missing") + + if(_data.has('releases')): + for key in _data.releases: + var entry = _data.releases[key] + if(!entry.has('godot_min')): + data_issues.append(str(key, ' missing godot_min')) + if(!entry.has('godot_max')): + data_issues.append(str(key, ' missing godot_max')) + else: + data_issues.append('missing releases entry') + + if(_data.has('branches')): + for key in _data.branches: + var entry = _data.branches[key] + if(!entry.has('godot_min')): + data_issues.append(str(key, ' missing godot_min')) + if(!entry.has('godot_max')): + data_issues.append(str(key, ' missing godot_max')) + else: + data_issues.append('missing branches entry') + + + func parse_file(path): + if(FileAccess.file_exists(path)): + var text = GutUtils.get_file_as_text(path) + parse_data(text) + else: + _data = {} + + + func get_gut_version_for_godot_version(godot_v=null): + var to_return = VERSION_ZERO + if(is_empty()): + return to_return + + if(godot_v == null): + godot_v = GutUtils.version_numbers.make_godot_version_string() + + for key in _data.releases: + var entry = _data.releases[key] + if(Vnt.is_version_gte(godot_v, entry.godot_min) and Vnt.is_version_lte(godot_v, entry.godot_max)): + if(Vnt.is_version_gte(key, to_return)): + to_return = key + + if(to_return == VERSION_ZERO and _data.has('branches')): + for key in _data.branches: + var entry = _data.branches[key] + if(Vnt.is_version_gte(godot_v, entry.godot_min) and Vnt.is_version_lte(godot_v, entry.godot_max)): + to_return = key + + return to_return + + func is_empty(): + return _data.is_empty() + + func clear(): + _data.clear() + data_issues.clear() + + ## See comment in get_update_string + # func is_in_asset_library(gut_v): + # if(_data.has('asset_library')): + # return _data.asset_library == gut_v + # else: + # return false + + func get_data(): + return _data.duplicate(true) + + +var _http_request : HTTPRequest +var local_data : VersionData = VersionData.new() +var remote_data : VersionData = VersionData.new() + +var min_fetch_wait = 60 * 60 # 1 hour + +signal download_completed() +signal updated() + + +func _ready() -> void: + _setup_http_request(HTTPRequest.new()) + + +func _setup_http_request(request): + _http_request = request + add_child(_http_request) + _http_request.timeout = 3.0 + _http_request.request_completed.connect(self._http_request_completed) + + +func _write_remote_file(data): + data.fetch_timestamp = Time.get_unix_time_from_system() + GutUtils.write_file(REMOTE_FILE_PATH, JSON.stringify(data)) + + +func _url_formatter(url, link_text=null): + if(link_text == null): + return url + else: + return str(link_text, ': ', url) + + +#------------ +# Events +#------------ +# Called when the HTTP request is completed. +func _http_request_completed(result, response_code, headers, body): + var body_text = body.get_string_from_utf8() + + if(response_code == 200): + var json = JSON.new() + var err = json.parse(body_text) + if(err != OK): + push_error("[GUT] Invalid JSON: ", json.get_error_message(), '. ', body_text) + download_completed.emit() + return + var response = json.get_data() + + remote_data.parse_data(response) + if(remote_data.data_issues.size() == 0): + _write_remote_file(response.duplicate(true)) + else: + push_error("[GUT] Invalid version data: ", remote_data.data_issues) + remote_data.clear() + else: + var json = JSON.new() + var err = json.parse(body_text) + var response = {} + if(err == OK): + response = json.get_data() + + var msg = '' + if(response != null and response.has('message')): + msg = str(" (", response.message, ")") + push_error("[GUT] Could not get version info, response code: ", response_code, msg) + + download_completed.emit() + + +func _is_branch_version(v : String): + return v.find(".") == -1 +#------------ +# Public +#------------ +func fetch_remote_file(): + var headers : PackedStringArray = [ + "Accept: application/vnd.github.raw", + "X-GitHub-Api-Version: 2022-11-28" + ] + var error = _http_request.request(REMOTE_FILE_URL, headers) + if error != OK: + var errtxt = str("[GUT] An error occurred requesting version data: ", error, ".") + remote_data.data_issues.append(errtxt) + push_error(errtxt) + return error + + +func get_gut_version_for_godot_version(godot_v=null): + var to_return = VERSION_ZERO + if(godot_v == null): + godot_v = GutUtils.version_numbers.make_godot_version_string() + + var remote_latest = remote_data.get_gut_version_for_godot_version(godot_v) + var local_latest = local_data.get_gut_version_for_godot_version(godot_v) + + if(remote_latest == VERSION_ZERO and local_latest != VERSION_ZERO): + to_return = local_latest + elif(remote_latest != VERSION_ZERO and local_latest == VERSION_ZERO): + to_return = remote_latest + elif(_is_branch_version(remote_latest) and !_is_branch_version(local_latest)): + to_return = local_latest + elif(Vnt.is_version_gte(remote_latest, local_latest)): + to_return = remote_latest + else: + to_return = local_latest + + return to_return + + +func is_gut_version_valid(gut_v =null, godot_v=null): + if(gut_v == null): + gut_v = GutUtils.version_numbers.gut_version + godot_v = GutUtils.version_numbers.make_godot_version_string() + + if(!local_data.is_empty() and !remote_data.is_empty()): + return local_data.is_gut_version_valid(gut_v, godot_v) or \ + remote_data.is_gut_version_valid(gut_v, godot_v) + else: + return true + +## See comment in get_update_string +# func is_in_asset_library(gut_v): +# if(remote_data._data.has('asset_library')): +# return remote_data._data.asset_library == gut_v +# else: +# return false + + +func check_for_update(): + local_data.parse_file(LOCAL_FILE_PATH) + if(FileAccess.file_exists(REMOTE_FILE_PATH)): + remote_data.parse_file(REMOTE_FILE_PATH) + + updated.emit.call_deferred() + + +func check_for_update_with_fetch(force=false): + remote_data.parse_file(REMOTE_FILE_PATH) + var time_since_last_fetch = 60 * 60 * 24 * 10_000 # ten thousand days + + if(remote_data._data.has("fetch_timestamp")): + time_since_last_fetch = Time.get_unix_time_from_system() - remote_data._data.fetch_timestamp + + if(force or time_since_last_fetch > min_fetch_wait): + fetch_remote_file() + await download_completed + + check_for_update() + + +func get_update_string(url_formatter:Callable=_url_formatter): + var gut_v = GutUtils.version_numbers.gut_version + var godot_v = GutUtils.godot_version_string() + var version_info = str("GUT ", gut_v, " is the lastest version for Godot ", godot_v) + + var rec_ver = get_gut_version_for_godot_version(godot_v) + var rec_ver_link = url_formatter.call(str("https://github.com/bitwes/Gut/releases/tag/v", rec_ver), str("GUT ",rec_ver)) + + if(is_gut_version_valid(gut_v, godot_v)): + if(rec_ver != gut_v): + version_info = str(rec_ver_link, ' is now available!') + else: + if(rec_ver.find(".") == -1): + version_info = str("GUT does not have a release for this version of Godot yet, but it does have ", + "the branch '", rec_ver, "'.\n", + "Check the readme for install links/instructions: ", url_formatter.call('https://github.com/bitwes/Gut')) + else: + version_info = str('This version of GUT may not be compatible with Godot ', godot_v, '. ') + if(rec_ver == '0.0.0'): + version_info += str("No release or branch exists for this version of Godot yet. Check back soon.") + else: + version_info += str('Consider changing to ', rec_ver_link) + ## Commented this out for now, this needs to be reassessed for the new store + ## For now I'm leaving it out as I don't know what the urls look like or have + ## anything out there yet. + # if(rec_ver != gut_v and is_in_asset_library(rec_ver)): + # version_info += str("\nYou can update to ", rec_ver, " through the Asset Library.") + return version_info + + +func get_summary_string(): + var gut_v = GutUtils.version_numbers.gut_version + var godot_v = GutUtils.godot_version_string() + + return str("GUT: ", gut_v, "\n", + "Godot: ", godot_v, "\n", + "Valid: ", is_gut_version_valid(gut_v, godot_v), "\n", + "Latest: ", get_gut_version_for_godot_version(godot_v)) + + +func fetch_limit_wait_time(): + var remaining = -1 + if(remote_data.get_data().has("fetch_timestamp")): + var time_since_last_fetch = Time.get_unix_time_from_system() - remote_data._data.fetch_timestamp + return max(min_fetch_wait - time_since_last_fetch, 0.0) + else: + return -1 + + +func get_days_since_last_fetch(): + var to_return = 99 + if(remote_data.get_data().has("fetch_timestamp")): + var time_since_last_fetch = Time.get_unix_time_from_system() - remote_data._data.fetch_timestamp + to_return = time_since_last_fetch / (60.0 * 60.0 * 24.0) + return to_return + + +func is_empty(): + return local_data.is_empty() and remote_data.is_empty() + + +func get_all_data(): + return { + local_data:local_data.get_data(), + remote_data:remote_data.get_data() + } diff --git a/addons/gut/utils.gd b/addons/gut/utils.gd index 1d6bda6..3bea3a9 100644 --- a/addons/gut/utils.gd +++ b/addons/gut/utils.gd @@ -2,8 +2,6 @@ class_name GutUtils extends Object -const GUT_METADATA = '__gutdbl' - # Note, these cannot change since places are checking for TYPE_INT to determine # how to process parameters. enum DOUBLE_STRATEGY{ @@ -16,6 +14,13 @@ enum DIFF { SIMPLE } +enum TREAT_AS { + NOTHING, + FAILURE, +} + +const GUT_METADATA = '__gutdbl' + const TEST_STATUSES = { NO_ASSERTS = 'no asserts', SKIPPED = 'skipped', @@ -37,24 +42,13 @@ const NOTHING := '__NOTHING__' const NO_TEST := 'NONE' const GUT_ERROR_TYPE = 999 -enum TREAT_AS { - NOTHING, - FAILURE, -} - -static var class_ref_by_name = {} : - get(): - if(class_ref_by_name == {}): - class_ref_by_name = _create_class_dictionary() - return class_ref_by_name; - - ## This dictionary defaults to all the native classes that we cannot call new ## on. It is further populated during a run so that we only have to create ## a new instance once to get the class name string. static var gdscript_native_class_names_by_type = { - Tween:"Tween" + Tween:"Tween", + CanvasItem:"CanvasItem", } @@ -194,16 +188,17 @@ static var TestCollector = LazyLoader.new('res://addons/gut/test_collector.gd'): static var ThingCounter = LazyLoader.new('res://addons/gut/thing_counter.gd'): get: return ThingCounter.get_loaded() set(val): pass +static var UpdateDetector = LazyLoader.new('res://addons/gut/update_detector.gd'): + get: return UpdateDetector.get_loaded() + set(val): pass # -------------------------------- static var gut_fonts = GutFonts.new() static var avail_fonts = gut_fonts.get_font_names() +static var strutils = Strutils.new() static var version_numbers = VersionNumbers.new( - # gut_versrion (source of truth) - '9.6.0', - # required_godot_version - '4.6' + '9.7.1' # gut_versrion (source of truth) ) @@ -234,34 +229,13 @@ static func get_error_tracker(): _error_tracker = GutErrorTracker.new() return _error_tracker - +static var inner_class_registry = InnerClassRegistry.new() # ############################################################################## # Methods # ############################################################################## -# So...I couldn't figure out how to get to a reference for a GDNative Class -# using a string. ClassDB has all thier names...so I made a hash using those -# names and the classes. Then I dynmaically make a script that has that as -# the source and grab the hash out of it and return it. Super Rube Golbergery, -# but tons of fun. -# -# This is lazy loaded into class_ref_by_name, it's only needed when finding -# stubs. -static func _create_class_dictionary(): - var text = "var all_the_classes: Dictionary = {\n" - var black_list = [ - ] - for classname in ClassDB.get_class_list(): - if(!black_list.has(classname) and (ClassDB.can_instantiate(classname) or GodotSingletons.names.has(classname))): - text += str('"', classname, '": ', classname, ", \n") - - text += "}" - var inst = GutUtils.create_script_from_source(text, 'res://dynamically_generated/class_dictionary.gd').new() - return inst.all_the_classes - - # This must be static so that the scripts are counted. static var _dyn_gdscript = DynamicGdScript.new() @@ -314,15 +288,10 @@ static func make_install_check_text(template_paths=DOUBLE_TEMPLATES, ver_nums=ve !FileAccess.file_exists(template_paths.SCRIPT)): text = 'One or more GUT template files are missing. If this is an exported project, you must include *.txt files in the export to run GUT. If it is not an exported project then reinstall GUT.' - elif(!ver_nums.is_godot_version_valid()): - text = ver_nums.get_bad_version_text() return text -static func is_install_valid(template_paths=DOUBLE_TEMPLATES, ver_nums=version_numbers): - return make_install_check_text(template_paths, ver_nums) == INSTALL_OK_TEXT - # ------------------------------------------------------------------------------ # Gets the value from an enum. @@ -647,7 +616,12 @@ static func find_method_meta(methods, method_name): static func get_method_meta(object, method_name): - return find_method_meta(object.get_method_list(), method_name) + if(object is GDScript): + return find_method_meta(object.get_script_method_list(), method_name) + elif(is_native_class(object)): + return find_method_meta(ClassDB.class_get_method_list(strutils.type2str(object)), method_name) + else: + return find_method_meta(object.get_method_list(), method_name) static func is_singleton(thing): diff --git a/addons/gut/version_conversion.gd b/addons/gut/version_conversion.gd index fe37578..114a946 100644 --- a/addons/gut/version_conversion.gd +++ b/addons/gut/version_conversion.gd @@ -1,4 +1,4 @@ -class ConfigurationUpdater: +class GutConfigurationUpdater: var EditorGlobals = load("res://addons/gut/gui/editor_globals.gd") func warn(message): @@ -47,8 +47,8 @@ class ConfigurationUpdater: else: info(str(' ', 'Deleted ', which)) -class v9_2_0: - extends ConfigurationUpdater +class Gutv9_2_0: + extends GutConfigurationUpdater func validate(): moved_file('res://.gut_editor_config.json', EditorGlobals.editor_run_gut_config_path) @@ -116,5 +116,5 @@ static func error_if_not_all_classes_imported() -> bool: static func convert(): - var inst = v9_2_0.new() + var inst = Gutv9_2_0.new() inst.validate() diff --git a/addons/gut/version_numbers.gd b/addons/gut/version_numbers.gd index c8c0f32..2476424 100644 --- a/addons/gut/version_numbers.gd +++ b/addons/gut/version_numbers.gd @@ -12,7 +12,7 @@ class VerNumTools: return parts - static func make_version_array(v): + static func make_version_array(v, min_spots=3): var to_return = [] if(typeof(v) == TYPE_STRING): to_return = _make_version_array_from_string(v) @@ -20,6 +20,11 @@ class VerNumTools: return [v.major, v.minor, v.patch] elif(typeof(v) == TYPE_ARRAY): to_return = v + + if(to_return.size() < min_spots): + for i in range(min_spots - to_return.size()): + to_return.append(0) + return to_return @@ -51,6 +56,24 @@ class VerNumTools: # still null means each index was the same. return GutUtils.nvl(is_ok, true) + static func is_version_lte(version, required): + var is_lt = null + var v = make_version_array(version) + var r = make_version_array(required) + + var idx = 0 + + while(is_lt == null and idx < v.size() and idx < r.size()): + if(v[idx] < r[idx]): + is_lt = true + elif(v[idx] > r[idx]): + is_lt = false + + idx += 1 + + # still null means each index was the same. + return GutUtils.nvl(is_lt, true) + static func is_version_eq(version, expected): var version_array = make_version_array(version) @@ -84,11 +107,10 @@ class VerNumTools: # # ############################################################################## var gut_version = '0.0.0' -var required_godot_version = '0.0.0' -func _init(gut_v = gut_version, required_godot_v = required_godot_version): +func _init(gut_v = gut_version): gut_version = gut_v - required_godot_version = required_godot_v + # ------------------------------------------------------------------------------ @@ -101,22 +123,5 @@ func get_version_text(): return godot_version_info + "\n" + gut_version_info -# ------------------------------------------------------------------------------ -# Returns a nice string for erroring out when we have a bad Godot version. -# ------------------------------------------------------------------------------ -func get_bad_version_text(): - var info = Engine.get_version_info() - var gd_version = str(info.major, '.', info.minor, '.', info.patch) - return 'GUT ' + gut_version + ' requires Godot ' + required_godot_version + \ - ' or greater. Godot version is ' + gd_version - - -# ------------------------------------------------------------------------------ -# Checks the Godot version against required_godot_version. -# ------------------------------------------------------------------------------ -func is_godot_version_valid(): - return VerNumTools.is_version_gte(Engine.get_version_info(), required_godot_version) - - func make_godot_version_string(): return VerNumTools.make_version_string(Engine.get_version_info()) diff --git a/addons/gut/versions.json b/addons/gut/versions.json new file mode 100644 index 0000000..4465533 --- /dev/null +++ b/addons/gut/versions.json @@ -0,0 +1,39 @@ +{ + "asset_library":"9.6.0", + "branches":{ + "main":{ + "godot_min":"4.6", + "godot_max":"4.6.999" + } + }, + "releases":{ + "9.7.1":{ + "godot_min":"4.7", + "godot_max":"4.7.999" + }, + "9.7.0":{ + "godot_min":"4.7", + "godot_max":"4.7.999" + }, + "9.6.1":{ + "godot_min":"4.6", + "godot_max":"4.6.999" + }, + "9.6.0":{ + "godot_min":"4.6", + "godot_max":"4.6.999" + }, + "9.5.0":{ + "godot_min":"4.5", + "godot_max":"4.5.999" + }, + "9.4.0":{ + "godot_min":"4.3", + "godot_max":"4.4.999" + }, + "9.3.0":{ + "godot_min":"4.2", + "godot_max":"4.2.999" + } + } +} diff --git a/llms.txt b/llms.txt index 4fc418c..ebf6d75 100644 --- a/llms.txt +++ b/llms.txt @@ -1,6 +1,6 @@ # Card Combat Engine -A headless, domain-agnostic turn-based card combat engine for **Godot 4.6 / +A headless, domain-agnostic turn-based card combat engine for **Godot 4.7 / GDScript**. Handles the *logic* of a card battle — turn FSM, mana, draw, attack/defense/block, damage resolution, and pluggable AI — and exposes every game-specific rule as an injectable `Callable`. @@ -101,7 +101,7 @@ not a game taxonomy — game taxonomies (Weapon, Terrain, Rarity) belong in | `addons/card_combat/combat_trigger_queue.gd` | Deferred trigger FIFO (QUEUED trigger mode) | | `addons/card_combat/hidden_card_stats.gd` | Declared vs hidden stats for bluffing | | `addons/card_combat/abilities/ability_library.gd` | Opt-in keyword ability handler | -| `test/` | GUT 9.6 test suite — 465 cases across 21 files | +| `test/` | GUT 9.7.1 test suite — 465 cases across 21 files | | `addons/card_combat/examples/demo.tscn` | Runnable smoke-check demo | | `addons/card_combat/benchmark/combat_benchmark.gd` | Performance / leak measurement | @@ -188,7 +188,7 @@ Full working example: `addons/card_combat/examples/demo.tscn`. godot --headless -s addons/gut/gut_cmdln.gd -gdir=res://test -ginclude_subdirs -gexit ``` -418 test cases (GUT 9.6) across: FSM, mana ramp, serialization/resume, +465 test cases (GUT 9.7.1) across: FSM, mana ramp, serialization/resume, determinism, AI contract, all AbilityLibrary keywords, trigger queue (INLINE vs QUEUED), multi-sided topology, command replay, and leak detection. diff --git a/project.godot b/project.godot index a889cbe..b8edd8a 100644 --- a/project.godot +++ b/project.godot @@ -11,7 +11,7 @@ config_version=5 [application] config/name="Combat Card System" -config/features=PackedStringArray("4.6", "GL Compatibility") +config/features=PackedStringArray("4.7", "GL Compatibility") config/icon="res://icon.svg" [debug]