NAME

Perlbug::Do - Commands (switches) for generic interface to perlbug database.

DESCRIPTION

Methods for various functions against the perlbug database.

Those that have the form /do(?i:a-z)/ all return something relevant.

To be printed, returned by email, etc.

SYNOPSIS

Note that all do...() methods expect to recieve one of the following arguments:

Either a string, an arrayref, or a hashref (helpful - huh?)

        my $h_cmds = $o_do->parse_input($line); # parse string

        print $o_do->process_commands($h_cmds); # calls do($cmd, $args) foreach 

METHODS

new

Create new Perlbug::Do object:

        my $o_do = Perlbug::Do->new();

parse_input

Parses the given line into a reference to a command hash, this is also where the input should be massaged into the correct format for each method call.

Wraps input2args(), override on a per interface basis, where appropriate.

Input line is expected to look like: -h -b (bugid)+ -r (keywords)+ ...

    my $h_cmds = $o_do->parse_input($line); 

parse_line

parse_input without the input2args

    my $h_cmds = $o_do->parse_input($line); 

return_type

Return appropriate type of argument wanted given command

        my $wanted = $self->return_type($cmd);

        eg:
                b -> ARRAY 
                P -> HASH
                s -> SCALAR 

input2args

Handles email input, calls SUPER::input2args()

        my $cmd_args = $o_do->input2args($cmd, $args);

process_commands

Interface to all do() methods, calls SUPER::process_commands().

        my @res = $o_do->process_commands(\%args);

Where %args looks something like this:

        my %args = (    
                'a'     => \@categories_status_etc,
                'B' => \%new_data,      
                'b' => \@bug_ids,
                'h' => \%extra_info,
                'l'     => $date || '',
                'q' => $sql_query,
                'z' => $config_type,
                'Z' => [($type, $string)],
        ); 

do

Wrap a Perlbug::dox command where 'x' may be any alphabetic character.

Each do() command returns the product of it's call for output.

    print "Bugs(@bugids): ".join('', $pb->do('b', \@bugids));

    print "New bug: ".join('', $pb->do('B', '', $newbug));

    print "New msg: ".join('', $pb->do('M', $bugidstring, $message)); # Base 

    print "New msg: ".join('', $pb->do('M', $bugidstring, \%mail));   # Email

doa

ONLY do this if registered as admin

        my @res = $o_do->doa($command_string);

doA

Wrapper for doa(), calls dob() also.

        my @res = $o_do->doa($command_string);

dob

Return the formatted bug by id/s

    my @res = $o_do->dob(@bugids);

doB

Create new bug, returning id.

    my $bugid = $o_do->doB(\%bug);

doc

Get the patches, or bugs for this changeid

        my @res = $o_do->doc(\@cids);   

doC

Create a new changeid

        my $cid = $o_do->doC($h_args);

dod

Switches debugging on (1).

        my $level_set = $o_do->dod($level);

doD

Dumps database for backup and recovery.

        my $feedback = $o_do->doD($date);

database_dump_command

Returns database dump command (mysql/oracle) for given date (or full) and target file.

else undef

    my $cmd = $o_do->database_dump_command($date, $file);

doe

Add email address to any cc's 'Cc:' to "-e me.too@some.where.org"

        my $i_set = $o_do->doe($cc_addrs);

doE

Send an email notify() about th(is|ese) bugid/s, as if the email was newly recieved.

        my $i_ok = $o_obj->doE(\@bugids); 

dof

Sets the appropriate format for use by Formatter methods, overrides default 'a' set earlier.

        my $feedback = $o_obj->dof('h'); 

dog

Return the formatted group by id/s

    my @res = $o_do->dog(\@groupids);

doG

Create new group

    my $new_gid = $o_do->doG($h_args);

doh

Returns help message built from a hash_ref

Syntax for the hash is 'key => description (sample args)':

        print $o_obj->doh({ 
                'e' => 'email me a copy too (email@address.com)',       
                # add 'H' => 'Help - more detailed info ()',                    
                # replace 'z' => '',                                            
        }); 
        

doi

Retrieve by index (group, status, etc.)

        my @res = $o_do->doi($str); 

doI

Wrapper for doi(), in large format

        my @res = $o_do->doI('open');

doj

Just test for a response - produces "$title $version => ok"

        my @res = $o_do->doj(@args); 

dok

Klaim the bug(id) given

        my $feedback = $o_do->dok(\@bids);

doK

UnKlaim the bug(id) given

        my $feedback = $o_do->doK(\@bids);

dol

Just the stored log results from this process.

        my $process_log = $o_do->dol($max_lines_from_end);

doL

