File Coverage

blib/lib/Data/TableReader/Field.pm

Criterion	Covered	Total	%
statement	35	36	97.2
branch	21	24	87.5
condition	2	6	33.3
subroutine	9	9	100.0
pod	1	2	50.0
total	68	77	88.3

package Data::TableReader::Field;
use Moo 2;
use Carp;
use namespace::clean;

# ABSTRACT: Field specification for Data::TableReader
our $VERSION = '0.021'; # VERSION


has name     => ( is => 'ro', required => 1 );
*addr=       \&Scalar::Util::refaddr;
has header   => ( is => 'ro' );
has required => ( is => 'ro', default => sub { 1 } );
has trim     => ( is => 'ro', default => sub { 1 } );
has blank    => ( is => 'ro' ); # default is undef
has type     => ( is => 'ro', isa => sub { ref $_[0] eq 'CODE' or $_[0]->can('validate') } );
has coerce   => ( is => 'ro', isa => sub { ref $_[0] eq 'CODE' or !ref $_[0] } );
has array    => ( is => 'ro' );
has follows  => ( is => 'ro' );
sub follows_list { my $f= shift->follows; ref $f? @$f : defined $f? ( $f ) : () }

sub BUILD {
   my $self= shift;
   if ($self->coerce) {
      croak "To coerce field ".$self->name.", either 'coerce' must be a coderef or 'type' must have a ->coerce method"
         unless ref $self->coerce eq 'CODE' or (defined $self->type && ref($self->type)->can('coerce'));
   }
}


has header_regex => ( is => 'lazy' );

sub _build_header_regex {
	my $self= shift;
	my $h= $self->header;
	unless (defined $h) {
		$h= $self->name;
		$h =~ s/([[:lower:]])([[:upper:]])/$1 $2/g; # split words on camelCase
		$h =~ s/([[:alpha:]])([[:digit:]])/$1 $2/g; # or digit
		$h =~ s/([[:digit:]])([[:alpha:]])/$1 $2/g;
		$h =~ s/_/ /g;                              # then split on underscore
	}
	return $h if ref($h) eq 'Regexp';
	my $pattern= join "[\\W_]*", map { $_ eq "\n"? '\n' : "\Q$_\E" } grep { defined && length }
		split /(\n)|\s+|(\W)/, $h; # capture newline or non-word, except for other whitespace
	return qr/^[\W_]*$pattern[\W_]*$/im;
}

has trim_coderef => ( is => 'lazy' );

sub _default_trim_coderef {
	$_ =~ s/\s+$//;
	$_ =~ s/^\s+//;
}

sub _build_trim_coderef {
	my $t= shift->trim;
	return undef unless $t;
	return \&_default_trim_coderef if !ref $t;
	return $t if ref $t eq 'CODE';
	return sub { s/$t//g; } if ref $t eq 'Regexp';
	croak("Can't convert ".ref($t)." to a coderef");
}

1;

__END__