File Coverage

blib/lib/BusyBird/Util.pm

Criterion	Covered	Total	%
statement	141	164	85.9
branch	41	54	75.9
condition	21	27	77.7
subroutine	28	31	90.3
pod	4	10	40.0
total	235	286	82.1

package BusyBird::Util;
use strict;
use warnings;
use Scalar::Util qw(blessed weaken);
use Carp;
use Exporter qw(import);
use BusyBird::DateTime::Format;
use BusyBird::Log qw(bblog);
use BusyBird::SafeData qw(safed);
use DateTime;
use 5.10.0;
use Future::Q 0.040;
use File::HomeDir;
use File::Spec;

our @EXPORT_OK =
    qw(set_param expand_param config_directory config_file_path sort_statuses
       split_with_entities future_of make_tracking vivifiable_as);
our @CARP_NOT = qw(Future::Q);

sub set_param {
    my ($hashref, $params_ref, $key, $default, $is_mandatory) = @_;
    if($is_mandatory && !defined($params_ref->{$key})) {
        my $classname = blessed $hashref;
        croak "ERROR: set_param in $classname: Parameter for '$key' is mandatory, but not supplied.";
    }
    $hashref->{$key} = (defined($params_ref->{$key}) ? $params_ref->{$key} : $default);
}

sub export_ok_all_tags {
    no strict "refs";
    my ($caller_package) = caller;
    my $export_ok = \@{"${caller_package}::EXPORT_OK"};
    my $export_tags = \%{"${caller_package}::EXPORT_TAGS"};
    my @all = @$export_ok;
    foreach my $tag (keys %$export_tags) {
        my $exported = $export_tags->{$tag};
        push(@all, @$exported);
        push(@$export_ok, @$exported);
    }
    $export_tags->{all} = \@all;
}

sub expand_param {
    my ($param, @names) = @_;
    my $refparam = ref($param);
    my @result = ();
    if($refparam eq 'ARRAY') {
        @result = @$param;
    }elsif($refparam eq 'HASH') {
        @result = @{$param}{@names};
    }else {
        $result[0] = $param;
    }
    return wantarray ? @result : $result[0];
}

sub config_directory {
    return File::Spec->catfile(File::HomeDir->my_home, ".busybird");
}

sub config_file_path {
    my (@paths) = @_;
    return File::Spec->catfile(config_directory, @paths);
}

sub vivifiable_as {
    return !defined($_[0]) || ref($_[0]) eq $_[1];
}

sub _epoch_undef {
    my ($datetime_str) = @_;
    my $dt = BusyBird::DateTime::Format->parse_datetime($datetime_str);
    return defined($dt) ? $dt->epoch : undef;
}

sub _sort_compare {
    my ($a, $b) = @_;
    if(defined($a) && defined($b)) {
        return $b <=> $a;
    }elsif(!defined($a) && defined($b)) {
        return -1;
    }elsif(defined($a) && !defined($b)) {
        return 1;
    }else {
        return 0;
    }
}

sub sort_statuses {
    my ($statuses) = @_;
    use sort 'stable';

    my @dt_statuses = map {
        my $safe_status = safed($_);
        [
            $_,
            _epoch_undef($safe_status->val("busybird", "acked_at")),
            _epoch_undef($safe_status->val("created_at")),
        ];
    } @$statuses;
    return [ map { $_->[0] } sort {
        foreach my $sort_key (1, 2) {
            my $ret = _sort_compare($a->[$sort_key], $b->[$sort_key]);
            return $ret if $ret != 0;
        }
        return 0;
    } @dt_statuses];
}

sub _create_text_segment {
    return {
        text => substr($_[0], $_[1], $_[2] - $_[1]),
        start => $_[1],
        end => $_[2],
        type => $_[3],
        entity => $_[4],
    };
}

sub split_with_entities {
    my ($text, $entities_hashref) = @_;
    use sort 'stable';
    if(!defined($text)) {
        croak "text must not be undef";
    }
    if(ref($entities_hashref) ne "HASH") {
        return [_create_text_segment($text, 0, length($text))];
    }

    ## create entity segments
    my @entity_segments = ();
    foreach my $entity_type (keys %$entities_hashref) {
        my $entities = $entities_hashref->{$entity_type};
        next if ref($entities) ne "ARRAY";
        foreach my $entity (@$entities) {
            my $se = safed($entity);
            my $start = $se->val("indices", 0);
            my $end = $se->val("indices", 1);
            if(defined($start) && defined($end) && $start <= $end) {
                push(@entity_segments, _create_text_segment(
                    $text, $start, $end, $entity_type, $entity
                ));
            }
        }
    }
    @entity_segments = sort { $a->{start} <=> $b->{start} } @entity_segments;

    ## combine entity_segments with non-entity segments
    my $pos = 0;
    my @final_segments = ();
    foreach my $entity_segment (@entity_segments) {
        if($pos < $entity_segment->{start}) {
            push(@final_segments, _create_text_segment(
                $text, $pos, $entity_segment->{start}
            ));
        }
        push(@final_segments, $entity_segment);
        $pos = $entity_segment->{end};
    }
    if($pos < length($text)) {
        push(@final_segments, _create_text_segment(
            $text, $pos, length($text)
        ));
    }
    return \@final_segments;
}

sub future_of {
    my ($invocant, $method, %args) = @_;
    return Future::Q->try(sub {
        croak "invocant parameter is mandatory" if not defined $invocant;
        croak "method parameter is mandatory" if not defined $method;
        croak "invocant is not blessed" if not blessed $invocant;
        croak "no such method as $method" if not $invocant->can($method);
        my $f = Future::Q->new();
        $invocant->$method(%args, callback => sub {
            my ($error, @results) = @_;
            if($error) {
                $f->reject($error, 1);
            }else {
                $f->fulfill(@results);
            }
        });
        return $f;
    });
}

sub make_tracking {
    my ($tracking_timeline, $main_timeline) = @_;
    if(!blessed($tracking_timeline) || !$tracking_timeline->isa("BusyBird::Timeline")) {
        croak "tracking_timeline must be a BusyBird::Timeline.";
    }
    if(!blessed($main_timeline) || !$main_timeline->isa("BusyBird::Timeline")) {
        croak "main_timeline must be a BusyBird::Timeline.";
    }
    my $name_tracking = $tracking_timeline->name;
    my $name_main = $main_timeline->name;
    if($name_tracking eq $name_main) {
        croak "tracking_timeline and main_timeline must be different timelines.";
    }
    weaken(my $track = $tracking_timeline);
    $tracking_timeline->add_filter_async(sub {
        my ($statuses, $done) = @_;
        if(!defined($track)) {
            $done->($statuses);
            return;
        }
        $track->contains(query => $statuses, callback => sub {
            my ($error, $contained, $not_contained) = @_;
            if(defined($error)) {
                bblog("error", "tracking timeline '$name_tracking' contains() error: $error");
                $done->($statuses);
                return;
            }
            $main_timeline->add($not_contained, sub {
                my ($error, $count) = @_;
                if(defined($error)) {
                    bblog("error", "main timeline '$name_main' add() error: $error");
                }
                $done->($statuses);
            });
        });
    });
    return $tracking_timeline;
}

1;

__END__