File Coverage

blib/lib/WWW/DuckDuckGo/ZeroClickInfo.pm

Criterion	Covered	Total	%
statement	47	62	75.8
branch	21	52	40.3
condition	2	9	22.2
subroutine	7	10	70.0
pod	2	5	40.0
total	79	138	57.2

package WWW::DuckDuckGo::ZeroClickInfo;
BEGIN {
  $WWW::DuckDuckGo::ZeroClickInfo::AUTHORITY = 'cpan:DDG';
}
{
  $WWW::DuckDuckGo::ZeroClickInfo::VERSION = '0.016';
}
# ABSTRACT: A DuckDuckGo Zero Click Info definition

use Moo;
use WWW::DuckDuckGo::Link;
use URI;

sub by {
	my ( $class, $result ) = @_;
	my %params;
	if ($result->{RelatedTopics}) {
		$params{related_topics_sections} = {};
		if ($result->{RelatedTopics}->[0]->{Topics}) {
			for (@{$result->{RelatedTopics}}) {
				die "go to irc.freenode.net #duckduckgo and kick yegg, and also tell him your searchterm" if $_->{Name} eq '_';
				my @topics;
				for (@{$_->{Topics}}) {
					push @topics, $class->_link_class->by($_) if ref $_ eq 'HASH' and %{$_};
				}
				$params{related_topics_sections}->{$_->{Name}} = \@topics;
			}
		} else {
			my @topics;
			for (@{$result->{RelatedTopics}}) {
				push @topics, $class->_link_class->by($_) if ref $_ eq 'HASH' and %{$_};
			}
			$params{related_topics_sections}->{_} = \@topics if @topics;
		}
	}
	my @results;
	for (@{$result->{Results}}) {
		push @results, $class->_link_class->by($_) if ref $_ eq 'HASH' and %{$_};
	}
        $params{_json} = $result;
	$params{results} = \@results if @results;
	$params{abstract} = $result->{Abstract} if $result->{Abstract};
	$params{abstract_text} = $result->{AbstractText} if $result->{AbstractText};
	$params{abstract_source} = $result->{AbstractSource} if $result->{AbstractSource};
	$params{abstract_url} = URI->new($result->{AbstractURL}) if $result->{AbstractURL};
	$params{image} = URI->new($result->{Image}) if $result->{Image};
	$params{heading} = $result->{Heading} if $result->{Heading};
	$params{answer} = $result->{Answer} if $result->{Answer};
	$params{answer_type} = $result->{AnswerType} if $result->{AnswerType};
	$params{definition} = $result->{Definition} if $result->{Definition};
	$params{definition_source} = $result->{DefinitionSource} if $result->{DefinitionSource};
	$params{definition_url} = URI->new($result->{DefinitionURL}) if $result->{DefinitionURL};
	$params{type} = $result->{Type} if $result->{Type};
	$params{html} = $result->{HTML} if $result->{HTML};
    $params{redirect} = $result->{Redirect} if $result->{Redirect};
	__PACKAGE__->new(%params);
}

sub _link_class { 'WWW::DuckDuckGo::Link' }

has _json => (
	is => 'ro',
);

has abstract => (
	is => 'ro',
	predicate => 'has_abstract',
);

has abstract_text => (
	is => 'ro',
	predicate => 'has_abstract_text',
);

has abstract_source => (
	is => 'ro',
	predicate => 'has_abstract_source',
);

has abstract_url => (
	is => 'ro',
	predicate => 'has_abstract_url',
);

has image => (
	is => 'ro',
	predicate => 'has_image',
);

has heading => (
	is => 'ro',
	predicate => 'has_heading',
);

has answer => (
	is => 'ro',
	predicate => 'has_answer',
);

has answer_type => (
	is => 'ro',
	predicate => 'has_answer_type',
);

has definition => (
	is => 'ro',
	predicate => 'has_definition',
);

has definition_source => (
	is => 'ro',
	predicate => 'has_definition_source',
);

has definition_url => (
	is => 'ro',
	predicate => 'has_definition_url',
);

has html => (
	is => 'ro',
	predicate => 'has_html',
);

has redirect => (
	is => 'ro',
	predicate => 'has_redirect',
);

sub default_related_topics {
	my ( $self ) = @_;
	$self->related_topics_sections->{_} if $self->has_related_topics_sections;
}

sub has_default_related_topics {
	my ( $self ) = @_;
	$self->has_related_topics_sections and defined $self->related_topics_sections->{_} ? 1 : 0;
}

has related_topics_sections => (
	is => 'ro',
	predicate => 'has_related_topics_sections',
);

# DEPRECATED WARN
sub related_topics {
	warn __PACKAGE__.": usage of the function related_topics is deprecated, use default_related_topics for the same functionality (also see: related_topics_sections)";
	shift->default_related_topics(@_);
}
################

has results => (
	is => 'ro',
	predicate => 'has_results',
);

has type => (
	is => 'ro',
	predicate => 'has_type',
);

has type_long_definitions => (
	is => 'ro',
	lazy => 1,
	default => sub {{
		A => 'article',
		D => 'disambiguation',
		C => 'category',
		N => 'name',
		E => 'exclusive',
	}},
);

sub type_long {
	my ( $self ) = @_;
	return if !$self->type;
	$self->type_long_definitions->{$self->type};
}

1;

__END__