Able to use strings rather than having to use hash refs

[catagits/CatalystX-DynamicComponent.git] / lib / CatalystX / DynamicComponent.pm

diff --git a/lib/CatalystX/DynamicComponent.pm b/lib/CatalystX/DynamicComponent.pm
index b99e35d..a8e489c 100644 (file)
--- a/lib/CatalystX/DynamicComponent.pm
+++ b/lib/CatalystX/DynamicComponent.pm
@@ -4,6 +4,7 @@ use MooseX::Types::Moose qw/Str CodeRef HashRef ArrayRef/;
 use Catalyst::Utils;
 use Moose::Util::TypeConstraints;
 use List::MoreUtils qw/uniq/;
+use Moose::Autobox;
 use namespace::autoclean;
 
 enum __PACKAGE__ . '::ResolveStrategy' => qw/
@@ -23,6 +24,9 @@ parameter 'pre_immutable_hook' => (
     predicate => 'has_pre_immutable_hook',
 );
 
+my $coerceablearray = subtype ArrayRef;
+coerce $coerceablearray, from Str, via { [ $_ ] };
+
 my %parameters = (
     methods => {
         isa =>HashRef, 
@@ -30,12 +34,12 @@ my %parameters = (
         resolve_strategy => 'merge',
     },
     roles => {
-        isa => ArrayRef,
+        isa => $coerceablearray, coerce => 1,
         default => sub { [] },
         resolve_strategy => 'merge',
     },
     superclasses => {
-        isa => ArrayRef,
+        isa => $coerceablearray, coerce => 1,
         default => sub { [] },
         resolve_strategy => 'replace',
     },
@@ -55,9 +59,15 @@ foreach my $name (keys %parameters) {
 
 # Code refs to implement the strategy types
 my %strategies = ( # Right hand precedence where appropriate
-    replace => sub { $_[1] ? $_[1] : $_[0]; },
+    replace => sub { 
+        $_[0] = [ $_[0] ] if $_[0] && !ref $_[0];
+        $_[1] = [ $_[1] ] if $_[1] && !ref $_[1];
+        $_[1] ? $_[1] : $_[0];
+    },
     merge => sub {
-        if (ref($_[0]) eq 'ARRAY') {
+        $_[0] = [ $_[0] ] if $_[0] && !ref $_[0];
+        $_[1] = [ $_[1] ] if $_[1] && !ref $_[1];
+        if (ref($_[0]) eq 'ARRAY' || ref($_[1]) eq 'ARRAY') {
             [ uniq( @{ $_[0] }, @{ $_[1] } ) ];
         }
         else {
@@ -82,28 +92,27 @@ role {
 
     method $name => sub {
         my ($app, $name, $config) = @_;
+        my $appclass = blessed($app) || $app;
 
         $config ||= {};
 
-        my $appclass = blessed($app) || $app;
-
         my $type = $name;
         $type =~ s/::.*$//;
-        $name = $appclass . '::' . $name;
 
-        my $meta = Moose->init_meta( for_class => $name );
+        my $component_name = $appclass . '::' . $name;
+        my $meta = Moose->init_meta( for_class => $component_name );
 
         my @superclasses = @{ $get_resolved_config->('superclasses', $p, $config) };
         push(@superclasses, 'Catalyst::' . $type) unless @superclasses;
         $meta->superclasses(@superclasses);
 
         my $methods = $get_resolved_config->('methods', $p, $config);
-        foreach my $name (keys %$methods) {
-            $meta->add_method($name => $methods->{$name});
+        foreach my $method_name (keys %$methods) {
+            $meta->add_method($method_name => $methods->{$method_name});
         }
 
         if (my @roles = @{ $get_resolved_config->('roles', $p, $config) }) {
-            Moose::Util::apply_all_roles( $name, @roles);
+            Moose::Util::apply_all_roles( $component_name, @roles);
         }
 
         if ($p->has_pre_immutable_hook) {
@@ -117,8 +126,8 @@ role {
 
         $meta->make_immutable;
 
-        my $instance = $app->setup_component($name);
-        $app->components->{ $name } = $instance;
+        my $instance = $app->setup_component($component_name);
+        $app->components->{ $component_name } = $instance;
     };
 };