XPMArgumentParser

A short, awesome, and really useful tool for rapidly parsing command-line arguments in a declarative manner using Objective-C.

XPMArgumentSignature
  * force = [XPMArgumentSignature argumentSignatureWithFormat:@"[-f --force]"],
  * soft = [XPMArgumentSignature argumentSignatureWithFormat:@"[-s --soft]"],
  * outputFile = [XPMArgumentSignature argumentSignatureWithFormat:@"[-o --output-file of]=",
  * inputFile = [XPMArgumentSignature argumentSignatureWithFormat:@"[-i --input-file if]={1,}"];
  
NSArray * signatures = @[force, soft, outputFile, inputFile];

XPMArgumentPackage * package =
 [[NSProcessInfo currentProcess] xpmargs_parseArgumentsWithSignatures:signatures];

if ([package booleanValueOfSignature:soft]) {
    // presumably you'd do something
}

if ([package firstObjectForSignature:inputFile]) {
    printf("dude, you gotta specify a file!\n");
    return -1;
}

Updates

2016

Removed CoreParse as a dependency, making it easier to include this project for everyone.
Reprefixed away from reserved prefix for filesystem work, now using XPM prefix. Should be a simple find/replace to update.

Features: It Just Works

You're probably already excited about the nice format ctors, which are admittedly a nice touch. But the real power of XPMArgumentParser is on the command line. It's designed to "just work" in a variety of situations.

Flag Grouping

It seems natural to us: we like to group flags together. tar -cvvf, anyone? XPMArgumentParser understands that quite well.

Equals Signs

Some tools require an equals sign for value assignment (foo -f=t works, but foo -f t doesn't). XPMArgumentParser doesn't mind either formats.

Multiple Values in a Group

Supposing you have two or more flags that require values, how does that work? XPMArgumentParser gives you two ways to work:

    # the long way
spiffy -i file1 -o file2
    # the lazy way
spiffy -io file1 file2

Personally, I prefer the lazy way. The values are assigned respective to the order of the flags in the group. Note that equals signs are not really logical in argument groups. If you do something like -cfg=file.txt, it will assign file.txt to f (if that's the first flag that takes a value), but it will not do anything fancy, like force that flag to take only one value if it supports multiple values. For that you need to use a barrier.

Many Values per Argument

New in this version is the ability to have more than one value per time an argument is invoked. You define the number of arguments per invocation as a range, minimum to maximum.

XPMArgumentSignature * files =
    [XPMArgumentSignature argumentSignatureWithFormat:@"[-f --files]={1,5}"];

And boom, you can specify between one and five files per time you use the -f flag. You might think that this could be a little awkward if you have a flag group with two flags that take multiple arguments. Well, it isn't. XPMArgumentParser understands "value barriers," which segregate between lists of values. A value barrier is either two dashes (--), or any other kind of argument invocation. So, given the following:

XPMArgumentSignature
  *inFiles = [XPMArgumentSignature argumentSignatureWithFormat:@"[-f --input-files]={1,5}"],
  *outputFiles = [XPMArgumentSignature argumentSignatureWithFormat:@"[-o --output-files]={1,5}"];

// on the command line:

foo -ofv ouput1 output2 output3 -- input1 input2 input3 input4 # use the double-dash to separate
foo -of ouput1 output2 output3 -v input1 input2 input3 input4 # use the verbose flag to separate

See how it "just works" for you?

Undecorated Arguments

Who here is in love with how the dd utility takes its arguments? So perhaps not many, but XPMArgumentParser understands that, too.

foo if=infile of=outfile

Is perfectly valid. This can also be used to create "subcommands."

foo commit -Am "Why are you reinventing git?"

Argument Injection

Wouldn't it be nice to build out a tree of possible arguments, with some arguments which are scanned if and only if a certain argument is present? So thought I, which is why the following invocation could be created like this:

foo commit -Am "Why are you reinventing git?"

// can be accomplished with

XPMArgumentSignature * commitSubcommand =
  [XPMArgumentSignature argumentSignatureWithFormat:@"[commit]"];
[commitSubcommand setInjectedSignatures:[NSSet setWithObjects:
  [XPMArgumentSignature argumentSignatureWithFormat:@"[-A --all]"],
  [XPMArgumentSignature argumentSignatureWithFormat:@"[-m --commit-message]="], nil]];

Descriptions

By default the -description method returns a very simple programmer-friendly text. However, you can use the descriptionHelper block property on XPMArgumentSignature. A different description method which you can call for emitting command-line help will use this. For example:

XPMArgumentSignature * verbose = [XPMArgumentSignature argumentSignatureWithFormat:@"[-v --verbose]"];
XPMArgumentSignature * help = [XPMArgumentSignature argumentSignatureWithFormat:@"[-h --help]"];

[verbose setDescriptionHelper:(NSString *)(^)(XPMArgumentSignature * currentSignature, NSUInteger indentLevel, NSUInteger terminalWidth) {
    return [@"-v --verbose  Emit more information." xpmargs_mutableStringByIndentingToWidth:indentLevel * 2 lineLength:terminalWidth];
}];
[help setDescriptionHelper:(NSString *)(^)(XPMArgumentSignature * currentSignature, NSUInteger indentLevel, NSUInteger terminalWidth) {
    return [@"-h --help     Show this message." xpmargs_mutableStringByIndentingToWidth:indentLevel * 2 lineLength:terminalWidth];
}];

XPMArgumentPackage * package = 
 [[NSProcessInfo processInfo] xpmargs_parseArgumentsWithSignatures:[NSSet setWithObjects:verbose, help, nil]];

if ([package booleanValueOfFlag:help]) {
    struct winsize ws;
    ioctl(0, TIOCGWINSZ, &ws);

    printf("My Really Cool CLI Tool v0.1\n\n");
    printf("%s\n", [[verbose descriptionForHelpWithIndent:2 width:ws.ws_col] UTF8String]);
    printf("%s\n", [[help descriptionForHelpWithIndent:2 width:ws.ws_col] UTF8String]);
    printf("\n(C) 2012 by Your Face. All your base are belong to us.\n");
}

Alternatives

BRLOptionParser - An Objective-C wrapper for getopt_long. Looks to be well-constructed.

mysteriouspants/ArgumentParser