# NAME

Command::Do - The power of the Sun in the palm of your hand

# VERSION

version 0.05

# SYNOPSIS

in yourcmd:

    use YourCmd;
    YourCmd->run;

in lib/YourCmd.pm

    package YourCmd;
    

    use Command::Do;
    

    field name => {
        required => 1,
        alias    => 'n',
        optspec  => '=s'
    };
    

    method run => {
        

        input => ['name'],
        using => sub {
            

            exit print "You sure have a nice name, " . shift->name;
            

        }
        

    };

and, finally, at the command line:

    $ yourcmd --name "Handsome"
    You sure have a nice name, Handsome

or, ... use one CLI (command-line interface) to rule them all.

    #!/usr/bin/env perl
    

    package Bit;
    

    use Command::Do;
    

    set {
        

        # load child classes (commands)
        classes => 1
        

    };
    

    fld command => {
    

        required   => 1,
        min_length => 2,
        filters    => ['trim', 'strip', sub { $_[0] =~ s/\W/\_/g; $_[0] }]
    

    };
    

    mth run => {
    

        input => ['command'],
        using => sub {
        

            my ($self) = @_;
            

            my $class = $self->class($self->command);
            

            if ($class) {
                

                $class->run # run child command class
                

            }
        

        }
    

    };
    

    bld sub {
        

        my ($self) = @_;
        

        $self->command(shift @ARGV); 
        

    };
    

    package main;
    

        Bit->new->run
    

    1;

# DESCRIPTION

Command::Do is an extremely easy method for creating, validating, executing, and
organizing command-line applications. Command::Do inherits most of its
functionality from the ever-awesome [Validation::Class](http://search.cpan.org/perldoc?Validation::Class) and [Getopt::Long](http://search.cpan.org/perldoc?Getopt::Long).

Command::Do is both simple, effective and anti-complicated. It is very
unassumming and flexible. It does not impose a particular application
configuration and its dependencies are trivial.

It doesn't provide a mechanism for rendering help and/or command and options
screens. The trend I'd recommend for that purpose is to simply display the
command's POD, if that doesn't suit you, building your own help text rendering
function is trivial.

Command::Do is very minimalistic and tries to remain unassuming, each class
field (see [Validation::Class](http://search.cpan.org/perldoc?Validation::Class)) that is to be used as a command line option
must have an `optspec` directive defined. The optspec directive should be a
valid [Getopt::Long](http://search.cpan.org/perldoc?Getopt::Long) option specification minus a name and aliases which are
deduced from the field name and alias directive.

    package ...;
    use Command::Do;
    

    field verbose => {
        optspec => '', # sets flag, same as '!'
        alias   => 'v'
    };
    

    # this is the equivalent to the following Getopt::Long statement
    # GetOptions('verbose|v!' => \$variable);

Furthermore, in addition to being a class that represents a command that does
stuff, Command::Do is:

    com-man-do: A soldier specially trained to carry out raids.
    

    In English, the term commando means a specific kind of individual soldier or
    military unit. In contemporary usage, commando usually means elite light
    infantry and/or special operations forces units, specializing in amphibious
    landings, parachuting, rappelling and similar techniques, to conduct and
    effect attacks. (per wikipedia)

... which is how I like to think about the command-line scripts I author.

# AUTHOR

Al Newkirk <awncorp@cpan.org>

# COPYRIGHT AND LICENSE

This software is copyright (c) 2012 by awncorp.

This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.