Add optional type casting to command arguments

[CollCaz]

I think it should be possible to type cast arguments, for example:

example:
Running [ command int(3) ] in the cosole:

func _main(argv: Array, data) -> Dictionary:
    output(argv[1]) # outputs 3
    output(typeof(argv[1])) # outputs 4 (meaning string)
    output(typed_argv[1])) #outputs 3
    output(typeof(typed_argv[1])) #outputs 2 (meaning int)

This may or may not be better if implemented in the base GDShellCommand resource rather than per command, idk.

would store the first argument in argv[] as int, the second as a float and the last one as a string.

This would be very useful when creating commands that call a function or a signal, so you could pass in arguments to that function or signal in the expected type.

This could be done with regex and, GDScript's built in type casting.

I plan to implement this feature, as I am also working on the emit_signal command from issue #15 and, also plan on creating a command that calls functions from nodes.

[Kubulambula]

This may or may not be better if implemented in the base GDShellCommand resource rather than per command, idk.

I agree. I would definitely put it inside GDShellCommand as I can imagine it would be used quite often.

We can do a function that takes a String from argv and tries to convert it to a Variant with the correct type.

Then we could make a second function that would take the argv as it's parameter and go through it with the conversion function and return a new Array of converted arguments.

[Kubulambula]

I know that str_to_var() can convert variants like vectors from string, but it has to be in a precise format, that might not be known to the user.

[CollCaz]

OK after a little bit of messing around with str_to_var() i can see some problems.

The vector types need to be declared as vectors Vector2(1, 3) Vector3(3, 5, 6) and so on
Nodes will be converted to a string holding all of their information

So im not sure if this is the right thing to use.

I think simply declaring every variable type would be simpler and more consistent, like in my first comment.
int(3) float(3.5) vector(23, 5) node(path/to/node) and so on

[Kubulambula]

I think simply declaring every variable type would be simpler and more consistent, like in my first comment. int(3) float(3.5) vector(23, 5) node(path/to/node) and so on

Yeah, that would probably be the best option for this use case. I can't think of anything else.

[Kubulambula]

As I am going through the command suggestions, almost all would benefit from this, so it would be great to implement this at some point and maybe rework GDShellCommand.argv_parse_options() with it

[CollCaz]

Sorry, I'm not sure how to implement this.
Would I add the actual value of a command argument to the options dictionary? Would the key then be it's index in the argv array?
So one could access the int value in command int(2) var x = options[1] so that print(x) prints 2 and typeof(x) returns the value for int.

Or did you have something else in mind.

[Kubulambula]

I meant that we could make a function that gets one argument from argv and converts it to the correct type. Then we could rework argv_parse_options() to use that function in the future.

Also I would convert numbers like 1 to int even without the int() and 1.0 or .1 to float without float() surrounding it, so that you can go it either way as I can imagine numbers would be really common to use as arguments.