SUPER:: results from the CPAN

SUPER::

Ambrosia

view release on metacpan or search on metacpan

lib/Ambrosia/Addons/Session.pm view on Meta::CPAN


our @EXPORT = qw/session/;

our $VERSION = 0.010;

{
    our $__SESSION__;

    sub new : Private
    {
        return shift->SUPER::new(@_);
    }

    sub instance
    {
        return $__SESSION__ ||= @_ ? shift()->new(@_) : new Ambrosia::core::Nil;
    }

    sub destroy
    {
        undef $__SESSION__;

lib/Ambrosia/Addons/Session/Cookie.pm view on Meta::CPAN

{
    public  => [qw/expires path/],
    private => [qw/__cookie/]
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init( @_ );
    my @cookie = fetch CGI::Cookie;
    $self->__cookie = scalar @cookie && @cookie % 2 == 0 ? {@cookie} : {};
    $self->path ||= '/';
}

sub getSessionName
{
    return 'cookie';
}

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

sub INTERNALREDIRECT() { 1 }
sub FORWARD() { 2 }

our @EXPORT = qw/controller/;

{
    my $__CONTROLLER__;

    sub instance
    {
        $__CONTROLLER__ = shift->SUPER::new(@_) unless $__CONTROLLER__;
        return $__CONTROLLER__;
    }

    sub controller
    {
        no warnings;
        return __PACKAGE__->instance(@_);
    }
}

lib/Ambrosia/CommonGatewayInterface/ApacheRequest.pm view on Meta::CPAN

    $self->_handler = new Apache::Request($r);

    if ( $params )
    {
        $self->delete_all;
        foreach ( keys %$params)
        {
            $self->_handler->param($_, $params->{$_});
        }
    }
    $self->SUPER::open();
    return $self->_handler;
}

################################################################################

sub input_data
{
    shift->_handler->param(@_);
}

lib/Ambrosia/CommonGatewayInterface/CGI.pm view on Meta::CPAN


    $self->_handler ||= new CGI;
    if ( $params )
    {
        $self->delete_all;
        foreach ( keys %$params)
        {
            $self->_handler->param($_, $params->{$_});
        }
    }
    $self->SUPER::open();
    return $self->_handler;
}

################################################################################

sub input_data
{
    shift->_handler->param(@_);
}

lib/Ambrosia/CommonGatewayInterface/Options.pm view on Meta::CPAN

our $VERSION = 0.010;

sub open
{
    my $self = shift;

    my ($opt, $usage) = describe_options(@{$self->options_spec});
    $self->_handler = new Ambrosia::CommonGatewayInterface::Options::ICGI(
        __opt => $opt, __usage => $usage
    );
    return $self->SUPER::open();
}

sub error
{
    return $_[0]->_handler->usage()->text();
}

sub input_data
{
    my $self = shift;

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

            my $package = shift;
            my %params = @_ == 1 ? %{$_[0]} : @_;
            assert {$params{engine_name}} 'Context must instance before first call "Context" or you not set "engine_name" in params.';
            #throw Ambrosia::error::Exception::BadUsage('Context must instance before first call "Context"') unless $params{engine_name};

            my ($engine_name,$engine_params) = @params{qw/engine_name engine_params/};
            delete @params{qw/engine_name engine_params/};
            my $cgi = Ambrosia::core::ClassFactory::create_object(
                    'Ambrosia::CommonGatewayInterface::' . $engine_name, $engine_params);

            $_CONTEXT = $package->SUPER::new(__cgi => $cgi, %params);
        }
        return $_CONTEXT;
    }

    sub destroy
    {
        undef $_CONTEXT;
    }

    sub Context

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

    __PACKAGE__->export_to_level(1, @EXPORT);
}

sub assign
{
    $PROCESS_MAP{$$} = shift;
}

sub new : Private
{
    return shift->SUPER::new(@_);
}

