Pod::Trac - Convert a POD to trac's wiki syntax and add it to the trac

    use Pod::Trac;

    my $trac = Pod::Trac->new({url => "http", login => "mylogin", passwd => "mypass"});
    $trac->from_file({file => "myfile.pm"});
    # or
    $trac->from_path({path => "/my/path/", file_filter => "pm"});

    Extract POD from your sources, convert them to the trac's wiki syntax, and create or update the
    page with the new document

    set $self->pod_rev to the revision of the current page
    set $self->pod_url to the url of the page created/updated
    push in $self->{created_path} the $self->pod_rev and $self->pod_url

package Pod::Trac;

use warnings;
use strict;
use Carp;

use File::Util;
use URI::Escape;
use HTTP::Request::Common qw(POST);
use LWP::UserAgent;
use HTTP::Cookies;
use Pod::Simple::Wiki;

use base qw( Class::Accessor::Fast );
__PACKAGE__->mk_accessors( qw(form_token pod_url pod_rev) );

our $VERSION = '0.0.1';

sub init {
    my ( $self ) = @_;
    $self->{ ua } = LWP::UserAgent->new;
    $self->{ ua }->cookie_jar( {} );

    my $req = HTTP::Request->new( GET => $self->{ trac_url } . "/login" );
    $req->authorization_basic( $self->{ login }, $self->{ passwd } );

    my $response = $self->{ ua }->request( $req );

    # are we logged in ?
    if ( !$response->is_success ) {
        croak( "Can't login on this trac, check your login" );
    }
    my $cookie = $response->request->headers->{ cookie };
    $cookie =~ /trac_form_token=(.*);/;
    $self->form_token( $1 );
}

sub generate {
    my ( $self, $file ) = @_;

    my ( $parser, $wiki );

    # convert the pod to wiki syntax
    $parser = Pod::Simple::Wiki->new( 'moinmoin' );
    $parser->output_string( \$wiki );
    $parser->parse_file( $file );

    return if length $wiki < 1;

    # send data to trac
    $self->write_to_trac( $wiki, $file );
}

sub write_to_trac {
    my ( $self, $poddata, $podname ) = @_;

    $poddata = uri_escape( $poddata );
    $podname =~ s/(\.\.\/)//g;

    $self->pod_url( $self->{ trac_url } . "/wiki/" . $podname );

    $self->pod_rev( 0 );
    my $req = HTTP::Request->new( GET => $self->pod_url );
    my $response = $self->{ ua }->request( $req );

    if ( $response->is_success ) {
        if ( $response->content
             =~ /<input type="hidden" name="version" value="(\d+?)" \/>/ )
        {
            $self->pod_rev( $1 );
        }
    }

    $req = HTTP::Request->new( POST => $self->pod_url );
    $req->content_type( 'application/x-www-form-urlencoded' );
    $req->content(   "__FORM_TOKEN="
                   . $self->form_token
                   . "&action=edit&version="
                   . $self->pod_rev
                   . "&text="
                   . $poddata
                   . "&save=Submit+changes" );
    $response = $self->{ ua }->request( $req );
    push @{ $self->{ created_path } },
        { pod_url => $self->pod_url, pod_rev => $self->pod_rev };
}

sub from_file {
    my ( $self, $params ) = @_;

    croak( "Please give me a file" ) unless defined $$params{ 'file' };
    $self->init();
    $self->generate( $$params{ file } );

}

sub from_path {
    my ( $self, $params ) = @_;

    croak( "Please give me a path" ) unless defined $$params{ 'path' };
    $self->init();
    my $f     = File::Util->new();
    my @files = $f->list_dir( $$params{ 'path' },
                              qw/--files-only --recurse --no-fsdots/ );

    foreach my $file ( @files ) {
        if ( defined $$params{ 'filter' } ) {
            if (grep { $file =~ /\.$_$/} @{$$params{filter}}){
                $self->generate( $file );
            }
        }
    }
}

1;
__END__