- and we're "implicitly" passing along some constructor args
- Lifecycle => Singleton
+ - Fix B::B so that Service::WithParametrs' parameters attribute has a builder
+ - Fix ConstructorInjection so that default parameters are supplied (for accept_context_args)
+ - Fix ConstructorInjection's 'suffix' - should be called 'config_key' or something, and
+ should be an attribute on the service (as it never changes), rather than a parameter
+ to the service
+
- We make a 'components' sub container in the main container.
- This gets the ConstructorInjection COMPONENT services, as model_Foo.
- Lifecycle of these services is Singleton
- Using the sugar added in the previous item
- Test when Model::Foo depends_on Model::Bar
- a) configure additional services in that container
- - super simple container $default_container => as { more services };
- class MyApp::Container extends Catalyst::Container {
- use Bread::Board; # Or our own sugar?
- method BUILD { container $self => as {
- service model => ...; # some constructor injection to MyApp::Model or something
- container Model => as {
- component Foo => (dependencies => ['/model']); # As per default!
- component Bar => (dependencies => ['/model/Foo']); # Magic!
- };
- # Note - implementation of BB may need to be changed to support making sure existing
- # services actually get overridden. not sure how the default container behaves when doing that
- # above code would build the constructor injection as it currently does,
- # defaulting to the class name in the right namespace as declared by the surrounding container
- # as well as adding using the catalyst-specific service class
- } }
- };
-
- let's consider the usage patterns we actually want to enable by doing the whole B::B thing
- what happens if i make the "per-app" service for a component life only for the duration of the request?
- or be instanciated every time i look up the component?
- (or scoping it per session, or having a block injection, or something)
-
- say you override the app service to be per-request
- now the wrapper for the per-request variant doesn't make sense anymore. does it?
- because you're only overriding one half of what has been generated automatically
-
- ah, so you have basically ended up with getting a request scoped thing to be used to construct a request scoped thing, which is pointless? Would/could you not just override the
- service which is actually getting looked up instead, and make it not depend on the auto-generated per-app scope service, which will then just never be built?
-
- yes, you could. but then you'd have to be aware of the distinction
- which is what i hoped to be a barely visible backcompat thing
- but which i'm afraid it won't be if we go for two actual separate services
-
- what stops the sugar we give from not just making you specify the lifecycle, and giving you the obvious name / wiring?
- i.e. everything looks like 'Foo', so you don't have to know COMPONENT/Foo exists
-
- my hopes of not needing any sugar at all, i guess
-
- only a couple of new lifecycles to be registered with the container - ??
+#### Extending my app, notes
+
+Basically try to implement something like this (starting out without the sugar!), and see how it breaks
+and what needs to be done to fix it!
+
+##### Eventual syntax
+
+package MyApp::Container;
+use Catalyst::IOC;
+
+ container $self, as {
+ container model => as {
+ component Foo => (); # As per default!
+ component Bar => (dependencies => ['/model/Foo']); # Magic!
+ component Baz => ( lifecycle => 'InstancePerContext );
+ component Quux => ( lifecycle => 'Singleton' ); # ACCEPT_CONTEXT not called
+ };
+ # Note - implementation of BB may need to be changed to support making sure existing
+ # services actually get overridden. not sure how the default container behaves when doing that
+ # above code would build the constructor injection as it currently does,
+ # defaulting to the class name in the right namespace as declared by the surrounding container
+ # as well as adding using the catalyst-specific service class
+ };
+
+1;
+
+##### To start with
+
+package MyApp::Container;
+use Moose;
+
+extends 'Catalyst::Container;
+
+after BUILD => sub {
+ my $self = shift;
+ my $model_container = $self->get_sub_container('model');
+ my $service = Catalyst::IOC::ConstructorInjection->new(
+ name => 'Baz',
+ class => 'MyApp::Model::Baz',
+ dependencies => [
+ depends_on( '/application_name' ),
+ depends_on( '/config' ),
+ depends_on( '/model/Foo' ),
+ ],
+ lifecycle => 'InstancePerContext',
+ );
+ $model_container->add_service( 'Foo', $service );
+};
### To polish off / t0m review
+# also, do you think I should draw it here, or just return the data structure?
+sub get_components_names_types {
- + MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = {
-
- +# FIXME - just till I understand how it's supposed to be done
- +# Made this so that COMPONENT is executed once,
- +# and ACCEPT_CONTEXT every call.
- +has instance => (
- + is => 'rw',
-
- # This is ok??
- +my $applevel_config = TestAppContainer->container->resolve(service => 'config')->{applevel_config};
- +__PACKAGE__->config(applevel_config => 'foo');
-
+ +Same as L<build_model_subcontainer>, but for controllers. The difference is
+ +that there is no ACCEPT_CONTEXT for controllers.
+ ^^ This is wrong!!
+
+ - my $accept_context_args = $self->param('accept_context_args');
+ + my $accept_context_args = $params{accept_context_args};
+ ^^ This is wrong! The service should be allowed to mangle the accept_context args, no?
+ Without this change, the user could make a custom service which mangled the param, and use
+ Catalyst/IOC/Service/WithAcceptContext.pm, with this change, that module will always see the
+ un-mangled version??
accept_context_args - where does this come from?
+
+ + $purity = $purity // 1;
+ ^^ perl 5.10 only
### Known issues