sub instance
{
    my $package = shift;
    my $key = shift;

    unless ( $STORAGE{$key} )
    {
        my %params = @_ == 1 ? %{$_[0]} : @_;

lib/Ambrosia/DataProvider/BaseDriver.pm view on Meta::CPAN

{
    public    => [qw/type catalog schema host port/],
    protected => [qw/_handler _cql_query _cache/],
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->_cql_query = [];
}

sub cache
{
    return $_[0]->_cache;
}

######################## CONNECTION/TRANSACTION ########################
#Open connection. Return handler.

lib/Ambrosia/DataProvider/DBIDriver.pm view on Meta::CPAN

        engine_params
        additional_params
        additional_action
        __sth
    /]
};

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->_cache ||= new Ambrosia::Utils::Container;
}

our $VERSION = 0.010;

sub reset
{
    my $self = shift;
    if ( $self->__sth )
    {
        $self->__sth->finish;
        $self->__sth = undef;
    }
    $self->SUPER::reset();
    return $self;
}

sub _name :Abstract :Protected {}

sub _connection_params
{
    my $self = shift;
    return 'dbi:'
        . $self->_name()

lib/Ambrosia/DataProvider/ResourceDriver.pm view on Meta::CPAN

use Ambrosia::Meta;
class
{
    extends   => [qw/Ambrosia::DataProvider::BaseDriver/],
    private   => [qw/__start/],
};

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->_cache = new Ambrosia::core::Nil();
}

our $VERSION = 0.010;

sub reset
{
    my $self = shift;
    $self->SUPER::reset();
    $self->__start = 0;
    return $self;
}

################################################################################

sub begin_transaction
{
}

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

use Ambrosia::Meta;
class sealed {
    private => [qw/__check_access/],
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->__check_access = sub {1};
    $self->on_error(sub {warn "Error: @_\n";1;});
}

sub on_check_access
{
    my $self = shift;
    my $proc = shift;
    if ( $proc && ref $proc eq 'CODE' )
    {

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


our $VERSION = 0.010;

################################################################################

sub _map() { return shift->__AMBROSIA_ALIAS_FIELDS__ || {} }

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    if ( $self->key_value() )
    {
        $self->SET_LOADED;
    }
    else
    {
        $self->SET_NEW;
    }
}

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

    };
}

{
    my %__EVENT_HANDLER__ = ();

    sub new : Private {};

    sub instance
    {
        return $__EVENT_HANDLER__{$$} ||= __PACKAGE__->SUPER::new();
    }
}

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->_handlers = {};
}

sub attachHandler
{
    my $class = shift;
    my $type = ref $class || $class || '';
    my $name = shift;
    my $handler = shift;

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

{
}

sub _TRUE { 1 }

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

    return $class->SUPER::new(
            source => shift,
            driver => new Ambrosia::core::Nil(),
            __variable  => shift || \my $tmp,
            __predicate => \&_TRUE,
            __on        => \&_TRUE,
            __limit     => 0,
            __skip      => 0,
        );
}

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

}

sub assign
{
    $PROCESS_MAP{$$} = shift;
}

