File Coverage

blib/lib/WWW/OhNoRobotCom/Search.pm

Criterion	Covered	Total	%
statement	33	98	33.6
branch	1	24	4.1
condition	2	26	7.6
subroutine	9	14	64.2
pod	2	2	100.0
total	47	164	28.6

package WWW::OhNoRobotCom::Search;

use warnings;
use strict;

our $VERSION = '0.003';

use Carp;
use URI;
use LWP::UserAgent;
use HTML::TokeParser::Simple;
use HTML::Entities;
use base 'Class::Accessor::Grouped';
__PACKAGE__->mk_group_accessors( simple =>
    qw/ua
    error
    results
/);

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;

    $args{timeout} ||= 30;
    $args{ua} ||= LWP::UserAgent->new(
        timeout => $args{timeout},
        agent   => 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.8.1.12)'
                    .' Gecko/20080207 Ubuntu/7.10 (gutsy) Firefox/2.0.0.12',
    );

    my $self = bless {}, $class;
    $self->ua( $args{ua} );

    return $self;
}

sub search {
    my $self = shift;
    my %args = ( term => shift );

    if ( @_ ) {
        %args = ( @_, %args );
    }

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

    my $valid_include = $self->_make_valid_include;
    %args = (
        comic_id    => '',
        include     => [ keys %$valid_include ],
        max_results => 10,

        %args,
    );

    $self->$_(undef) for qw(results error);

    if ( grep { not exists $valid_include->{$_} } @{ $args{include} } ) {
        carp "Invalid include parameter was specified";
    }

    return $self->_set_error('No term was given')
        unless defined $args{term} and length $args{term};

    my %request_args = (
        ( $args{lucky} ? ( lucky => 'Let the Robot Decide!' ) : () ),
        's'   => $args{term},
        comic => $args{comic_id},
        map( { $valid_include->{$_} => 1 } @{ delete $args{include} } ),
    );

    my $results_ref = $self->_fetch_results(
        \%request_args,
        @args{ qw(lucky max_results) },
    );

    return $self->results( $results_ref );
}

sub _fetch_results {
    my ( $self, $request_args_ref, $is_lucky, $max_results ) = @_;

    my %results;

    my $ua = $self->ua;
    $ua->requests_redirectable([]);

    my $uri = URI->new('http://www.ohnorobot.com/index.pl');
    $uri->query_form(  %$request_args_ref );
    my $response = $ua->get( $uri, );

    if ( $is_lucky and $response->code == 302 ) {
        return URI->new( $response->header('Location') );
    }
    elsif ( $response->is_success ) {
        my $results_ref = $self->_parse_results( $response->content );

        return unless $results_ref;

        %results = %$results_ref;

        my $has_results = scalar keys %$results_ref;
        my $result_count = $has_results;

        while ( $max_results >= $result_count and $has_results ) {
            ++$request_args_ref->{p}; # p for page DUH!
            $uri->query_form( %$request_args_ref );

            my $response = $ua->get( $uri );
            unless ( $response->is_success ) {
                $result_count += 10;
                next;
            }

            my %new_results = %{ $self->_parse_results($response->content) };
            %results = (
                %results,
                %new_results,
            );
            $has_results = keys %new_results;
            $result_count += $has_results;
        }
    }
    else {
        return $self->_set_error('Network error: ' . $response->status_line);
    }

    return $self->_set_error('Nothing was found')
        if $is_lucky and not %results;
    return \%results;
}

sub _parse_results {
    my ( $self, $content ) = @_;

    my $parser = HTML::TokeParser::Simple->new( \$content );

    my %results;
    my $get_link = 0;
    my $current_link;
    while ( my $t = $parser->get_token ) {
        if ( $t->is_start_tag('a')
            and defined $t->get_attr('class')
            and $t->get_attr('class') eq 'searchlink'
        ) {
            $get_link = 1;
            $current_link = $t->get_attr('href');
        }
        elsif ( $get_link and $t->is_text ) {
            $results{ $current_link } = decode_entities($t->as_is);
            $results{ $current_link } =~ s/^\s+|\s+$//g;
            $results{ $current_link } =~ s/\s+/ /g;
            $get_link = 0;
        }
    }
    return \%results;
}

sub _make_valid_include {
    return {
            all_text    => 'b',
            speakers    => 'n',
            scene       => 'd',
            sound       => 'e',
            link        => 't',
            meta        => 'm',
    };
}

sub _set_error {
    my ( $self, $error ) = @_;
    $self->error( $error );
    return;
}


1;

__END__