=cut
-#use warnings;
-#use strict;
-
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.07;
+our $VERSION = '0.26';
my $UndefMsg = q{Action for type '%s' not yet defined in library '%s'};
=head1 SYNOPSIS
PositiveInt NegativeInt
ArrayRefOfPositiveInt ArrayRefOfAtLeastThreeNegativeInts
LotsOfInnerConstraints StrOrArrayRef
+ MyDateTime
)];
# import builtin types
- use MooseX::Types::Moose 'Int';
+ use MooseX::Types::Moose qw/Int HashRef/;
# type definition.
subtype PositiveInt,
subtype StrOrArrayRef,
as Str|ArrayRef;
+ # class types
+
+ class_type 'DateTime';
+
+ # or better
+
+ class_type MyDateTime, { class => 'DateTime' };
+
+ coerce MyDateTime,
+ from HashRef,
+ via { DateTime->new(%$_) };
+
1;
=head2 Usage
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
B<Important Note>: This handler will only be exported for types that can
do type coercion. This has the advantage that a coercion to a type that
-cannot hasn't defined any coercions will lead to a compile-time error.
+has not defined any coercions will lead to a compile-time error.
=head1 LIBRARY DEFINITION
package MyWrapper;
use strict;
- use Class::C3;
+ use MRO::Compat;
use base 'MooseX::Types::Wrapper';
sub coercion_export_generator {
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
+subtypes. This will allow:
+
+ subtype Tree() => as HashRef[Str|Tree];
+
+Which validates things like:
+
+ {key=>'value'};
+ {key=>{subkey1=>'value', subkey2=>'value'}}
+
+And so on. This feature is new and there may be lurking bugs so don't be afraid
+to hunt me down with patches and test cases if you have trouble.
+
=head1 NOTES REGARDING TYPE UNIONS
L<MooseX::Types> uses L<MooseX::Types::TypeDecorator> to do some overloading
}
# 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
## 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
: MooseX::Types::UndefinedType->new($name);
sub create_arged_type_constraint {
my ($class, $name, @args) = @_;
my $type_constraint = Moose::Util::TypeConstraints::find_or_create_type_constraint("$name");
- return $type_constraint->parameterize(@args);
+ my $parameterized = $type_constraint->parameterize(@args);
+ # It's obnoxious to have to parameterize before looking for the TC, but the
+ # alternative is to hard-code the assumption that the name is
+ # "$name[$args[0]]", which would be worse.
+ # This breaks MXMS, unfortunately, which relies on things like Tuple[...]
+ # creating new type objects each time.
+ # if (my $existing =
+ # Moose::Util::TypeConstraints::find_type_constraint($parameterized->name)) {
+ # return $existing;
+ # }
+ # Moose::Util::TypeConstraints::register_type_constraint($parameterized);
+ return $parameterized;
}
=head2 create_base_type_constraint ($name)
subtype StrOrArrayRef => as Str|ArrayRef;
-The 'StrOrArrayRef' will have it's stringification activated this causes the
+The 'StrOrArrayRef' will have its stringification activated this causes the
subtype to not be created. Since the bareword type constraints are not strings
you really should not try to treat them that way. You will have to use the ','
operator instead. The author's of this package realize that all the L<Moose>
operator and this could be an issue if you are converting code.
Patches welcome for discussion.
+
+=head2 Compatibility with Sub::Exporter
+
+If you want to use L<Sub::Exporter> with a Type Library, you need to make sure
+you export all the type constraints declared AS WELL AS any additional export
+targets. For example if you do:
+
+ package TypeAndSubExporter; {
+
+ use MooseX::Types::Moose qw(Str);
+ use MooseX::Types -declare => [qw(MyStr)];
+ use Sub::Exporter -setup => { exports => [ qw(something) ] };
+
+ subtype MyStr,
+ as Str;
+
+ sub something {
+ return 1;
+ }
+
+ } 1;
+ package Foo; {
+ use TypeAndSubExporter qw(MyStr);
+ } 1;
+
+You'll get a '"MyStr" is not exported by the TypeAndSubExporter module' error.
+Upi can workaround by:
+
+ - use Sub::Exporter -setup => { exports => [ qw(something) ] };
+ + use Sub::Exporter -setup => { exports => [ qw(something MyStr) ] };
+
+This is a workaround and I am exploring how to make these modules work better
+together. I realize this workaround will lead a lot of duplication in your
+export declarations and will be onerous for large type libraries. Patches and
+detailed test cases welcome. See the tests directory for a start on this.
+
+=head1 COMBINING TYPE LIBRARIES
+
+You may want to combine a set of types for your application with other type
+libraries, like L<MooseX::Types::Moose> or L<MooseX::Types::Common::String>.
+
+The L<MooseX::Types::Combine> module provides a simple API for combining a set
+of type libraries together.
+
=head1 SEE ALSO
L<Moose>,
L<MooseX::Types::Moose>,
L<Sub::Exporter>
-=head1 AUTHOR AND COPYRIGHT
+=head1 ACKNOWLEDGEMENTS
+
+Many thanks to the C<#moose> cabal on C<irc.perl.org>.
+
+=head1 AUTHOR
+
+Robert "phaylon" Sedlacek <rs@474.at>
+
+=head1 CONTRIBUTORS
+
+jnapiorkowski: John Napiorkowski <jjnapiork@cpan.org>
+
+caelum: Rafael Kitover <rkitover@cpan.org>
+
+rafl: Florian Ragwitz <rafl@debian.org>
+
+hdp: Hans Dieter Pearcey <hdp@cpan.org>
-Robert 'phaylon' Sedlacek C<E<lt>rs@474.atE<gt>>, with many thanks to
-the C<#moose> cabal on C<irc.perl.org>.
+autarch: Dave Rolsky <autarch@urth.org>
-Additional features by John Napiorkowski (jnapiorkowski) <jjnapiork@cpan.org>.
+=head1 COPYRIGHT & LICENSE
-=head1 LICENSE
+Copyright (c) 2007-2009 Robert Sedlacek <rs@474.at>
This program is free software; you can redistribute it and/or modify
it under the same terms as perl itself.
projects / gitmo/MooseX-Types.git / blobdiff