fix union with string types

[gitmo/MooseX-Types.git] / lib / MooseX / Types.pm

diff --git a/lib/MooseX/Types.pm b/lib/MooseX/Types.pm
index 4a39855..a19d709 100644 (file)
--- a/lib/MooseX/Types.pm
+++ b/lib/MooseX/Types.pm
@@ -9,15 +9,18 @@ MooseX::Types - Organise your Moose types in libraries
 
 use Moose::Util::TypeConstraints;
 use MooseX::Types::TypeDecorator;
-use MooseX::Types::Base             ();
-use MooseX::Types::Util             qw( filter_tags );
+use MooseX::Types::Base               ();
+use MooseX::Types::Util               qw( filter_tags );
 use MooseX::Types::UndefinedType;
-use Carp::Clan                      qw( ^MooseX::Types );
+use MooseX::Types::CheckedUtilExports ();
+use Carp::Clan                        qw( ^MooseX::Types );
+use Sub::Name;
+use Scalar::Util                      'reftype';
 
 use namespace::clean -except => [qw( meta )];
 
 use 5.008;
-our $VERSION = 0.10;
+our $VERSION = '0.14';
 my $UndefMsg = q{Action for type '%s' not yet defined in library '%s'};
 
 =head1 SYNOPSIS
@@ -35,7 +38,7 @@ my $UndefMsg = q{Action for type '%s' not yet defined in library '%s'};
     )];
 
   # import builtin types
-  use MooseX::Types::Moose 'Int';
+  use MooseX::Types::Moose qw/Int HashRef/;
 
   # type definition.
   subtype PositiveInt, 
@@ -70,6 +73,12 @@ my $UndefMsg = q{Action for type '%s' not yet defined in library '%s'};
   subtype StrOrArrayRef,
     as Str|ArrayRef;
 
+  class_type 'DateTime';
+
+  coerce 'DateTime',
+    from HashRef,
+    via { DateTime->new(%$_) };
+
   1;
 
 =head2 Usage
@@ -113,6 +122,10 @@ names of the types will be prefixed with the library's name.
 This module will also provide you with some helper functions to make it 
 easier to use Moose types in your code.
 
+String type names will produce a warning, unless it's for a C<class_type> or
+C<role_type> declared within the library, or a fully qualified name like
+C<'MyTypeLibrary::Foo'>.
+
 =head1 TYPE HANDLER FUNCTIONS
 
 =head2 $type
@@ -260,6 +273,8 @@ The fully qualified name of this type as L<Moose> knows it.
 A message that will be thrown when type functionality is used but the
 type does not yet exist.
 
+=back
+
 =head1 RECURSIVE SUBTYPES
 
 As of version 0.08, L<Moose::Types> has experimental support for Recursive
@@ -337,7 +352,12 @@ sub import {
     }
 
     # run type constraints import
-    return Moose::Util::TypeConstraints->import({ into => $callee });
+    Moose::Util::TypeConstraints->import({ into => $callee });
+
+    # override some with versions that check for syntax errors
+    MooseX::Types::CheckedUtilExports->import({ into => $callee });
+
+    1;
 }
 
 =head2 type_export_generator
@@ -354,20 +374,23 @@ sub type_export_generator {
     
     ## Return an anonymous subroutine that will generate the proxied type
     ## constraint for you.
-    
-    return sub {
-        my $type_constraint;
+
+    return subname "__TYPE__::$name" => sub {
+        my $type_constraint = $class->create_base_type_constraint($name);
+
         if(defined(my $params = shift @_)) {
             ## We currently only allow a TC to accept a single, ArrayRef
             ## parameter, as in HashRef[Int], where [Int] is what's inside the
             ## ArrayRef passed.
-            if(ref $params eq 'ARRAY') {
+            if(reftype $params eq 'ARRAY') {
                 $type_constraint = $class->create_arged_type_constraint($name, @$params);
+            } elsif(!defined $type_constraint) {
+                croak "Syntax error in type definition (did you forget a comma"
+                    . " after $type?)";
             } else {
-                croak 'Arguments must be an ArrayRef, not '. ref $params;
+                croak "Argument must be an ArrayRef to create a parameterized "
+                    . "type, Eg.: ${type}[Int]. Got: ".ref($params)."."
             }
-        } else {
-            $type_constraint = $class->create_base_type_constraint($name);
         }
 
         $type_constraint = defined($type_constraint) ? $type_constraint