X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMooseX%2FStorage.pm;h=b5731d4f8a48de84b3384d4d8261d4470b3fdec6;hb=e44b5f5498b782752d2c91b6796698c86143a2f0;hp=dbbdf8567e53a0006b90621ef258bef1b09439fa;hpb=f35d2054a8e958a92b37555c9b64144e07c3e6be;p=gitmo%2FMooseX-Storage.git

diff --git a/lib/MooseX/Storage.pm b/lib/MooseX/Storage.pm
index dbbdf85..b5731d4 100644
--- a/lib/MooseX/Storage.pm
+++ b/lib/MooseX/Storage.pm
@@ -5,7 +5,7 @@ use Moose qw(confess);
 use MooseX::Storage::Meta::Attribute::DoNotSerialize;
 use String::RewritePrefix ();
 
-our $VERSION   = '0.21';
+our $VERSION   = '0.32';
 our $AUTHORITY = 'cpan:STEVAN';
 
 sub import {
@@ -19,21 +19,51 @@ sub import {
     $pkg->meta->add_method('Storage' => __PACKAGE__->meta->find_method_by_name('_injected_storage_role_generator'));
 }
 
-sub __expand_role {
-    my ($base, $value) = @_;
+my %HORRIBLE_GC_AVOIDANCE_HACK;
+
+sub _rewrite_role_name {
+    my ($self, $base, $string) = @_;
+
+    my $role_name = scalar String::RewritePrefix->rewrite(
+        {
+            ''  => "MooseX::Storage::$base\::",
+            '=' => '',
+        },
+        $string,
+    );
+}
+
+sub _expand_role {
+    my ($self, $base, $value) = @_;
 
     return unless defined $value;
 
     if (ref $value) {
-        confess "references for roles are not yet handled";
+        confess "too many args in arrayref role declaration" if @$value > 2;
+        my ($class, $param) = @$value;
+
+        $class = $self->_rewrite_role_name($base => $class);
+        Class::MOP::load_class($class);
+
+        my $role = $class->meta->generate_role(parameters => $param);
+
+        $HORRIBLE_GC_AVOIDANCE_HACK{ $role->name } = $role;
+        return $role->name;
     } else {
-        return scalar String::RewritePrefix->rewrite(
-            {
-                ''  => "MooseX::Storage::$base\::",
-                '=' => '',
-            },
-            $value,
-        );
+        my $class = $self->_rewrite_role_name($base, $value);
+        Class::MOP::load_class($class);
+
+        my $role = $class;
+
+        if ($class->meta->isa(
+            'MooseX::Role::Parameterized::Meta::Role::Parameterizable'
+        )) {
+            $role = $class->meta->generate_role(parameters => undef);
+            $HORRIBLE_GC_AVOIDANCE_HACK{ $role->name } = $role;
+            return $role->name;
+        }
+
+        return $class;
     }
 }
 
@@ -42,13 +72,13 @@ sub _injected_storage_role_generator {
 
     $params{base} = '=MooseX::Storage::Basic' unless defined $params{base};
 
-    my @roles = __expand_role(Base => $params{base});
+    my @roles = __PACKAGE__->_expand_role(Base => $params{base});
 
     # NOTE:
     # you don't have to have a format
     # role, this just means you dont
     # get anything other than pack/unpack
-    push @roles, __expand_role(Format => $params{format});
+    push @roles, __PACKAGE__->_expand_role(Format => $params{format});
 
     # NOTE:
     # many IO roles don't make sense unless
@@ -61,17 +91,13 @@ sub _injected_storage_role_generator {
     # us. This allows the StorableFile to work
     #(exists $params{'format'})
     #    || confess "You must specify a format role in order to use an IO role";
-    push @roles, __expand_role(IO => $params{io});
+    push @roles, __PACKAGE__->_expand_role(IO => $params{io});
 
     # Note:
     # These traits alter the behaviour of the engine, the user can
     # specify these per role-usage
     for my $trait ( @{ $params{'traits'} ||= [] } ) {
-        push @roles, __expand_role(Traits => $trait);
-    }
-
-    for my $role ( @roles ) {
-        Class::MOP::load_class($role) or die "Could not load role ($role)";
+        push @roles, __PACKAGE__->_expand_role(Traits => $trait);
     }
 
     return @roles;
@@ -161,7 +187,7 @@ class name and each instance attribute is stored. Very simple.
 This level is not optional, it is the bare minumum that
 MooseX::Storage provides and all other levels build on top of this.
 
-See L<Moosex::Storage::Basic> for the fundamental implementation and
+See L<MooseX::Storage::Basic> for the fundamental implementation and
 options to C<pack> and C<unpack>
 
 =item B<format>
@@ -180,7 +206,7 @@ The third (io) level is C<load> and C<store>. In this level we are reading
 and writing data to file/network/database/etc.
 
 This level is also optional, in most cases it does require a C<format> role
-to also be used, the expection being the C<StorableFile> role.
+to also be used, the exception being the C<StorableFile> role.
 
 =back
 
@@ -246,7 +272,7 @@ over anyway.
 
 =head1 CAVEAT
 
-This is B<not> a persistence framework, changes to your object after
+This is B<not> a persistence framework; changes to your object after
 you load or store it will not be reflected in the stored class.
 
 =head1 EXPORTS
@@ -255,12 +281,27 @@ you load or store it will not be reflected in the stored class.
 
 =item B<Storage (%options)>
 
-This module will export the C<Storage> method will can be used to
+This module will export the C<Storage> method and can be used to
 load a specific set of MooseX::Storage roles to implement a specific
 combination of features. It is meant to make things easier, but it
 is by no means the only way. You can still compose your roles by
 hand if you like.
 
+By default, options are assumed to be short forms.  For example, this:
+
+  Storage(format => 'JSON');
+
+...will result in looking for MooseX::Storage::Format::JSON.  To use a role
+that is not under the default namespace prefix, start with an equal sign:
+
+  Storage(format => '=My::Private::JSONFormat');
+
+To use a parameterized role (for which, see L<MooseX::Role::Parameterized>) you
+can pass an arrayref of the role name (in short or long form, as above) and its
+parameters:
+
+  Storage(format => [ JSONpm => { json_opts => { pretty => 1 } } ]);
+
 =back
 
 =head1 METHODS