Parsing strategy .optional

[msalmonse]

I wanted to add a —draft option to my command but I wanted to be able to optionally specify the draft text i.e. —draft or —draft Entwurf. Unfortunately I couldn't think of a way to handle it.

I think that there is a case for having optional arrays although I think there that specifying a minimum and maximum number of elements would be better.

I don't think that there is a good way of handling this with standard types so maybe a custom type should be a requirement, one that could take an optional value as an argument.

[swiftyfinch]

Hi, I need something similar!
I use the option --focus and sometimes want to add some strings. Like --focus Alamofire.
But I can't use [String]? in the Option property wrapper.

I wonder maybe there is another way to get such behavior?

[msalmonse]

After giving it some thought I think that rather than flag and option a minimum and maximum number of arguments is more flexible. A flag is then 0…0, an option is 1…1, what I want is 0…1.

[swiftyfinch]

Sorry, I'm not sure that I understand you.
You can use Flag like 0 or 1 and Option like 0 or 1 as well. But also, Option can be an array. So it will be a collection with zero or more elements.

But I need the third state of Option:

Command                         | Swift
---------------------------------------------------------------------------------
rugby				| let focus: [String]? = nil
rugby --focus			| let focus: [String]? = []
rugby --focus Alamofire SnapKit | let focus: [String]? = ["Alamofire", "SnapKit"]

[msalmonse]

Not 0 or 1 but 0 to 1, it is a closed range of the number of arguments allowed, a flag has none or 0…0, an option 1…1 or 1… depending on your parsing strategy in the current setup.

[swiftyfinch]

I found that there is init with initial: nil. But when I run my command its demands this argument.

swift-argument-parser/Sources/ArgumentParser/Parsable Properties/Option.swift

Lines 496 to 509 in 992a745

	public init<Element>(
	name: NameSpecification = .long,
	parsing parsingStrategy: ArrayParsingStrategy = .singleValue,
	help: ArgumentHelp? = nil,
	completion: CompletionKind? = nil
	) where Element: ExpressibleByArgument, Value == Array<Element> {
	self.init(
	initial: nil,
	name: name,
	parsingStrategy: parsingStrategy,
	help: help,
	completion: completion
	)
	}

[swiftyfinch]

Also, as a workaround I can use rugby --focus none.
Then parse none and consider that focus is nil.

[natecook1000]

This isn't currently supported, mostly because there isn't a great way to model it cleanly. It might make sense as a double Optional, but those are awkward to work with. Maybe we could add an Optional-esque type:

struct Example: ParsableCommand {
    @Option var kind: OptionValue<String>?

    func run() {
        print(kind as Any)
    }
}

$ example
nil
$ example --kind
.flagOnly
$ example --kind foo
.value(foo)

Still strikes me as a bit gross… Any other ideas?

[swiftyfinch]

Hey, @natecook1000 why we can use it like this:

@Option var kind: [String]?

Like it already works with non-collection types.

I can try to make a draft if it suits.
I see that need to change the array parsing strategy, but maybe there are some pitfalls.

[msalmonse]

I found another way to do it

[Jomy10]

@msalmonse Mind sharing your solution? :)

[msalmonse]

I wrote my own parser with a min and max count for parameters. I fixed the negative numbers problem as well and threw in environmental variables.

SAP is very good but… I remember a comparison of Windows with Linux: in Windows the easy is easy and the difficult is impossible while in Linux it's all just hard.

[Jomy10]

@msalmonse Thank you for the reply!