File Coverage

blib/lib/Geo/UK/Postcode/Regex/Simple.pm

Criterion	Covered	Total	%
statement	44	44	100.0
branch	58	60	96.6
condition			n/a
subroutine	10	10	100.0
pod	4	4	100.0
total	116	118	98.3

package Geo::UK::Postcode::Regex::Simple;

our $VERSION = '0.015';

use strict;
use warnings;

use Carp;

use base 'Exporter';

use Geo::UK::Postcode::Regex qw/ %REGEXES /;

our @EXPORT_OK = qw/ postcode_re extract_pc parse_pc validate_pc /;
our %EXPORT_TAGS = ( all => \@EXPORT_OK );

our $MODE             = 'strict';    # or 'valid' or 'lax'
our $PARTIAL          = 0;
our $ANCHORED         = 1;
our $CAPTURES         = 1;
our $CASE_INSENSITIVE = 0;

sub import {
    my $class = shift;

    my %tags = map { $_ => 1 } @_;

    $MODE
        = delete $tags{'-valid'}  ? 'valid'
        : delete $tags{'-lax'}    ? 'lax'
        : delete $tags{'-strict'} ? 'strict'
        :                           $MODE;

    $PARTIAL    #
        = delete $tags{'-partial'} ? 1
        : delete $tags{'-full'}    ? 0
        :                            $PARTIAL;
    $ANCHORED
        = delete $tags{'-unanchored'} ? 0
        : delete $tags{'-anchored'}   ? 1
        :                               $ANCHORED;
    $CAPTURES
        = delete $tags{'-nocaptures'} ? 0
        : delete $tags{'-captures'}   ? 1
        :                               $CAPTURES;

    $CASE_INSENSITIVE
        = delete $tags{'-case-insensitive'} ? 1
        : delete $tags{'-case-sensitive'}   ? 0
        :                                     $CASE_INSENSITIVE;

    local $Exporter::ExportLevel = 1;
    $class->SUPER::import( grep { /^[^\-]/ } keys %tags );
}

sub postcode_re {

    croak "invalid \$MODE $MODE" if $MODE !~ m/^(?:strict|lax|valid)$/;

    my $key = $MODE;
    $key .= '_partial'          if $PARTIAL;
    $key .= '_anchored'         if $ANCHORED;
    $key .= '_captures'         if $CAPTURES;
    $key .= '_case-insensitive' if $CASE_INSENSITIVE;

    return $REGEXES{$key};
}

sub parse_pc {

    croak "parse_pc only works with an anchored regex" unless $ANCHORED;

    Geo::UK::Postcode::Regex->parse(
        shift,
        {   partial            => $PARTIAL          ? 1 : 0,
            strict             => $MODE eq 'lax'    ? 0 : 1,
            valid              => $MODE eq 'valid'  ? 1 : 0,
            'case-insensitive' => $CASE_INSENSITIVE ? 1 : 0,
        }
    );
}

sub extract_pc {

    croak "extract_pc only works with full postcodes" if $PARTIAL;

    Geo::UK::Postcode::Regex->extract(
        shift,
        {   strict             => $MODE eq 'lax'    ? 0 : 1,
            valid              => $MODE eq 'valid'  ? 1 : 0,
            'case-insensitive' => $CASE_INSENSITIVE ? 1 : 0,
        }
    );
}

sub validate_pc {
    my $pc = shift;

    croak "invalid \$MODE $MODE" if $MODE !~ m/^(?:strict|lax|valid)$/;

    my $key = $MODE;

    $key .= '_partial' if $PARTIAL;

    $key .= '_anchored' if $ANCHORED;

    $key .= '_case-insensitive' if $CASE_INSENSITIVE;

    return $pc =~ $REGEXES{$key} ? 1 : 0;
}

1;

__END__