File Coverage

blib/lib/DDG/Request.pm

Criterion	Covered	Total	%
statement	70	80	87.5
branch	20	20	100.0
condition	4	8	50.0
subroutine	15	19	78.9
pod	2	4	50.0
total	111	131	84.7

package DDG::Request;
our $AUTHORITY = 'cpan:DDG';
# ABSTRACT: A request to DuckDuckGo itself, so the query itself and parameter around the query defining him
$DDG::Request::VERSION = '1017';
use Moo;
use utf8;


#
# QUERY
#
###############################


has query_raw => (
	is => 'ro',
	required => 1,
);

my $whitespaces = qr{\s+};
my $whitespaces_matches = qr{($whitespaces)};
my $whitespaces_dashes = qr{[\s\-]+};
my $non_alphanumeric_ascii = qr{[\x00-\x1f\x21-\x2f\x3a-\x40\x5b-\x60\x7b-\x81\x{a7}]+};


has query_raw_parts => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query_raw_parts',
);
sub _build_query_raw_parts {
	[
		split(/$whitespaces_matches/,shift->query_raw)
	]
}


has query_parts => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query_parts',
);
sub _build_query_parts {
	my $x;
	[
		grep { ( $x += length ) < 500 } # 500 matches the internal query max
		grep { ! /$whitespaces/ }
		grep { length }
		@{shift->query_raw_parts}
	]
}


has query_parts_lc => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query_parts_lc',
);
sub _build_query_parts_lc {
	[
		map { lc }
		@{shift->query_parts}
	]
}


has triggers => (
	is => 'ro',
	lazy => 1,
	builder => '_build_triggers',
);
sub _build_triggers {
	my ( $self ) = @_;
	my @parts = @{$self->query_raw_parts};
	return {} if not scalar @parts;
	my $x = $parts[0] eq '' ? 2 : 0;
	my %triggers;
	for ($x..(scalar @parts-1)) {
		unless ($_ % 2) {
			$triggers{$_} = $self->generate_triggers($parts[$_]);
		}
	}
	return \%triggers;
}


sub generate_triggers {
	my $part = lc $_[1];
	my %parts;
	++$parts{$part};
	$part =~ s/^!//go && ++$parts{$part};
	$part =~ s/\?$//go && ++$parts{$part};
	# Look for non-word characters, except single quotes, e.g. can't, John's
	if ($part =~ /[^\w']/o) {
		# The split could be part of the if but it would leave single quotes
		# in the resulting terms.
		my @boundary_words = split /\W+/o, $part ;
		++$parts{$_} for @boundary_words;
		++$parts{join('', @boundary_words)};
		++$parts{join(' ', @boundary_words)};
	}
	return [keys %parts];
}


has remainder => (
    is => 'rwp',
	lazy => 1
);

sub generate_remainder {
	my ( $self, $from_pos, $to_pos ) = @_;
	$to_pos = $from_pos unless defined $to_pos;
	my @query_raw_parts = @{$self->query_raw_parts};
	my $max = scalar @query_raw_parts-1;
	my $remainder = '';
	if ( $to_pos < $max && ( $from_pos == 0 || ( $from_pos == 2 && $query_raw_parts[0] eq '' ) ) ) {
		$remainder = join('',@query_raw_parts[$to_pos+1..$max]);
		$remainder =~ s/^\s//;
	} elsif ( $max % 2 ? $to_pos == $max-1 : $to_pos == $max ) {
		$remainder = join('',@query_raw_parts[0..$from_pos-1]);
		$remainder =~ s/\s$//;
	} else {
		my $left_remainder = join('',@query_raw_parts[0..$from_pos-1]);
		my $right_remainder = join('',@query_raw_parts[$to_pos+1..$max]);
		$left_remainder =~ s/\s$//;
		$right_remainder =~ s/^\s//;
		$remainder = $left_remainder.' '.$right_remainder;
	}
	$self->_set_remainder($remainder);
	return $remainder;
}


has matched_trigger => (
	is => 'ro',
	lazy => 1,
	builder => 1
);

sub _build_matched_trigger {
	my $self = shift;

	my $r = $self->remainder || '';
	my $qr = $self->query_raw;
	$qr =~ s/\s*\Q$r\E\s*//i;
	return $qr;
}


has query => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query',
);
sub _build_query {
	join(' ',@{shift->query_parts})
}


has query_lc => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query_lc',
);
sub _build_query_lc {
	lc(shift->query)
}


has query_nowhitespace => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query_nowhitespace',
);
sub _build_query_nowhitespace {
	for (shift->query) {
		s/$whitespaces//g;
		return $_;
	}
}


has query_nowhitespace_nodash => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query_nowhitespace_nodash',
);
sub _build_query_nowhitespace_nodash {
	for (shift->query) {
		s/$whitespaces_dashes//g;
		return $_;
	}
}


has query_clean => (
	is => 'ro',
	lazy => 1,
	builder => '_build_query_clean',
);
sub _build_query_clean {
	for (shift->query_lc) {
		s/$non_alphanumeric_ascii//g;
		s/$whitespaces/ /g;
		return $_;
	}
}


has words => (
	is => 'ro',
	lazy => 1,
	builder => '_build_words',
);
sub _build_words {
	[
		grep { length }
		split(/$whitespaces/,shift->query_clean)
	]
}


has wordcount => (
	is => 'ro',
	lazy => 1,
	builder => '_build_wordcount',
);
sub _build_wordcount { scalar @{shift->words} }


has seen_plugins => (
	is => 'rw',
	lazy => 1,
	builder => '_build_seen_plugins',
);
sub _build_seen_plugins {[]}

#
# LANGUAGE / LOCATION / IP
#
###############################

# DDG::Language TODO
has language => (
	#isa => 'DDG::Language',
	is => 'ro',
	predicate => 'has_language',
);
sub lang { shift->language }

has location => (
	#isa => 'DDG::Location',
	is => 'ro',
	predicate => 'has_location',
);
sub loc { shift->location }

1;

__END__