Returns the current (or given later) logfile.

        my $LOG = $o_do->doL($date);

dom

Return the formatted message by id/s

    my @data = $o_do->dom(\@messageids);

doM

Create new message

    my $new_mid = $o_do->doM($h_args);

don

Return the formatted user by id/s

        my @res = $o_do->don(\@nids);

doN

Creates new note (assigns to given bugid).

        my $nid = $self->doN($h_args);

doo

Returns a summary overview of the bugs, bugs, messages etc. in the database.

        my @over = $o_do->doo();

stats

Get stats from db for overview usage.

        my $h_data = $self->stats;

dop

Return the formatted patch by id/s

    my @res = $o_do->dop(\@patchids);

doP

Assign to given bugid, given patch, return new patch_id

        $pid = $o_obj->doP($h_args);

doq

Gets the sql _q_ query statement given in the body of the message, executes it, and returns the result in the result array.

        my @results = $o_do->doq($sql);

doQ

Returns the database schema, for use with SQL statements.

        my @tables_data = $o_do->doQ;

dor

Retrieve data based on contents of the body of a bug

    my @res = $o_do->dor('object initialisation problem');

doR

Wrapper for dor(), in large format

    my @res = $o_do->doR('object initialisation problem');

dos

Retrieve bugs based on the subject line of a bug

    my @res = $o_do->dos('build failure');

doS

Wrapper for dos() in 'large format'

        my @RES = $o_do->doS('some subject');   

        and R

    foreach my $bid (@args) {
                push(@res, $o_bug->read($bid)->format());
                
                my @mids = $o_bug->rel_ids('message');
                my ($mid) = sort { $a <=> $b } @mids;
        push(@res, $self->dom(\@mids));
                
        my @pids = $o_bug->rel_ids('patch');
        push(@res, $self->dop(\@pids));
                
        my @tids = $o_bug->rel_ids('test');
        push(@res, $self->dot(\@tids));
                
        my @nids = $o_bug->rel_ids('note');
        push(@res, $self->don(\@nids));
    }

dot

Return the formatted test by id/s

    my @res = $o_do->dot(\@testids);

doT

Assign to given bugid, given test, return i_ok

        $new_tid = $o_obj->doT($h_args);

dou

Return the formatted user by id/s

    my @res = $o_do->dou(\@userids);

doU

Create new user entry

        my $uid = $self->doU($h_args);

Initiate new admin entry, including htpasswd entry, (currently rf only)

        userid          = test_user:
        password        = p*ss33*t:
        address         = perlbugtest@rfi.net:
        match_address =.*\@rfi\.net:
        name            = Richard Foley:

dov

Volunteer proposed bug modifications where msg is something like: 'propose_close_<bugid>@bugs.perl.org'

        my $i_ok = $o_obj->dov($h_args);

doV

Volunteer a new administrator

        my $feedback = $o_do->doV($h_args);

dox

Delete bug from db_bug table.

Use doX for messages associated with bugs.

        my @feedback = $o_do->dox(\@bids);

doX

Delete given bugs along with messages from db_message.

Also does parent/child, bug_user, etc. tables, also calls dox()

        my @feedback = $o_do->doX(\@bids);

doy

Password renewal

    my $i_ok = $o_do->doy("$user $pass");

doz

Retrieve configuration data

    $data = $o_obj->doz([qw(current email target)]);

doZ

Attempt to set current configuration data, for this session only

    my $debuglevel = $o_obj->doZ('debug', 2);

    my $switches   = $o_obj->doZ('switches', 'abcdef');

overview

Formatting for overview.

        my $overview = $o_do->overview($h_overview, [$fmt]);

FORMAT_O_l

Formating for lean overview (currently wrapper for FORMAT_a

        my ($top, $format, @args) = $o_fmt->FORMAT_l(\%overview);

FORMAT_O_L

Formating for Lean Html overview (currently wrapper for FORMAT_h

        my ($top, $format, @args) = $o_fmt->FORMAT_L(\%overview);

FORMAT_O_a

Formating for overview (default).

        my ($top, $format, @args) = $o_fmt->FORMAT_a(\%overview);

FORMAT_O_A

Formatting for ASCII overview.

        my ($top, $format, @args) = $o_fmt->FORMAT_O_A(\%overview);

FORMAT_O_h

Formatting for html overview.

        my ($top, $format, @args) = $o_fmt->FORMAT_O_h(\%overview);

FORMAT_O_H

Formatting for HTML overview.

        my ($top, $format, @args) = $o_fmt->FORMAT_O_H(\%overview);

AUTHOR

Richard Foley perlbug@rfi.net Oct 1999 2000 2001