File Coverage

blib/lib/POE/Component/IRC/Plugin/WWW/CPANRatings/RSS.pm

Criterion	Covered	Total	%
statement	9	9	100.0
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	12	12	100.0

package POE::Component::IRC::Plugin::WWW::CPANRatings::RSS;

use warnings;
use strict;

our $VERSION = '0.0106';

use POE qw/Component::WWW::CPANRatings::RSS/;
use POE::Component::IRC::Plugin qw( :ALL );
use utf8;

sub new {
    my $package = shift;
    my %args = @_;
    my $self = bless {}, $package;

    $self->{ +lc } = delete $args{ $_ }
        for keys %args;

    $self->{rate} ||= 60;
    $self->{ua}   ||= { timeout => 30 };
    $self->{file} = 'cpan_ratings.rss.storable'
        unless defined $self->{file};

    $self->{format}
    ||= 'rating: {:dist:} - {:rating:} - by {:creator:} [ {:link:} ]';

    $self->{channels} ||= [];
    $self->{response_event} ||= 'irc_cpanratings';
    $self->{auto} = 1
        unless defined $self->{auto};

    $self->{utf} = 1
        unless defined $self->{utf};

    $self->{max_ratings} = 5
        unless defined $self->{max_ratings};

    return $self;
}

sub PCI_register {
    my ($self, $irc) = splice @_, 0, 2;

    $self->{irc} = $irc;

    $self->{poco} = POE::Component::WWW::CPANRatings::RSS->spawn(
        debug => $self->{debug},
        ua    => $self->{ua},
    );

    $self->{SESSION_ID} = POE::Session->create(
        object_states => [
            $self => [qw(_start _shutdown ratings)],
        ],
    )->ID();

    return 1;
}

sub PCI_unregister {
    my ($self, $irc) = splice @_, 0, 2;

    $poe_kernel->call( $self->{SESSION_ID} => '_shutdown' );
    delete $self->{irc};
    return 1;
}

sub _start {
    my ($kernel, $self) = @_[KERNEL, OBJECT];
    $self->{SESSION_ID} = $_[SESSION]->ID();

    $kernel->refcount_increment( $self->{SESSION_ID}, __PACKAGE__ );

    $self->{poco}->fetch( {
            event  => 'ratings',
            repeat => $self->{rate},
            unique => 1,
            file   => $self->{file},
        }
    );

    return;
}

sub ratings {
    my ( $self, $in_ref ) = @_[ OBJECT, ARG0 ];
    if ( $in_ref->{error} ) {
        $self->{debug}
            and warn "Got ratings error: $in_ref->{error}\n";
        return;
    }

    my @ratings = @{ $in_ref->{ratings} || [] };
    for my $review ( splice @ratings, 0, $self->{max_ratings} ) {
        my $text = $self->{format};
        my $rating = $review->{rating};
        if ( $self->{utf} and $rating ne 'N/A' ) {
            $rating = $self->_make_utf_rating( $rating );
        }
        elsif ( $rating ne 'N/A' ) {
            $rating = "$rating/5";
        }
        $text =~ s/{:dist:}/$review->{dist}/g;
        $text =~ s/{:rating:}/$rating/g;
        $text =~ s/{:creator:}/$review->{creator}/g;
        $text =~ s/{:link:}/$review->{link}/g;

        if ( $self->{auto} ) {
            $self->{irc}->yield( ctcp => $_ => 'ACTION ' . $text )
                for @{ $self->{channels} };
        }
    }
    my %event_output =  %$in_ref;
    delete $event_output{unique};
    $event_output{rate} = delete $event_output{repeat};
    $self->{irc}->send_event( $self->{response_event} => \%event_output );
}

sub _shutdown {
    my ($kernel, $self) = @_[KERNEL, OBJECT];
    $self->{poco}->shutdown;
    $kernel->alarm_remove_all();
    $kernel->refcount_decrement( $self->{SESSION_ID}, __PACKAGE__ );
    return;
}

sub _make_utf_rating {
    my ( $self, $rating ) = @_;

    my $out = '●' x int $rating;
    $out .= '◐'
        if $rating - int $rating;
    $out .= '○' x (5 - length $out);

    return $out;
}

1;
__END__