SUPER:: results from the CPAN

SUPER::

Ambrosia

view release on metacpan or search on metacpan

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

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32  
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

14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 {
    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

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40 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

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45     $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

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40  
    $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

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 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

37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57         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

29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49     __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

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 {
    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

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53         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

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 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

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29 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

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42  
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

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64     };
}
 
{
    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

31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 {
}
 
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

29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 }
 
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

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 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

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 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

125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144         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

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29     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

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 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

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30 {
    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

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32     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

89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109  
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

649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669 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

684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704     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

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63  
######################################################################
package Ambrosia::error::Exception;
use base qw/https://metacpan.org/pod/Ambrosia::error::Exception::Error">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/https://metacpan.org/pod/Ambrosia::error::Exception::Error">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/https://metacpan.org/pod/Ambrosia::error::Exception::Error">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/https://metacpan.org/pod/Ambrosia::error::Exception::Error">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

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 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

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 {
    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

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 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 0.515 second using v1.01-cache-2.11-cpan-cba739cd03b )