File Coverage

blib/lib/Bubblegum/Object/String.pm

Criterion	Covered	Total	%
statement	144	144	100.0
branch	35	38	92.1
condition	7	11	63.6
subroutine	49	49	100.0
pod	34	34	100.0
total	269	276	97.4

# ABSTRACT: Common Methods for Operating on Strings
package Bubblegum::Object::String;

use 5.10.0;
use namespace::autoclean;

use Bubblegum::Class 'with';
use Bubblegum::Constraints -isas, -types;

use Carp 'confess';
use Scalar::Util 'looks_like_number';

with 'Bubblegum::Object::Role::Defined';
with 'Bubblegum::Object::Role::Comparison';
with 'Bubblegum::Object::Role::Coercive';
with 'Bubblegum::Object::Role::Value';

our @ISA = (); # non-object

our $VERSION = '0.45'; # VERSION

sub append {
    return $_[0] = CORE::join ' ', map type_string($_), @_;
}

sub codify {
    my $self = CORE::shift || 'return(@_)';
    my $vars = sprintf 'my (%s) = @_;', join ',', map "\$$_", 'a'..'z';
    my $code = sprintf 'use gum; sub { %s return do { %s } }', $vars, $self;
    my $ref  = eval $code or confess $@;
    return $ref;
}

sub concat {
    return $_[0] = CORE::join '', map type_string($_), @_;
}

sub contains {
    my $self  = CORE::shift;
    my $other = CORE::shift;

    if (isa_regexpref($other)) {
        return $self =~ $other ? 1 : 0;
    }

    if (isa_string($other)) {
        return CORE::index($self, $other) < 0 ? 0 : 1;
    }

    return 0;
}

sub eq {
    my $self  = CORE::shift;
    my $other = type_string CORE::shift;

    return $self eq $other ? 1 : 0;
}

sub eqtv {
    my $self  = CORE::shift;
    my $other = CORE::shift;

    return 0 unless CORE::defined $other;
    return ($self->type eq $other->type && $self eq $other) ? 1 : 0;
}

sub format {
    my $self   = CORE::shift;
    my $format = type_string CORE::shift;

    return CORE::sprintf $format, $self, @_;
}

sub gt {
    my $self  = CORE::shift;
    my $other = type_string CORE::shift;

    return $self gt $other ? 1 : 0;
}

sub gte {
    my $self  = CORE::shift;
    my $other = type_string CORE::shift;

    return $self ge $other ? 1 : 0;
}

sub lt {
    my $self  = CORE::shift;
    my $other = type_string CORE::shift;

    return $self lt $other ? 1 : 0;
}

sub lte {
    my $self  = CORE::shift;
    my $other = type_string CORE::shift;

    return $self le $other ? 1 : 0;
}

sub ne {
    my $self  = CORE::shift;
    my $other = type_string CORE::shift;

    return $self ne $other ? 1 : 0;
}

sub camelcase {
    $_[0] = CORE::ucfirst(CORE::lc("$_[0]"));
    $_[0] =~ s/[^a-zA-Z0-9]+([a-z])/\U$1/g;
    $_[0] =~ s/[^a-zA-Z0-9]+//g;
    return $_[0];
}

sub chomp {
    CORE::chomp $_[0];
    return $_[0];
}

sub chop {
    CORE::chop $_[0];
    return $_[0];
}

sub hex {
    my $self = CORE::shift;
    return CORE::hex $self;
}

sub index {
    my ($self, $substr, $pos) = @_;
    type_string $substr;
    return CORE::index $self, $substr if scalar @_ == 2;

    type_number $pos;
    return CORE::index $self, $substr, $pos
}

sub lc {
    my $self = CORE::shift;
    return CORE::lc $self;
}

sub lcfirst {
    my $self = CORE::shift;
    return CORE::lcfirst $self;
}

sub length {
    my $self = CORE::shift;
    return CORE::length $self;
}

sub lines {
    my $self = CORE::shift;
    return [CORE::split /\n+/, $self];
}

sub lowercase {
    goto &lc
}

sub replace {
    my ($self, $regexp, $other, $mods) = @_;

    $mods = CORE::defined $mods ? type_string $mods : '';
    if (!isa_regexpref($regexp) && isa_string($regexp)) {
        $regexp = CORE::quotemeta $regexp;
    }

    CORE::eval("sub { \$_[0] =~ s/$regexp/$other/$mods }")->($_[0]);
    return $self = $_[0];
}

sub reverse {
    my $self = CORE::shift;
    return CORE::reverse $self;
}

sub rindex {
    my ($self, $substr, $pos) = @_;
    type_string $substr;
    return CORE::rindex $self, $substr if !defined $pos;

    type_number $pos;
    return CORE::rindex $self, $substr, $pos;
}

sub snakecase {
    $_[0] = CORE::lc("$_[0]");
    $_[0] =~ s/[^a-zA-Z0-9]+([a-z])/\U$1/g;
    $_[0] =~ s/[^a-zA-Z0-9]+//g;
    return $_[0];
}

sub split {
    my ($self, $regexp, $limit) = @_;

    if (!isa_regexpref($regexp) && isa_string($regexp)) {
        $regexp = CORE::quotemeta $regexp;
    }

    return [CORE::split /$regexp/, $self] if !defined $limit;

    type_number $limit;
    return [CORE::split /$regexp/, $self, $limit];
}

sub strip {
    $_[0] =~ s/\s{2,}/ /g;
    return $_[0];
}

sub titlecase {
    $_[0] =~ s/\b(\w)/\U$1/g;
    return $_[0];
}

sub trim {
    $_[0] =~ s/^\s+|\s+$//g;
    return $_[0];
}

sub uc {
    my $self = CORE::shift;
    return CORE::uc $self;
}

sub ucfirst {
    my $self = CORE::shift;
    return CORE::ucfirst $self;
}

sub uppercase {
    goto &uc;
}

sub words {
    my $self = CORE::shift;
    return [CORE::split /\s+/, $self];
}

1;

__END__