1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

sub _build_cybs_wsdl {
    my $self = shift;
 
    my $dir = $self->_production ? 'production' : 'test';
 
    load 'File::ShareDir::ProjectDistDir', 'dist_file';
    return load_class('Path::Class::File')->new(
            dist_file(
                'Business-CyberSource',
                $dir
                . '/'
                . 'CyberSourceTransaction_'
                . $self->cybs_api_version
                . '.wsdl'
            )
        );
}

has cybs_wsdl => (
    required  => 0,
    lazy      => 1,
    is        => 'ro',
    isa       => File,
    builder   => '_build_cybs_wsdl',
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# this works

use Class::Load 0.20 'load_class';

my $var = 'baz';

my $class = 'Foo::Bar';

my $result = load_class( $class )->class_method( $var ); # works wonders with ->new

# sometimes this will work, but not always. Try this with the various Dumper functions and see which ones work.

use Module::Load 'load';

my $package = 'Foo::Bar';

load $package, 'function';

my $result = function( $var ); # seems to only work if Foo::Bar's exporter works right, many packages have to be exported at compile time not runtime

# perl doesn't like stuff like this or really anything where I've tried substituting the package name into calling a function. at least not with strict on. This is a large reason I'd avoid functional interfaces. They are hard to substitute at runtime. Maybe I just don't know a good way to do it, without disabling strict, feel free to enlighten me.

load( $package );

my $function = $package . '::' . 'function';

$function->( $var );

  1
  2
  3
  4
  5
  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
 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
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use 5.014;
use warnings;
use Class::Load 'load_class';

package PaymentGateway {
    use Moose;

    sub submit {
        return int( rand(2) );
    }
    __PACKAGE__->meta->make_immutable;
}

package Order {
    use Moose;

    sub make_payment {
        my $self = shift;

        return $self->_payment_gateway->submit( $self );
    }

    has _payment_gateway => (
        isa      => 'Object',
        is       => 'ro',
        required => 1,
    );

    __PACKAGE__->meta->make_immutable;
}

package AppContainer {
    use Moose;
    extends 'Bread::Board::Container';

    use Bread::Board; #import sugar

    sub _build_config {
        my $self = shift;

        # hardcode for example
        return {
            username   => 'foo',
            password   => 'bar',
        };
    }

    has _config => (
        isa     => 'HashRef',
        is      => 'ro',
        lazy    => 1,
        builder => '_build_config',
    );

    sub BUILD {
        my $self = shift;

        # container can take a container as a parameter. if you do this it
        # will simply add to the container it tooks as a paramter
        # this will be our root container /
        container $self => as {
            # subcontainer path to will be /model
            container model => as {

                #  order uses constructor injection
                service order => (
                    class => 'Order',
                    dependencies => {
                        # use full path
                        _payment_gateway =>
                            depends_on('/remote/payment_gateway'),
                    },
                );
            };
            # another subcontainer /service
            container remote => as {
                service username   => $self->_config->{username};
                service password   => $self->_config->{password};

                service payment_gateway => (
                    class        => 'PaymentGateway',
                    # we don't need more than one instance
                    lifecycle    => 'Singleton',
                    dependencies => {
                        username   => depends_on('username'),
                        password   => depends_on('password'),
                    },
                );
            };
        };
    }

    __PACKAGE__->meta->make_immutable;
}

package Controller {
    # this could be any framework controller
    use Moose;

    has _c => (
        isa  => 'Bread::Board::Container',
        is   => 'ro',
    );

    sub process_order {
        my $self = shift;

        my $order = $self->_c->resolve( service => '/model/order' );

        if ( $order->make_payment ) {
            say 'payment succeeded';
        }
        else {
            say 'payment failed';
        }
    }
    __PACKAGE__->meta->make_immutable;
}

my $app = AppContainer->new({ name => 'app' });

# controller has not idea there's only one app containerr
my $controller = Controller->new( _c => $app );

for ( my $i = 0; $i < 10 ; $i++ ) {
    $controller->process_order;
}
1;