- NAME
- VERSION
- DESCRIPTION
- SYNOPSIS
- METHODS
  - Class Methods
    - new
    - state_class
    - state_manager
    - add_rc_file
    - process_args
    - run
    - require_harness
    - print_version
  - Attributes
- PLUGINS
  - Sample Plugin
- SEE ALSO

# NAME

App::Prove - Implements the `prove` command.

# VERSION

Version 3.44

# DESCRIPTION

Test::Harness provides a command, `prove`, which runs a TAP based test suite and prints a report. The `prove` command is a minimal wrapper around an instance of this module.

# SYNOPSIS

    use App::Prove;

    my $app = App::Prove->new;
    $app->process_args(@ARGV);
    $app->run;

# METHODS

## Class Methods

### `new`

Create a new `App::Prove`. Optionally a hash ref of attribute initializers may be passed.

### `state_class`

Getter/setter for the name of the class used for maintaining state. This class should either subclass from `App::Prove::State` or provide an identical interface.

### `state_manager`

Getter/setter for the instance of the `state_class`.

### `add_rc_file`

    $prove->add_rc_file('myproj/.proverc');

Called before `process_args` to prepend the contents of an rc file to the options.

### `process_args`

    $prove->process_args(@args);

Processes the command-line arguments. Attributes will be set appropriately. Any filenames may be found in the `argv` attribute.

Dies on invalid arguments.

### `run`

Perform whatever actions the command line args specified. The `prove` command line tool consists of the following code:

    use App::Prove;

    my $app = App::Prove->new;
    $app->process_args(@ARGV);
    exit( $app->run ? 0 : 1 );  # if you need the exit code

### `require_harness`

Load a harness replacement class.

    $prove->require_harness($for => $class_name);

### `print_version`

Display the version numbers of the loaded TAP::Harness and the current Perl.

## Attributes

After command line parsing the following attributes reflect the values of the corresponding command line switches. They may be altered before calling `run`.

`archive`
`argv`
`backwards`
`blib`
`color`
`directives`
`dry`
`exec`
`extensions`
`failures`
`comments`
`formatter`
`harness`
`ignore_exit`
`includes`
`jobs`
`lib`
`merge`
`modules`
`parse`
`plugins`
`quiet`
`really_quiet`
`recurse`
`rules`
`show_count`
`show_help`
`show_man`
`show_version`
`shuffle`
`state`
`state_class`
`taint_fail`
`taint_warn`
`test_args`
`timer`
`verbose`
`warnings_fail`
`warnings_warn`
`tapversion`
`trap`

# PLUGINS

`App::Prove` provides support for 3rd-party plugins. These are currently loaded at run-time, after arguments have been parsed (so you can not change the way arguments are processed, sorry), typically with the `-Pplugin` switch, eg:

    prove -PMyPlugin

This will search for a module named `App::Prove::Plugin::MyPlugin`, or failing that, `MyPlugin`. If the plugin can't be found, `prove` will complain & exit.

You can pass an argument to your plugin by appending an `=` after the plugin name, eg `-PMyPlugin=foo`. You can pass multiple arguments using commas:

    prove -PMyPlugin=foo,bar,baz

These are passed in to your plugin's `load()` class method (if it has one), along with a reference to the `App::Prove` object that is invoking your plugin:

    sub load {
        my ($class, $p) = @_;

        my @args = @{ $p->{args} };
        # @args will contain ( 'foo', 'bar', 'baz' )
        $p->{app_prove}->do_something;
        ...
    }

Note that the user's arguments are also passed to your plugin's `import()` function as a list, eg:

    sub import {
        my ($class, @args) = @_;
        # @args will contain ( 'foo', 'bar', 'baz' )
        ...
    }

This is for backwards compatibility, and may be deprecated in the future.

## Sample Plugin

Here's a sample plugin, for your reference:

    package App::Prove::Plugin::Foo;

    # Sample plugin, try running with:
    # prove -PFoo=bar -r -j3
    # prove -PFoo -Q
    # prove -PFoo=bar,My::Formatter

    use strict;
    use warnings;

    sub load {
        my ($class, $p) = @_;
        my @args = @{ $p->{args} };
        my $app  = $p->{app_prove};

        print "loading plugin: $class, args: ", join(', ', @args ), "\n";

        # turn on verbosity
        $app->verbose( 1 );

        # set the formatter?
        $app->formatter( $args[1] ) if @args > 1;

        # print some of App::Prove's state:
        for my $attr (qw( jobs quiet really_quiet recurse verbose )) {
            my $val = $app->$attr;
            $val    = 'undef' unless defined( $val );
            print "$attr: $val\n";
        }

        return 1;
    }

    1;

# SEE ALSO

prove, TAP::Harness