Data::CPAN::DSLIP::Explain - "decrypts" CPAN module DSLIP code

    use strict;
    use warnings;

    use Data::CPAN::DSLIP::Explain;

    my $dslip = 'Sdcfp';

    my $obj = Data::CPAN::DSLIP::Explain->new;

    my $meaning = $obj->dslip( $dslip );

    print "\nDSLIP code `$dslip` means:\n",
            join "\n\t",
                map {
                    $obj->explain_dslip_letter( $_ )
                    . "\n\t\t$meaning->{$_}"
                } qw(D S L I P);

    print "\n\n----\n";

    my $object = Data::CPAN::DSLIP::Explain->new;

    my $meaning = $object->dslip( 'Sdcfp' );
    my @meanings = $object->dslip( qw( Sdcfp Sdcfp Sdcfp ) );

    $VAR1 = {
        'D' => 'Standard, supplied with Perl',
        'S' => 'Developer',
        'L' => 'C and perl, a C compiler will be needed'
        'I' => 'plain Functions, no references used',
        'P' => 'Standard-Perl: user may choose between GPL and Artistic',
    };

    my $D_means = $object->explain_dslip_letter('D');
    my $S_means = $object->explain_dslip_letter('S');
    my $L_means = $object->explain_dslip_letter('L');
    my $I_means = $object->explain_dslip_letter('I');
    my $P_means = $object->explain_dslip_letter('P');

    perldoc Data::CPAN::DSLIP::Explain

package Data::CPAN::DSLIP::Explain;

use warnings;
use strict;

our $VERSION = '0.03';

use Carp;

sub new {
    my $class = shift;
    croak "Must have even number of arguments to ->new()"
        if @_ & 1;
    my %args = @_;
    $args{ lc $_ } = delete $args{ $_ } for keys %args;
    return bless \%args, $class;
}

sub dslip {
    my $self = shift;
    my $dslip = $self->_convert_dslip( @_ );
    if ( wantarray ) {
        return @$dslip;
    }
    else {
        return $dslip->[0];
    }
}

sub _convert_dslip {
    my $self = shift;
    my @dslips = @_;
    
    my $explanation_of = $self->_get_dslip_explanations;
    my @result;
    foreach my $dslip ( @dslips ) {
        my %codes;
        @codes{ qw(D S L I P) } = map { lc } split //, $dslip;

        $codes{ $_ } = $explanation_of->{ $_ }{ $codes{$_} }
            for keys %codes;

        push @result, \%codes;
    }
    
    return \@result;
}

sub explain_dslip_letter {
    my $self = shift;
    my $dslip_letter = uc shift;
    my $explanation_of = $self->_get_dslip_explanations;
    return $explanation_of->{ $dslip_letter }{info};
}

sub _get_dslip_explanations {
    my $self = shift;
    return {
        D => {
            info   => 'Development Stage (Note: *NO IMPLIED TIMESCALES*)',
            i      => 'Idea, listed to gain consensus or as a placeholder',
            c      => 'under construction but pre-alpha (not yet released)',
            a      => 'Alpha testing',
            b      => 'Beta testing',
            r      => 'Released',
            'm'    => 'Mature (no rigorous definition)',
            's'    => 'Standard, supplied with Perl',
        },

        S => {
            info    => 'Support Level',
            'm'     => 'Mailing-list',
            d       => 'Developer',
            u       => 'Usenet newsgroup comp.lang.perl.modules',
            n       => 'None known, try comp.lang.perl.modules',
        },
        
        L => {
            info    => 'Language Used',
            p       => 'Perl-only, no compiler needed, '
                        . 'should be platform independent',
            c       => 'C and perl, a C compiler will be needed',
            h       => 'written in perl with optional C code, '
                            . 'no compiler needed',
            '+'     => 'C++ and perl, a C++ compiler will be needed',
            o       => 'perl and another language other than C or C++',
        },
        
        I => {
            info    => 'Interface Style',
            f       => 'plain Functions, no references used',
            h       => 'hybrid, object and function interfaces available',
            n       => 'no interface at all (huh?)',
            r       => 'some use of unblessed References or ties',
            o       => 'Object oriented using blessed references '
                        . 'and/or inheritance',
        },
         
        P => {
            info    => 'Public License',
            p       => 'Standard-Perl: user may choose between GPL '
                            . 'and Artistic',
            g       => 'GPL: GNU General Public License',
            l       => 'LGPL: "GNU Lesser General Public License"' 
                        . '(previously known as "GNU Library '
                        . 'General Public License")',
            b       => 'BSD: The BSD License',
            a       => 'Artistic license alone',
            o       => 'other (but distribution allowed '
                            . 'without restrictions)',
        }
    }
}

1;
__END__