File Coverage

blib/lib/Util/Underscore/Scalars.pm

Criterion	Covered	Total	%
statement	32	37	86.4
branch	20	24	83.3
condition	7	8	87.5
subroutine	14	14	100.0
pod			n/a
total	73	83	87.9

package Util::Underscore::Scalars;

#ABSTRACT: Functions for introspecting and manipulating scalars

use strict;
use warnings;


## no critic (ProhibitMultiplePackages)
package    # hide from PAUSE
    _;

## no critic (RequireArgUnpacking, RequireFinalReturn, ProhibitSubroutinePrototypes)

## no critic (ProtectPrivateVars)
$Util::Underscore::_ASSIGN_ALIASES->('Scalar::Util', new_dual => 'dualvar');

sub is_dual(_) {
    goto &Scalar::Util::isdual;
}

sub is_vstring(_) {
    goto &Scalar::Util::isvstring;
}

sub is_readonly(_) {
    goto &Scalar::Util::readonly;
}

## no critic (ProtectPrivateVars)
$Util::Underscore::_ASSIGN_ALIASES->('Const::Fast', const => 'const');

sub is_tainted (_) {
    goto &Scalar::Util::tainted;
}

if (eval q{use Data::Alias 1.18 (); 1}) {  ## no critic (ProhibitStringyEval)
    ## no critic (ProtectPrivateVars)
    $Util::Underscore::_ASSIGN_ALIASES->('Data::Alias', alias => 'alias');
}

sub is_plain(_) {
    defined $_[0]
        && !defined ref_type $_[0];
}

sub is_string(_) {
    defined $_[0]
        && (!defined ref_type $_[0]
        || overload::Method($_[0], q[""]));
}

sub is_bool(_) {
    !defined ref_type $_[0]
        || overload::Method($_[0], q[bool]);
}

sub is_identifier(_) {
    defined $_[0]
        && scalar($_[0] =~ /\A [^\W\d]\w* \z/xsm);
}

sub is_package(_) {
    defined $_[0]
        && scalar($_[0] =~ /\A [^\W\d]\w* (?: [:][:]\w+ )* \z/xsm);
}

sub chomp(_;$) {

    # localizedly set the input record separator
    local $/ = $/;
    if (@_ > 1) {
        if (_::is_string $_[1]) {
            $/ = "$_[1]";
        }
        else {
            Carp::croak q(_::chomp: second argument must be a string);
        }
    }

    # handle a single string
    # ATTENTION: this depends on _::is_string
    if (_::is_string $_[0]) {
        CORE::chomp(my $copy = $_[0]);
        return $copy;
    }

    # handle an arrayref of strings (effectively auto-mapping)
    # ATTENTION: _::is_array_ref will be defined later
    elsif (_::is_array_ref($_[0])) {
        my @result = @{ $_[0] };
        for (@result) {
            goto ERROR if not _::is_string;
            CORE::chomp;
        }
        return \@result;
    }

    ERROR:
    Carp::croak
        q(_::chomp: first argument must be string or arrayref of strings);
}

sub index($$;$) {
    if (@_ >= 3 and $_[2] < 0) {
        Carp::croak q(_::index: starting position must be non-negative.)
    }
    my $result = CORE::index($_[0], $_[1], $_[2] // 0);
    return ($result >= 0) ? $result : undef;
}

1;

__END__