It might be hard not to inherit the param method, but it is certainly possible to redefine it so its return values make no sense for you:

package my_dumb_cgi;
@ISA = ("CGI");

sub param
  { return "gotcha!"; }
[download]

Not that this would make any sense, just that it is possible.

Ah, better. This:

params {
    my ( $self, $cgi ) = @_;
    my %formdata;
    $cgi = CGI::self_or_default if ( ! defined $cgi or ! ref $cgi ) an
+d $cgi;

    if ( defined $cgi and $cgi ) {
[download]

I was not able to understand this:     $cgi = CGI::self_or_default if ( ! defined $cgi or ! ref $cgi ) and $cgi; so I did some "mechanical" translation which made it easy for me to understand (this may have more to do with the strange ways in which my mind works, though):     $cgi = CGI::self_or_default   if  $cgi  and  ! ( defined $cgi and ref $cgi ); So we don't want to override $cgi if it is false and we don't want to override $cgi if it is a good reference. But, my testing shows that ref $cgi doesn't produce a warning even if $cgi is undef so we can shorten this to:     $cgi = CGI::self_or_default   if  $cgi  and  ! ref $cgi;

Similarly, $cgi in a "Boolean context" doesn't elicit a warning in the face of undef so:     if ( defined $cgi and $cgi ) { can become:     if (  $cgi  ) {

This brings us to:

params {
    my ( $self, $cgi ) = @_;
    my %formdata;
    $cgi = CGI::self_or_default   if  $cgi  and  ! ref $cgi;

    if (  $cgi  ) {
[download]

    if (  $cgi  ) {
        $cgi = CGI::self_or_default   if   ! ref $cgi;
[download]

Well, anyway, that "works" better for me. (:

Much nicer. One little issue, though:

# This:

$cgi = CGI::self_or_default if $cgi and ! ref $cgi;

# is not equivalent to this:

$cgi = CGI::self_or_default if ! ref $cgi;
[download]

The reason this is the case is how it's called:

print $foo->list_params( 1 );
[download]

If someone supplies a false value, it should return "0". With the second version of your assignment to $cgi, it will always return the params, regardless of whether or not a false value has been passed. That might seem irrelevant, but this is a reduced test case of the actual code. Here's how this will be used in real life:

$write->table( -params    => 1,
               -condition => "$x % 7 == 3",
               -active    => 1,
               -caller    => 0,
               SomeVar    => $some_var,
               DATA       => \%some_hash );
[download]

Since this is part of a debugging module, the programmer may want to turn off the param display once the params are verified, or turn them back on again if there is a problem. Rather than going through and deleting or re-entering the '-param' key, the programmer can just toggle the value at will. (I know we discussed this with /msgs, but this is for the benefit of those not privy to the conversation).

Cheers,
Ovid

Update: Hmm... I seem to be posting a lot of updates lately :(

Seems I missed a little if which drastically changes the meaning of tye's code:

if (  $cgi  ) {
        $cgi = CGI::self_or_default   if   ! ref $cgi;
[download]

sigh

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

First I figured you could undef a subroutine:

package MyCGI;
use base CGI;
undef(*MyCGI::param);
[download]

Update: would it be possible to (instead of using @ISA for inheritance) copy all of the subroutine refs from the parent class symbol table into your own and then delete one of them? I'll look into it...

Later: yes, you can copy from a superclass instead of using @ISA:

package A;
sub abc { "abc\n" };
sub def { "def\n" };

package B;
# inherit from A all but A::def
foreach my $symname (keys %A::) {
 next if $symname eq 'def';
 $B::{$symname} = $A::{$symname};
}
my $b = bless({}, 'B');
print $b->abc;    # prints "abc\n"
print $b->def;    # no such method
[download]