BusyBird

 view release on metacpan or  search on metacpan

META.json  view on Meta::CPAN

            "SQL::Maker" : "1.19",
            "SQL::QueryMaker" : "0.03",
            "Scalar::Util" : "1.24",
            "Storable" : "2.27",
            "Test::Builder" : "0",
            "Test::Fatal" : "0.006",
            "Test::More" : "0.98",
            "Text::Xslate" : "1.60",
            "Tie::IxHash" : "0",
            "Time::HiRes" : "1.9720",
            "Try::Tiny" : "0.10",
            "Twiggy" : "0",
            "URI::Escape" : "0",
            "autovivification" : "0.14",
            "parent" : "0",
            "perl" : "v5.8.0",
            "sort" : "0"
         }
      },
      "test" : {
         "requires" : {

META.yml  view on Meta::CPAN

  SQL::Maker: '1.19'
  SQL::QueryMaker: '0.03'
  Scalar::Util: '1.24'
  Storable: '2.27'
  Test::Builder: '0'
  Test::Fatal: '0.006'
  Test::More: '0.98'
  Text::Xslate: '1.60'
  Tie::IxHash: '0'
  Time::HiRes: '1.9720'
  Try::Tiny: '0.10'
  Twiggy: '0'
  URI::Escape: '0'
  autovivification: '0.14'
  parent: '0'
  perl: v5.8.0
  sort: '0'
resources:
  bugtracker: https://github.com/debug-ito/busybird/issues
  repository: git://github.com/debug-ito/busybird.git
version: '0.12'

cpanfile  view on Meta::CPAN

requires 'Pod::Usage' => "0";
requires 'Router::Simple'=> '0';
requires 'Scalar::Util'=> '1.24';
requires 'Storable'=> '2.27';
requires 'Test::Builder'=> '0';
requires 'Test::Fatal'=> '0.006';
requires 'Test::More'=> '0.98';
requires 'Text::Xslate'=> '1.60';
requires 'Tie::IxHash'=> '0';
requires 'Time::HiRes'=> '1.9720';
requires 'Try::Tiny'=> '0.10';
requires 'autovivification'=> '0.14';
requires 'JavaScript::Value::Escape'=> '0';
requires 'Cache::Memory::Simple'=> '1.01';
requires 'URI::Escape'=> '0';
requires 'sort'=> '0';
requires 'DBI' => 0;
requires 'DBD::SQLite' => 0;
requires 'SQL::Maker' => '1.19';
requires 'SQL::QueryMaker' => '0.03';
requires 'Future::Q' => '0.040';

lib/BusyBird/Flow.pm  view on Meta::CPAN

package BusyBird::Flow;
use v5.8.0;
use strict;
use warnings;
use Async::Queue;
use BusyBird::Log qw(bblog);
use CPS qw(kforeach);
use Carp;
use Scalar::Util qw(weaken);
use Try::Tiny;

sub new {
    my ($class) = @_;
    my $self = bless {
        filters => [],
    }, $class;
    $self->{queue} = $self->_create_queue();
    return $self;
}

lib/BusyBird/Main.pm  view on Meta::CPAN

package BusyBird::Main;
use v5.8.0;
use strict;
use warnings;
use BusyBird::Timeline;
use BusyBird::Watcher::Aggregator;
use BusyBird::Log qw(bblog);
use BusyBird::Config;
use Tie::IxHash;
use Carp;
use Try::Tiny;

our @CARP_NOT = qw(BusyBird::Timeline BusyBird::Config);

sub new {
    my ($class) = @_;
    tie(my %timelines, 'Tie::IxHash');
    my $self = bless {
        timelines => \%timelines,
        config => BusyBird::Config->new(type => "global", with_default => 1),
    }, $class;

lib/BusyBird/Main/PSGI.pm  view on Meta::CPAN

package BusyBird::Main::PSGI;
use v5.8.0;
use strict;
use warnings;
use BusyBird::Util qw(set_param future_of);
use BusyBird::Main::PSGI::View;
use Router::Simple;
use Plack::Request;
use Plack::Builder ();
use Plack::App::File;
use Try::Tiny;
use JSON qw(decode_json);
use Scalar::Util qw(looks_like_number);
use List::Util qw(min);
use Carp;
use Exporter 5.57 qw(import);
use URI::Escape qw(uri_unescape);
use Encode qw(decode_utf8);
use Future::Q;
use POSIX qw(ceil);

lib/BusyBird/Main/PSGI/View.pm  view on Meta::CPAN

package BusyBird::Main::PSGI::View;
use v5.8.0;
use strict;
use warnings;
use BusyBird::Util qw(set_param split_with_entities);
use Carp;
use Try::Tiny;
use Scalar::Util qw(weaken);
use JSON qw(to_json);
use Text::Xslate qw(html_builder html_escape);
use File::Spec;
use Encode ();
use JavaScript::Value::Escape ();
use DateTime::TimeZone;
use BusyBird::DateTime::Format;
use BusyBird::Log qw(bblog);
use BusyBird::SafeData qw(safed);

lib/BusyBird/Runner.pm  view on Meta::CPAN

package BusyBird::Runner;
use v5.8.0;
use strict;
use warnings;
use Getopt::Long qw(GetOptionsFromArray :config no_ignore_case bundling);
use BusyBird::Util qw(config_directory config_file_path);
use File::Spec;
use Try::Tiny;
use Plack::Runner ();
use Exporter 5.57 qw(import);

our @EXPORT_OK = qw(run);

sub run {
    my (@argv) = @_;
    my @plack_opts = try {
        prepare_plack_opts(@argv);
    }catch {

lib/BusyBird/StatusStorage/Common.pm  view on Meta::CPAN

package BusyBird::StatusStorage::Common;
use v5.8.0;
use strict;
use warnings;
use Carp;
use Exporter 5.57 qw(import);
use BusyBird::Util qw(future_of);
use BusyBird::DateTime::Format;
use DateTime;
use Try::Tiny;
use Future::Q;

our @EXPORT_OK = qw(contains ack_statuses get_unacked_counts);

sub ack_statuses {
    my ($self, %args) = @_;
    croak 'timeline arg is mandatory' if not defined $args{timeline};
    my $ids;
    if(defined($args{ids})) {
        if(!ref($args{ids})) {

lib/BusyBird/StatusStorage/Memory.pm  view on Meta::CPAN

use warnings;
use parent ('BusyBird::StatusStorage');
use BusyBird::Util qw(set_param sort_statuses);
use BusyBird::Log qw(bblog);
use BusyBird::StatusStorage::Common qw(contains ack_statuses get_unacked_counts);
use BusyBird::DateTime::Format;
use Storable qw(dclone);
use Carp;
use List::Util qw(min);
use JSON;
use Try::Tiny;

sub new {
    my ($class, %options) = @_;
    my $self = bless {
        timelines => {}, ## timelines should always be sorted.
    }, $class;
    $self->set_param(\%options, 'max_status_num', 2000);
    if($self->{max_status_num} <= 0) {
        croak "max_status_num option must be bigger than 0.";
    }

lib/BusyBird/StatusStorage/SQLite.pm  view on Meta::CPAN

package BusyBird::StatusStorage::SQLite;
use v5.8.0;
use strict;
use warnings;
use parent ("BusyBird::StatusStorage");
use DBI;
use Carp;
use Try::Tiny;
use SQL::Maker 1.19;
use SQL::QueryMaker 0.03 qw(sql_and sql_eq sql_ne sql_or sql_lt sql_le sql_raw);
use BusyBird::DateTime::Format;
use BusyBird::Util qw(set_param);
use JSON;
use Scalar::Util qw(looks_like_number);
use DateTime::Format::Strptime;
use DateTime;
no autovivification;

t/WebAPI.t  view on Meta::CPAN

use BusyBird::StatusStorage::SQLite;
use BusyBird::DateTime::Format;
use testlib::HTTP;
use BusyBird::Test::StatusStorage qw(:status test_cases_for_ack);
use testlib::Timeline_Util qw(status);
use testlib::Main_Util qw(create_main);
use BusyBird::Log ();
use Plack::Test;
use Encode ();
use JSON qw(encode_json decode_json);
use Try::Tiny;

$BusyBird::Log::Logger = undef;

sub create_dying_status_storage {
    my $mock = Test::MockObject->new();
    foreach my $method (map { "${_}_statuses" } qw(ack get put delete)) {
        $mock->mock($method, sub {
            die "$method dies.";
        });
    }

t/testlib/StatusStorage/CrazyStatus.pm  view on Meta::CPAN

package testlib::StatusStorage::CrazyStatus;
use strict;
use warnings;
use Exporter qw(import);
use Test::More;
use testlib::CrazyStatus ();
use testlib::Timeline_Util qw(*LOOP *UNLOOP sync status);
use Try::Tiny;

our @EXPORT_OK = qw(test_storage_crazy_statuses);

sub crazy_statuses {
    my ($accept_crazy_timestamps) = @_;
    my @common = testlib::CrazyStatus::crazy_statuses();
    my (@ng, @crazy_but_ok);
    foreach my $s (@common) {
        if(!defined($s->{busybird}) || ref($s->{busybird}) eq 'HASH') {
            push @crazy_but_ok, $s;