view release on metacpan or  search on metacpan

lib/perl5i/2/SCALAR.pm  view on Meta::CPAN

}


require POSIX;
*ceil  = \&POSIX::ceil;
*floor = \&POSIX::floor;
*round_up   = \&ceil;
*round_down = \&floor;
sub round {
    return 0 if $_[0] == 0;

    if( $_[0]->is_positive ) {
        abs($_[0] - int($_[0])) < 0.5 ? round_down($_[0])
                                      : round_up($_[0])
    }
    else {
        abs($_[0] - int($_[0])) < 0.5 ? round_up($_[0])
                                      : round_down($_[0])
    }
}

require Scalar::Util;
*is_number = \&Scalar::Util::looks_like_number;
sub is_positive         { $_[0]->is_number && $_[0] > 0 }
sub is_negative         { $_[0]->is_number && $_[0] < 0 }
sub is_integer          {
    return 0 if !$_[0]->is_number;
    return $_[0] =~ m{ ^[+-]? \d+ $}x;
}
*is_int = \&is_integer;
sub is_even             { $_[0]->is_integer && !($_[0] % 2) }
sub is_odd              { $_[0]->is_integer && ($_[0] % 2) }
sub is_decimal          {
    return 0 if !$_[0]->is_number;

    # Fast and reliable way to spot most decimals
    return 1 if ((int($_[0]) - $_[0]) != 0);

    # Final gate for tricky things like 1.0, 1. and .0
    return $_[0] =~ m{^ [+-]? (?: \d+\.\d* | \.\d+ ) $}x;
}

sub group_digits {
    my($self, $opts) = @_;

    state $defaults = {
        thousands_sep   => ",",
        grouping        => 3,
        decimal_point   => ".",
    };

    my $is_money = $opts->{currency};
    my $sep           = $opts->{separator}     // (_get_from_locale("thousands_sep", $is_money)
                                                   || $defaults->{thousands_sep});
    my $grouping      = $opts->{grouping}      // (_get_grouping($is_money)
                                                   || $defaults->{grouping});
    my $decimal_point = $opts->{decimal_point} // (_get_from_locale("decimal_point", $is_money) 
                                                   || $defaults->{decimal_point});
    return $self if $grouping == 0;

    my($integer, $decimal) = split m{\.}, $self, 2;

    $integer = CORE::reverse $integer;
    $integer =~ s/(\d{$grouping})(?=\d)(?!\d*\.)/$1$sep/g;
    $integer = CORE::reverse $integer;

    my $number = $integer;
    $number .= $decimal_point . $decimal if defined $decimal;

    return $number;
}

sub commify {
    my($self, $args) = @_;

    state $defaults = {
        separator       => ",",
        grouping        => 3,
        decimal_point   => ".",
    };

    my $opts = $defaults->merge($args);

    return $self->group_digits( $opts );
}


sub _get_lconv {
    return eval {
        require POSIX;
        POSIX::localeconv();
    } || {};
}

sub _get_grouping {
    my $is_money = shift;
    my $key = $is_money ? "mon_grouping" : "grouping";

    my $lconv = _get_lconv;

    if( $lconv->{$key} ) {
        return (unpack("C*", $lconv->{$key}))[0];
    }
    else {
        return;
    }
}

sub _get_from_locale {
    my($key, $is_money) = @_;
    $key = "mon_$key" if $is_money;

    my $lconv = _get_lconv;
    return $lconv->{$key};
}


sub path2module {
    my $path = shift;

    my($vol, $dirs, $file) = File::Spec->splitpath($path);