Ambrosia

 view release on metacpan or  search on metacpan

benchmark/Ambrosia/Meta.b  view on Meta::CPAN

    use strict;
    use warnings;
    use lib qw(lib t ..);
    use Ambrosia::Event qw/on_run/;

    sub new
    {
        my $proto = shift;
        my $class = ref $proto || $proto;
        my %self = @_;
        return bless \%self, $class;
    };

    sub getState
    {
        return $_[0]->{State};
    }

    1;
}

lib/Ambrosia/Logger.pm  view on Meta::CPAN

package Ambrosia::Logger;
use strict;
use warnings;

use File::Path;
use IO::File;
use Data::Dumper;
use Time::HiRes qw ( time );
use Scalar::Util "blessed";

use Ambrosia::error::Exceptions;

use base qw/Exporter/;
our @EXPORT = qw/logger/;

our $VERSION = 0.010;

our %PROCESS_MAP = ();
our %LOGGERS = ();

lib/Ambrosia/Logger.pm  view on Meta::CPAN

    else
    {
        $self = {
            _log => undef,
            _prefix => ( $params{-prefix} || '' ),
            _op => ( $params{-op} || '' ),
            _dir => $params{-dir},
            _time => {},
        };
        $pkg .= $key;
        bless $self, $pkg;

        no strict 'refs';
        no warnings 'redefine';

        push @{"${pkg}::ISA"}, __PACKAGE__;

        if ( $params{INFO} )
        {
            *{"${pkg}::log_info"} = sub { goto &__info; };
        }

lib/Ambrosia/Logger.pm  view on Meta::CPAN

    foreach ( @keys )
    {
        my $obj = $LOGGERS{$_}->{object};
        $obj->{_log}->close if $obj->{_log} && $obj->{_dir};
    }
}

sub error
{
    __info_ex(shift, 'ERROR: ', map { ref $_ && blessed($_) && $_->isa('Ambrosia::error::Exception::Error') ? "$_" : $_ } @_);
}

sub log
{
    my ($self, @msg) = @_;
    my($sec, $min, $hour) = (localtime)[0..2];
    @msg = ('EMPTY') unless @msg;
    @msg = map { defined $_ ? $_ : 'undef' } @msg;
    __tolog($self, sprintf("%02d:%02d:%02d (op = %s) %s\n", $hour, $min, $sec, $self->{_op}, join (' ', @msg)));
}

lib/Ambrosia/Utils/Container.pm  view on Meta::CPAN

    '*{}' => \&__as_glob,
    '==' => \&__as_bool,
    'bool'=> \&__as_bool,
    '""'  => \&__as_string,
    '0+'  => \&__as_number,
    'fallback' => 1
    ;

sub call(&)
{
    return bless {code => $_[0]}, 'deferred';
}

sub as_hash
{
    return $_[0] if caller eq __PACKAGE__;
    local $@;
    unless ( exists $_[0]->{value} )
    {
        my $h = $_[0]->{code}->();
        if ( ref $h eq 'HASH' )

lib/Ambrosia/View/JSON.pm  view on Meta::CPAN

{
    my $self = shift;

    my $json = JSON::XS->new;
    $json->utf8(0);
    $json->latin1(1);

    my $str = '';
    eval
    {
        $json->convert_blessed(1);
        $str = $self->data ? $json->encode($self->data) : '{}';
warn "$str\n";
    };
    if ( $@ )
    {
        carp "ERROR: $@";
    }

    return $str;
}

lib/Ambrosia/core/Nil.pm  view on Meta::CPAN

our $VERSION = 0.010;

our $AUTOLOAD;

{
    my $SINGLETON;

    sub new
    {
        my $proto = shift;
        return $SINGLETON ||= bless [], ref $proto || $proto;
    }
}

sub sub_nil
{
    my $obj = shift;
    sub { $obj };
}

sub TO_JSON

lib/Ambrosia/core/Object.pm  view on Meta::CPAN

sub new
{
    my $proto = shift;
    my $class = ref($proto) || $proto;

    if ($class->__AMBROSIA_IS_ABSTRACT__)
    {
        throw Ambrosia::error::Exception 'You cannot instance abstract class ' . $class;
    }

    my $self = bless [[]], $class;
    $self->_init(@_);
    return $self;
}

sub fields
{
    return ();
}

### run from new ###

lib/Ambrosia/error/Exception/Error.pm  view on Meta::CPAN

    my $frames = undef;
    foreach ( @msg )
    {
        if ( ref $_ && eval{$_->can('frames')} )
        {
            $frames = $_;
            last;
        }
    }

    my $self = bless
        {
            _error_code => $error_code,
            _message    => (join ' - ', grep { !ref $_ } @msg),
            _frames     => $frames || [],
        }, $class;

    $self->_addFrames() unless defined $frames;

    die $self;
}

t/FooStandart.pm  view on Meta::CPAN

package Foo;
use strict;
use warnings;

sub new {
    my $proto = shift;
    my $class = ref $proto || $proto;
    return bless {}, $class;
}

sub pro_a{my $self=shift; if (my $v = shift) {$self->{pro_a}=$v;} return $self->{pro_a};}
sub pro_b{my $self=shift; if (my $v = shift) {$self->{pro_b}=$v;} return $self->{pro_b};}
sub pro_c{my $self=shift; if (my $v = shift) {$self->{pro_c}=$v;} return $self->{pro_c};}
sub pro_d{my $self=shift; if (my $v = shift) {$self->{pro_d}=$v;} return $self->{pro_d};}
sub pro_e{my $self=shift; if (my $v = shift) {$self->{pro_e}=$v;} return $self->{pro_e};}
sub pro_f{my $self=shift; if (my $v = shift) {$self->{pro_f}=$v;} return $self->{pro_f};}
sub pro_g{my $self=shift; if (my $v = shift) {$self->{pro_g}=$v;} return $self->{pro_g};}
sub pro_h{my $self=shift; if (my $v = shift) {$self->{pro_h}=$v;} return $self->{pro_h};}