{
    sub new : Private
    {
        return shift->SUPER::new(@_);
    }

    sub instance
    {
        my $package = shift;
        my $key = shift;

        unless ( $RPC{$key} )
        {
            my %params = @_ == 1 ? %{$_[0]} : @_;

lib/Ambrosia/RPC/Service/SOAP/Lite.pm view on Meta::CPAN

class
{
    private => [qw/__soap __proxy __outputxml __readable __default_ns __ns __soapversion __timeout __on_error/]
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init( @_ );
    $self->__outputxml = undef if $self->__outputxml ne 'true';
    $self->__soapversion = '1.2' unless $self->__soapversion;
    $self->__soap = undef;
    $self->__on_error = sub {
        my $soap = shift;
        my $som = shift;

        my $error_msg = join "\n", (
                ref $som
                ? ('SOAP FAULT: ', 'code: ' . $som->faultcode, 'desc: ' . $som->faultstring)

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

class
{
    private => [qw/__data/]
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->__data ||= {};
}

sub TIEHASH { $_[1]; }
sub STORE    { }
sub FETCH    { $_[0]->__data->{$_[1]} }
sub FIRSTKEY { each %{$_[0]->__data}; }
sub NEXTKEY  { each %{$_[0]->__data} }
sub EXISTS   { exists $_[0]->__data->{$_[1]} }
sub DELETE   { } #delete $_[0]->__data->{$_[1]} }

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

        return $obj;
    }
}

sub as_hash
{
    my $self = shift;

    if ( @_ )
    {
        return $self->SUPER::as_hash(1)->{__data};
    }
    return { map { $_ => $self->__data->{$_} } keys %{$self->__data} };
}

sub info
{
    my $self = shift;
    return join "\n", map { my $d = $self->__data->{$_}; $_ . '=' . ( ref $d || $d ) } keys %{$self->__data};
}

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

    private => [qw/__list __strategy/]
};

our $VERSION = 0.010;

use Ambrosia::Utils::Enumeration property => __strategy => (STRATEGY_LIFO => 1, STRATEGY_FIFO => 2);

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->__list ||= [];
    $self->SET_STRATEGY_FIFO();
}

sub add
{
    my $self = shift;
    push @{$self->__list}, @_;
    $self;
}

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

class abstract
{
    protected => [qw/_prototype _violations _data/],
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->_violations = new Ambrosia::Validator::Violation(prototype => $self->_prototype);
    $self->_data = {};
}

my $qr_trim = qr/(?:^\s+)|(?:\s+$)/;
sub get_value
{
    return (map { $_ =~ s/$qr_trim//sg; $_; } grep defined $_, @_);
}

lib/Ambrosia/Validator/Constraint.pm view on Meta::CPAN

{
    public => [qw/name errorMessage/],
    private => [qw/constraint/],
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);

    $self->errorMessage = [];
    $self->constraint = sub() { return (shift(), [], []) };
}

sub check
{
    my $self = shift;
    my $v;
    ($v, $self->errorMessage) = $self->constraint->(@_);

lib/Ambrosia/Validator/Violation.pm view on Meta::CPAN

    public => [qw/prototype count/],
    private => [qw/__data/],
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->__data = {};
    $self->SUPER::_init(@_);
    $self->count = 0;

    #no strict 'refs';
    #*{__PACKAGE__ . '::fields'} = sub() { keys %{$_[0]->__data} };
}

sub add
{
    my $self = shift;
    my $f = shift;

lib/Ambrosia/Validator/Violation.pm view on Meta::CPAN


class
{
    public    => [qw/value errorMessage/],
};
our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);
    $self->errorMessage ||= [];
}

1;

__END__

=head1 NAME

Ambrosia::Validator::Violation - it is used for a wrapping of checked object in case of a bad data.

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

    class
    {
        public    => [qw/foo_pub1 foo_pub2/],
        protected => [qw/foo_pro1 foo_pro2/],
        private   => [qw/foo_pri1 foo_pri2/],
    };
    
    sub _init
    {
        my $self = shift;
        $self->SUPER::_init(@_);

        $self->foo_pub1 ||= 'foo_pub1';
        $self->foo_pub2 ||= 'foo_pub2';
        $self->foo_pri1 ||= 'foo_pri1';
        $self->foo_pri2 ||= 'foo_pri2';
        $self->foo_pro1 ||= 2;
        $self->foo_pro2 ||= 'foo_pro2';
    }
    
    sub count

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

        public    => [qw/bar_pub1 bar_pub2/],
        protected => [qw/bar_pro1 bar_pro2/],
        private   => [qw/bar_pri1 bar_pri2 list/],
    };
    
    sub _init
    {
        my $self = shift;

        #Ignore all input data
        $self->SUPER::_init(foo_pri1=>4);
        $self->bar_pub1 = 'bar_pub1';
        $self->bar_pub2 = 'bar_pub2';
        $self->bar_pri1 = 'bar_pri1';
        $self->bar_pri2 = 'bar_pri2';
        $self->bar_pro1 = 'bar_pro1';
        $self->bar_pro2 = 'bar_pro2';

        $self->list = [] unless defined $self->list;

        push @{$self->list}, (new Foo(foo_pub1 => 'list1.1', foo_pub2 => 'list1.2'),

lib/Ambrosia/error/Exceptions.pm view on Meta::CPAN


######################################################################
package Ambrosia::error::Exception;
use base qw/Ambrosia::error::Exception::Error/;
our $VERSION = 0.010;

sub CODE() {'E0000'}

sub throw
{
    return shift->SUPER::throw(CODE, @_);
}

######################################################################
package Ambrosia::error::Exception::BadUsage;
use base qw/Ambrosia::error::Exception::Error/;
our $VERSION = 0.010;

sub CODE() {'E0001'}

sub throw
{
    return shift->SUPER::throw(CODE, @_);
}

######################################################################
package Ambrosia::error::Exception::BadParams;
use base qw/Ambrosia::error::Exception::Error/;
our $VERSION = 0.010;

sub CODE() {'E0002'}

sub throw
{
    return shift->SUPER::throw(CODE, @_);
}

######################################################################
package Ambrosia::error::Exception::AccessDenied;
use base qw/Ambrosia::error::Exception::Error/;
our $VERSION = 0.010;

sub CODE() {'E0003'}

sub throw
{
    return shift->SUPER::throw(CODE, @_);
}

1;

__END__

=head1 NAME

Ambrosia::error::Exception - an unspecified exception.
Ambrosia::error::Exception::BadUsage - this exception will occur if you use something incorrect.

share/Managers/buildApp.pm view on Meta::CPAN

class sealed {
    private => [qw/parser source xslt application/],
    extends => [qw/Ambrosia::BaseManager/]
};

our $VERSION = 0.010;

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);

    $self->parser = XML::LibXML->new();
    $self->xslt = XML::LibXSLT->new();

    my $source = $self->source = $self->parser->parse_file(Context->param('data'));

    $self->application = ($source->getElementsByTagName('Application'))[0]->cloneNode(0);

    $self->application->addChild(($source->getElementsByTagName('Config'))[0]->cloneNode(1));
    $self->application->addChild(($source->getElementsByTagName('DataSource'))[0]->cloneNode(1));

t/Bar.pm view on Meta::CPAN

{
    extends => [qw/t::Foo/],
    public => [qw/bar_pub1 bar_pub2/],
    protected => [qw/bar_pro1 bar_pro2 list_pro/],
    private => [qw/bar_pri1 bar_pri2 list_pri/],
};
    
sub _init
{
    my $self = shift;
    $self->SUPER::_init(foo_pri1 => 'value for bar foo_pri1');#Ignore all input parameters
    $self->bar_pub1 = 'bar_pub1';
    $self->bar_pub2 = 'bar_pub2';
    $self->bar_pri1 = 'bar_pri1';
    $self->bar_pri2 = 'bar_pri2';
    $self->bar_pro1 = 'bar_pro1';
    $self->bar_pro2 = 'bar_pro2';
    $self->list_pro = [];
    push @{$self->list_pro}, (  new t::Foo(foo_pub1=>'pro list1.1',foo_pub2=>'pro list1.2'),
                                new t::Foo(foo_pub1=>'pro list2.1',foo_pub2=>'pro list2.2')
                            );

t/Foo.pm view on Meta::CPAN

class
{
    public => [qw/foo_pub1 foo_pub2/],
    protected => [qw/foo_pro1 foo_pro2/],
    private => [qw/foo_pri1 foo_pri2/],
};

sub _init
{
    my $self = shift;
    $self->SUPER::_init(@_);

    $self->foo_pub1 ||= 'foo_pub1';
    $self->foo_pub2 ||= 'foo_pub2';
    $self->foo_pro1 ||= 'foo_pro1';
    $self->foo_pro2 ||= 'foo_pro2';
    $self->foo_pri1 ||= 'foo_pri1';
    $self->foo_pri2 ||= 'foo_pri2';
}

my $sum = 0;

( run in 1.940 second using v1.01-cache-2.11-cpan-49f99fa48dc )