NAME

Getopt::optparse - optparse style processing of command line options

This library supports both single and double dash options. An equal sign must be used.

SYNOPSIS

    use Getopt::optparse;
    my $parser = Getopt::optparse->new();
    $parser->add_option(
        '--hostname', 
        {
            dest    => 'hostname',
            help    => 'Remote hostname',
            default => 'localhost.localdomain'
        }
    );
    $parser->add_option( 
        '--global', {
            dest    => 'global',
            action  => 'store_true',
            help    => 'Show global',
            default => 0
        }
    );
    $parser->add_option(
        '--username', 
        {
            dest   => 'username',
            action => 'append',
            help   => 'Usernames to analyze'
        }
    );
    $parser->add_option(
        '-v', 
        {
            dest   => 'verbose',
            action => 'count',
            help   => 'Increment verbosity'
        }
    );

    my $options = $parser->parse_args();
    printf("Hostname is: %s\n", $options->{hostname});
    printf("Username is: %s\n", $options->{username});

    if ($options->{global}) {
    }

    for my $uname (@{$options->{username}}) {
        print $uname, "\n";
    }

DESCRIPTION

Library which allows Python optparse style processing of command line options.

CONSTRUCTOR

$parser = Getopt::optparse->new( \%options )

Construct a new Getopt::optparse object and return it. Hash reference argument may be provided though none are required.

METHODS

The following methods are available:

Getopt::optparse->add_option( 'optionname', {option_attributes} )

Add option to be parsed from command line. Accepts two arguments. Both are required:

    $parser->add_option(
        '--hostname',
        {
            dest => 'hostname',
            help => 'Remote hostname',
            default => 'localhost.localdomain'
        }
    )

Option Name (required)

Value to be parsed from command line. --hostname in the above example. This library supports both single and double dash option names..

Option Attributes hash reference (required)

These may include:

dest (required)

Name of key were parsed option will be stored.

default (optional)

Value of dest if no option is parsed on command line.

help (optional)

Text message displayed when -h or --help is found on command line.

action (optional)

The following actions are supported.

store_true

Using this makes dest true or false (0 or 1) if the option name is found on the command line.

append

Using this appends each occurrance of an option to an ARRAY reference if option name is found on the command line.

count

Using this increments dest by one for every occurrence if option name is found on the command line.

callback (optional)

Allows user to pass code reference which is executed after Getopt::optparse->parse_args() is run. The callback has access to to all parsed options from command line. Placed here as not to clobber other actions.

    # This example uses a callback to validate that user accounts don't already exist.
    $parser->add_option(
        '-username', 
        {
            dest     => 'username',
            action   => 'append',
            help     => 'Username for new ILO account',
            callback => sub {
                my ($parser, $options) = @_;
                for my $uname (@{$options->{username}}) {
                    if ($uname) {
                         my $code = system(sprintf("getent passwd %s 2>&1 > /dev/null", $uname));
                         if (! $code) {
                             printf("Error: -username provided already exists: %s\n", $uname);
                             exit 1;
                         }
                     }
                     else {
                         printf("Error: -username provided not defined: %s\n", $uname);
                         exit 2;
                     }
                 }
             }
         }
    );

    # This example uses a callback to ensure a hostname is resolvable.
    $parser->add_option(
        '-hostname', 
        {
            dest     => 'hostname',
            help     => 'Remote hostname',
            default  => 'cpan.perl.org',
            callback => sub {
                my ($parser, $options) = @_;
                my $hostname = $options->{hostname};
                if ($hostname) {
                    if ($hostname =~ /(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/) {
                        printf("Error: -hostname should be resolvable fqdn not IP: %s\n", $hostname);
                        exit 3;
                    }
                    if (! gethostbyname($hostname)) {
                        printf("Error: unable to resolve -hostname: %s\n", $hostname);
                        exit 4;
                    }
                }
            }
        }
    );

    # This example uses a callback to validate password integrity.
    $parser->add_option(
        '-password', 
        {
            dest     => 'password',
            help     => 'Password for account',
            callback => sub {
                my ($parser, $options) = @_;
                my $password = $options->{password};
                if ($password) {
                    if ($password !~ /^(?=.*[0-9])(?=.*[A-Z])(?=.*[a-z])/s || (length($options->{password}) < 10)) {
                        print "Error: Password should be at least 10 characters, contain numbers and a lower and upper case letters.\n";
                        exit 5;
                    }
                }
            }
        }
       
    );

Getopt::optparse->parse_args()

Parse added options from command line and return their values as a hash reference.

    my $options = $parser->parse_args();

    printf("Hostname is: %s\n", $options->{hostname});

    for my $uname (@{$options->{username}}) {
        print $uname, "\n";
    }

AUTHOR

Matt Hersant <matt_hersant@yahoo.com>