File Coverage

blib/lib/Geo/Location/IP/Database/Reader.pm

Criterion	Covered	Total	%
statement	154	154	100.0
branch	12	12	100.0
condition	4	6	66.6
subroutine	20	20	100.0
pod	8	8	100.0
total	198	200	99.0

package Geo::Location::IP::Database::Reader;

# SPDX-License-Identifier: Artistic-1.0-Perl OR GPL-1.0-or-later

use 5.026;
use warnings;
use utf8;

use Object::Pad;

class Geo::Location::IP::Database::Reader
    :isa(Geo::Location::IP::Database::SimpleReader);

our $VERSION = 0.005;

use Geo::Location::IP::Address;
use Geo::Location::IP::Error::Generic;
use Geo::Location::IP::Error::AddressNotFound;

method anonymous_ip ($key, $ip) {
    $self->_assert_database_type(qr{Anonymous-IP});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::anonymous_ip($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

method asn ($key, $ip) {
    $self->_assert_database_type(qr{ASN});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::asn($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

method city ($key, $ip) {
    $self->_assert_database_type(qr{City});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::city($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

method connection_type ($key, $ip) {
    $self->_assert_database_type(qr{Connection-Type});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::connection_type($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

method country ($key, $ip) {
    $self->_assert_database_type(qr{Country});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::country($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

method domain ($key, $ip) {
    $self->_assert_database_type(qr{Domain});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::domain($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

method enterprise ($key, $ip) {
    $self->_assert_database_type(qr{Enterprise});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::enterprise($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

method isp ($key, $ip) {
    $self->_assert_database_type(qr{ISP});
    $self->_assert_ip_address($key, $ip);
    my $model = $self->SUPER::isp($key => $ip);
    $self->_assert_record($model, $ip);
    return $model;
}

our $private_ip_address_regex = qr{
    \A
    (?:
        10\.
        |
        172\.(?:1[6-9]|2[0-9]|3[01])\.
        |
        192\.168\.
        |
        f[cd]
    )
}xms;

method _assert_database_type ($type_regex) {
    my $type = $self->metadata->database_type;
    if ($type !~ $type_regex) {
        my $class   = ref $self;
        my $method  = (caller(1))[3] =~ s{.+::}{}r;
        my $message = "The $class->$method() method cannot be called with a "
            . "$type database";
        Geo::Location::IP::Error::Generic->throw(message => $message);
    }
    return;
}

method _assert_ip_address ($key, $ip) {
    if (!defined $ip || !defined $key || $key ne 'ip') {
        my $class   = ref $self;
        my $method  = (caller(1))[3] =~ s{.+::}{}r;
        my $message = "Required param (ip) was missing when calling $method "
            . "on $class";
        Geo::Location::IP::Error::Generic->throw(message => $message);
    }
    if ($ip eq 'me') {
        my $class   = ref $self;
        my $method  = (caller(1))[3] =~ s{.+::}{}r;
        my $message = "me is not a valid IP when calling $method on $class";
        Geo::Location::IP::Error::Generic->throw(message => $message);
    }
    if ($ip =~ $private_ip_address_regex) {
        my $class   = ref $self;
        my $method  = (caller(1))[3] =~ s{.+::}{}r;
        my $message = "The IP address you provided ($ip) is not a public "
            . "IP address when calling $method on $class";
        Geo::Location::IP::Error::Generic->throw(message => $message);
    }
    return;
}

method _assert_record ($obj, $ip) {
    if (!defined $obj) {
        my $ip_address = Geo::Location::IP::Address->new(
            address => $ip,
            network => undef,
        );
        Geo::Location::IP::Error::AddressNotFound->throw(
            message    => "No record found for IP address $ip",
            ip_address => $ip_address,
        );
    }
    return;
}

method _get ($ip) {
    local $@;
    my @result = eval { $self->SUPER::_get($ip) };
    if (my $e = $@) {
        Geo::Location::IP::Error::Generic->throw(message => $e);
    }
    return @result;
}

1;
__END__