use warnings;
use Carp ();
-use List::MoreUtils qw( all );
-use Scalar::Util 'blessed';
+use List::MoreUtils qw( all any );
+use Scalar::Util qw( blessed reftype );
use Moose::Exporter;
-our $VERSION = '0.59';
+our $VERSION = '0.72';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
sub message (&);
sub optimize_as (&);
-## private stuff ...
-sub _create_type_constraint ($$$;$$);
-sub _install_type_coercions ($$);
-
## --------------------------------------------------------
use Moose::Meta::TypeConstraint;
Moose::Exporter->setup_import_methods(
as_is => [
qw(
- type subtype class_type role_type as where message optimize_as
+ type subtype class_type role_type maybe_type
+ as where message optimize_as
coerce from via
enum
find_type_constraint
}
(scalar @type_constraint_names >= 2)
- || Moose->throw_error("You must pass in at least 2 type names to make a union");
+ || __PACKAGE__->_throw_error("You must pass in at least 2 type names to make a union");
my @type_constraints = map {
find_or_parse_type_constraint($_) ||
- Moose->throw_error("Could not locate type constraint ($_) for the union");
+ __PACKAGE__->_throw_error("Could not locate type constraint ($_) for the union");
} @type_constraint_names;
return Moose::Meta::TypeConstraint::Union->new(
my ($base_type, $type_parameter) = _parse_parameterized_type_constraint($type_constraint_name);
(defined $base_type && defined $type_parameter)
- || Moose->throw_error("Could not parse type name ($type_constraint_name) correctly");
-
- # We need to get the relevant type constraints and use them to
- # create the name to ensure that we end up with the fully
- # normalized name, because the user could've passed something like
- # HashRef[Str|Int] and we want to make that HashRef[Int|Str].
- my $base_type_tc = $REGISTRY->get_type_constraint($base_type)
- || Moose->throw_error("Could not locate the base type ($base_type)");
- my $parameter_tc = find_or_create_isa_type_constraint($type_parameter)
- || Moose->throw_error("Could not locate the parameter type ($type_parameter)");
-
- return Moose::Meta::TypeConstraint::Parameterized->new(
- name => $base_type_tc->name . '[' . $parameter_tc->name . ']',
- parent => $base_type_tc,
- type_parameter => $parameter_tc,
- );
+ || __PACKAGE__->_throw_error("Could not parse type name ($type_constraint_name) correctly");
+
+ if ($REGISTRY->has_type_constraint($base_type)) {
+ my $base_type_tc = $REGISTRY->get_type_constraint($base_type);
+ return _create_parameterized_type_constraint(
+ $base_type_tc,
+ $type_parameter
+ );
+ } else {
+ __PACKAGE__->_throw_error("Could not locate the base type ($base_type)");
+ }
}
+sub _create_parameterized_type_constraint {
+ my ( $base_type_tc, $type_parameter ) = @_;
+ if ( $base_type_tc->can('parameterize') ) {
+ return $base_type_tc->parameterize($type_parameter);
+ } else {
+ return Moose::Meta::TypeConstraint::Parameterized->new(
+ name => $base_type_tc->name . '[' . $type_parameter . ']',
+ parent => $base_type_tc,
+ type_parameter => find_or_create_isa_type_constraint($type_parameter),
+ );
+ }
+}
+
#should we also support optimized checks?
sub create_class_type_constraint {
my ( $class, $options ) = @_;
# too early for this check
#find_type_constraint("ClassName")->check($class)
- # || Moose->throw_error("Can't create a class type constraint because '$class' is not a class name");
+ # || __PACKAGE__->_throw_error("Can't create a class type constraint because '$class' is not a class name");
my %options = (
class => $class,
# too early for this check
#find_type_constraint("ClassName")->check($class)
- # || Moose->throw_error("Can't create a class type constraint because '$class' is not a class name");
+ # || __PACKAGE__->_throw_error("Can't create a class type constraint because '$class' is not a class name");
my %options = (
role => $role,
sub register_type_constraint {
my $constraint = shift;
- Moose->throw_error("can't register an unnamed type constraint") unless defined $constraint->name;
+ __PACKAGE__->_throw_error("can't register an unnamed type constraint") unless defined $constraint->name;
$REGISTRY->add_type_constraint($constraint);
return $constraint;
}
# type constructors
sub type {
- splice(@_, 1, 0, undef);
- goto &_create_type_constraint;
+ # back-compat version, called without sugar
+ if ( ! any { ( reftype($_) || '' ) eq 'HASH' } @_ ) {
+ return _create_type_constraint( $_[0], undef, $_[1] );
+ }
+
+ my $name = shift;
+
+ my %p = map { %{$_} } @_;
+
+ return _create_type_constraint( $name, undef, $p{where}, $p{message}, $p{optimize_as} );
}
sub subtype {
- # NOTE:
- # this adds an undef for the name
- # if this is an anon-subtype:
- # subtype(Num => where { $_ % 2 == 0 }) # anon 'even' subtype
- # or
- # subtype(Num => where { $_ % 2 == 0 }) message { "$_ must be an even number" }
- #
- # but if the last arg is not a code ref then it is a subtype
- # alias:
+ # crazy back-compat code for being called without sugar ...
#
- # subtype(MyNumbers => as Num); # now MyNumbers is the same as Num
- # ... yeah I know it's ugly code
- # - SL
- unshift @_ => undef if scalar @_ == 2 && ( 'CODE' eq ref( $_[-1] ) );
- unshift @_ => undef
- if scalar @_ == 3 && all { ref($_) =~ /^(?:CODE|HASH)$/ } @_[ 1, 2 ];
- goto &_create_type_constraint;
+ # subtype 'Parent', sub { where };
+ if ( scalar @_ == 2 && ( reftype( $_[1] ) || '' ) eq 'CODE' ) {
+ return _create_type_constraint( undef, @_ );
+ }
+
+ # subtype 'Parent', sub { where }, sub { message };
+ # subtype 'Parent', sub { where }, sub { message }, sub { optimized };
+ if ( scalar @_ >= 3 && all { ( reftype($_) || '' ) eq 'CODE' }
+ @_[ 1 .. $#_ ] ) {
+ return _create_type_constraint( undef, @_ );
+ }
+
+ # subtype 'Name', 'Parent', ...
+ if ( scalar @_ >= 2 && all { !ref } @_[ 0, 1 ] ) {
+ return _create_type_constraint(@_);
+ }
+
+ if ( @_ == 1 && ! ref $_[0] ) {
+ __PACKAGE__->_throw_error('A subtype cannot consist solely of a name, it must have a parent');
+ }
+
+ # The blessed check is mostly to accommodate MooseX::Types, which
+ # uses an object which overloads stringification as a type name.
+ my $name = ref $_[0] && ! blessed $_[0] ? undef : shift;
+
+ my %p = map { %{$_} } @_;
+
+ # subtype Str => where { ... };
+ if ( ! exists $p{as} ) {
+ $p{as} = $name;
+ $name = undef;
+ }
+
+ return _create_type_constraint( $name, $p{as}, $p{where}, $p{message}, $p{optimize_as} );
}
sub class_type {
);
}
+sub maybe_type {
+ my ($type_parameter) = @_;
+
+ register_type_constraint(
+ $REGISTRY->get_type_constraint('Maybe')->parameterize($type_parameter)
+ );
+}
+
sub coerce {
my ($type_name, @coercion_map) = @_;
_install_type_coercions($type_name, \@coercion_map);
}
-sub as { @_ }
-sub from { @_ }
-sub where (&) { $_[0] }
-sub via (&) { $_[0] }
-
-sub message (&) { +{ message => $_[0] } }
-sub optimize_as (&) { +{ optimized => $_[0] } }
+# The trick of returning @_ lets us avoid having to specify a
+# prototype. Perl will parse this:
+#
+# subtype 'Foo'
+# => as 'Str'
+# => where { ... }
+#
+# as this:
+#
+# subtype( 'Foo', as( 'Str', where { ... } ) );
+#
+# If as() returns all it's extra arguments, this just works, and
+# preserves backwards compatibility.
+sub as { { as => shift }, @_ }
+sub where (&) { { where => $_[0] } }
+sub message (&) { { message => $_[0] } }
+sub optimize_as (&) { { optimize_as => $_[0] } }
+
+sub from {@_}
+sub via (&) { $_[0] }
sub enum {
my ($type_name, @values) = @_;
$type_name = undef;
}
(scalar @values >= 2)
- || Moose->throw_error("You must have at least two values to enumerate through");
+ || __PACKAGE__->_throw_error("You must have at least two values to enumerate through");
my %valid = map { $_ => 1 } @values;
register_type_constraint(
## --------------------------------------------------------
sub _create_type_constraint ($$$;$$) {
- my $name = shift;
- my $parent = shift;
- my $check = shift;
-
- my ($message, $optimized);
- for (@_) {
- $message = $_->{message} if exists $_->{message};
- $optimized = $_->{optimized} if exists $_->{optimized};
- }
+ my $name = shift;
+ my $parent = shift;
+ my $check = shift;
+ my $message = shift;
+ my $optimized = shift;
- my $pkg_defined_in = scalar(caller(0));
+ my $pkg_defined_in = scalar( caller(1) );
- if (defined $name) {
+ if ( defined $name ) {
my $type = $REGISTRY->get_type_constraint($name);
( $type->_package_defined_in eq $pkg_defined_in )
. " and cannot be created again in "
. $pkg_defined_in )
if defined $type;
- }
- my $class = "Moose::Meta::TypeConstraint";
-
- # FIXME should probably not be a special case
- if ( defined $parent and $parent = find_or_parse_type_constraint($parent) ) {
- $class = "Moose::Meta::TypeConstraint::Parameterizable"
- if $parent->isa("Moose::Meta::TypeConstraint::Parameterizable");
+ $name =~ /^[\w:\.]+$/
+ or die qq{$name contains invalid characters for a type name.}
+ . qq{ Names can contain alphanumeric character, ":", and "."\n};
}
- my $constraint = $class->new(
- name => $name || '__ANON__',
+ my %opts = (
+ name => $name,
package_defined_in => $pkg_defined_in,
- ($parent ? (parent => $parent ) : ()),
- ($check ? (constraint => $check) : ()),
- ($message ? (message => $message) : ()),
- ($optimized ? (optimized => $optimized) : ()),
+ ( $check ? ( constraint => $check ) : () ),
+ ( $message ? ( message => $message ) : () ),
+ ( $optimized ? ( optimized => $optimized ) : () ),
);
- # NOTE:
- # if we have a type constraint union, and no
- # type check, this means we are just aliasing
- # the union constraint, which means we need to
- # handle this differently.
- # - SL
- if (not(defined $check)
- && $parent->isa('Moose::Meta::TypeConstraint::Union')
- && $parent->has_coercion
- ){
- $constraint->coercion(Moose::Meta::TypeCoercion::Union->new(
- type_constraint => $parent
- ));
+ my $constraint;
+ if ( defined $parent
+ and $parent
+ = blessed $parent ? $parent : find_or_create_isa_type_constraint($parent) )
+ {
+ $constraint = $parent->create_child_type(%opts);
+ }
+ else {
+ $constraint = Moose::Meta::TypeConstraint->new(%opts);
}
$REGISTRY->add_type_constraint($constraint)
my ($type_name, $coercion_map) = @_;
my $type = find_type_constraint($type_name);
(defined $type)
- || Moose->throw_error("Cannot find type '$type_name', perhaps you forgot to load it.");
+ || __PACKAGE__->_throw_error("Cannot find type '$type_name', perhaps you forgot to load it.");
if ($type->has_coercion) {
$type->coercion->add_type_coercions(@$coercion_map);
}
use re "eval";
- my $valid_chars = qr{[\w:]};
+ my $valid_chars = qr{[\w:\.]};
my $type_atom = qr{ $valid_chars+ };
my $any;
push @rv => $1;
}
(pos($given) eq length($given))
- || Moose->throw_error("'$given' didn't parse (parse-pos="
+ || __PACKAGE__->_throw_error("'$given' didn't parse (parse-pos="
. pos($given)
. " and str-length="
. length($given)
# define some basic built-in types
## --------------------------------------------------------
+# By making these classes immutable before creating all the types we
+# below, we avoid repeatedly calling the slow MOP-based accessors.
+$_->make_immutable(
+ inline_constructor => 1,
+ constructor_name => "_new",
+
+ # these are Class::MOP accessors, so they need inlining
+ inline_accessors => 1
+ ) for grep { $_->is_mutable }
+ map { $_->meta }
+ qw(
+ Moose::Meta::TypeConstraint
+ Moose::Meta::TypeConstraint::Union
+ Moose::Meta::TypeConstraint::Parameterized
+ Moose::Meta::TypeConstraint::Parameterizable
+ Moose::Meta::TypeConstraint::Class
+ Moose::Meta::TypeConstraint::Role
+ Moose::Meta::TypeConstraint::Enum
+ Moose::Meta::TypeConstraint::Registry
+);
+
type 'Any' => where { 1 }; # meta-type including all
type 'Item' => where { 1 }; # base-type
=> where { $_->can('does') }
=> optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Role;
-my $_class_name_checker = sub {
-};
+my $_class_name_checker = sub {};
subtype 'ClassName'
=> as 'Str'
=> where { Class::MOP::is_class_loaded($_) }
=> optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::ClassName;
+subtype 'RoleName'
+ => as 'ClassName'
+ => where { (($_->can('meta') || return)->($_) || return)->isa('Moose::Meta::Role') }
+ => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::RoleName; ;
+
## --------------------------------------------------------
# parameterizable types ...
sub add_parameterizable_type {
my $type = shift;
(blessed $type && $type->isa('Moose::Meta::TypeConstraint::Parameterizable'))
- || Moose->throw_error("Type must be a Moose::Meta::TypeConstraint::Parameterizable not $type");
+ || __PACKAGE__->_throw_error("Type must be a Moose::Meta::TypeConstraint::Parameterizable not $type");
push @PARAMETERIZABLE_TYPES => $type;
}
sub list_all_builtin_type_constraints { @BUILTINS }
}
+sub _throw_error {
+ shift;
+ require Moose;
+ unshift @_, 'Moose';
+ goto &Moose::throw_error;
+}
+
1;
__END__
=head1 DESCRIPTION
This module provides Moose with the ability to create custom type
-contraints to be used in attribute definition.
+constraints to be used in attribute definition.
=head2 Important Caveat
Int
Str
ClassName
+ RoleName
Ref
ScalarRef
ArrayRef[`a]
GlobRef
FileHandle
Object
- Role
+ Role
B<NOTE:> Any type followed by a type parameter C<[`a]> can be
parameterized, this means you can say:
HashRef[CodeRef] # a hash of str to CODE ref mappings
Maybe[Str] # value may be a string, may be undefined
+If Moose finds a name in brackets that it does not recognize as an
+existing type, it assumes that this is a class name, for example
+C<ArrayRef[DateTime]>.
+
B<NOTE:> Unless you parameterize a type, then it is invalid to
include the square brackets. I.e. C<ArrayRef[]> will be
literally interpreted as a type name.
B<NOTE:> The C<Undef> type constraint for the most part works
correctly now, but edge cases may still exist, please use it
-sparringly.
+sparingly.
B<NOTE:> The C<ClassName> type constraint does a complex package
existence check. This means that your class B<must> be loaded for
this type constraint to pass. I know this is not ideal for all,
but it is a saner restriction than most others.
+B<NOTE:> The C<RoleName> constraint checks a string is I<package name>
+which is a role, like C<'MyApp::Role::Comparable'>. The C<Role>
+constraint checks that an I<object> does the named role.
+
=head2 Type Constraint Naming
+Type name declared via this module can only contain alphanumeric
+characters, colons (:), and periods (.).
+
Since the types created by this module are global, it is suggested
that you namespace your types just as you would namespace your
modules. So instead of creating a I<Color> type for your B<My::Graphics>
-module, you would call the type I<My::Graphics::Color> instead.
+module, you would call the type I<My.Graphics.Color> instead.
=head2 Use with Other Constraint Modules
For instance, this is how you could use it with
L<Declare::Constraints::Simple> to declare a completely new type.
- type 'HashOfArrayOfObjects'
- => IsHashRef(
+ type 'HashOfArrayOfObjects',
+ {
+ where => IsHashRef(
-keys => HasLength,
- -values => IsArrayRef( IsObject ));
+ -values => IsArrayRef(IsObject)
+ )
+ };
For more examples see the F<t/200_examples/204_example_w_DCS.t>
test file.
=over 4
-=item B<type ($name, $where_clause)>
+=item B<type 'Name' => where { } ... >
This creates a base type, which has no parent.
-=item B<subtype ($name, $parent, $where_clause, ?$message)>
+The C<type> function should either be called with the sugar helpers
+(C<where>, C<message>, etc), or with a name and a hashref of
+parameters:
+
+ type( 'Foo', { where => ..., message => ... } );
+
+The valid hashref keys are C<where>, C<message>, and C<optimize_as>.
+
+=item B<subtype 'Name' => as 'Parent' => where { } ...>
This creates a named subtype.
-=item B<subtype ($parent, $where_clause, ?$message)>
+If you provide a parent that Moose does not recognize, it will
+automatically create a new class type constraint for this name.
+
+When creating a named type, the C<subtype> function should either be
+called with the sugar helpers (C<where>, C<message>, etc), or with a
+name and a hashref of parameters:
+
+ subtype( 'Foo', { where => ..., message => ... } );
+
+The valid hashref keys are C<as> (the parent), C<where>, C<message>,
+and C<optimize_as>.
+
+=item B<subtype as 'Parent' => where { } ...>
This creates an unnamed subtype and will return the type
constraint meta-object, which will be an instance of
L<Moose::Meta::TypeConstraint>.
+When creating an anonymous type, the C<subtype> function should either
+be called with the sugar helpers (C<where>, C<message>, etc), or with
+just a hashref of parameters:
+
+ subtype( { where => ..., message => ... } );
+
=item B<class_type ($class, ?$options)>
-Creates a type constraint with the name C<$class> and the metaclass
-L<Moose::Meta::TypeConstraint::Class>.
+Creates a new subtype of C<Object> with the name C<$class> and the
+metaclass L<Moose::Meta::TypeConstraint::Class>.
=item B<role_type ($role, ?$options)>
-Creates a type constraint with the name C<$role> and the metaclass
-L<Moose::Meta::TypeConstraint::Role>.
+Creates a C<Role> type constraint with the name C<$role> and the
+metaclass L<Moose::Meta::TypeConstraint::Role>.
+
+=item B<maybe_type ($type)>
+
+Creates a type constraint for either C<undef> or something of the
+given type.
=item B<enum ($name, @values)>
will match any of the items in C<@values>. It is case sensitive.
See the L<SYNOPSIS> for a simple example.
-B<NOTE:> This is not a true proper enum type, it is simple
-a convient constraint builder.
+B<NOTE:> This is not a true proper enum type, it is simply
+a convenient constraint builder.
=item B<enum (\@values)>
This can be used to define a "hand optimized" version of your
type constraint which can be used to avoid traversing a subtype
-constraint heirarchy.
+constraint hierarchy.
B<NOTE:> You should only use this if you know what you are doing,
all the built in types use this, so your subtypes (assuming they
Given a string that is expected to match a type constraint, will normalize the
string so that extra whitespace and newlines are removed.
-=item B<create_type_constraint_union ($pipe_seperated_types | @type_constraint_names)>
+=item B<create_type_constraint_union ($pipe_separated_types | @type_constraint_names)>
-Given string with C<$pipe_seperated_types> or a list of C<@type_constraint_names>,
+Given string with C<$pipe_separated_types> or a list of C<@type_constraint_names>,
this will return a L<Moose::Meta::TypeConstraint::Union> instance.
=item B<create_parameterized_type_constraint ($type_name)>
=item B<find_or_create_does_type_constraint ($type_name)>
-Attempts to parse the type name using L<find_or_parse_type_constraint> and if
+Attempts to parse the type name using C<find_or_parse_type_constraint> and if
no appropriate constraint is found will create a new anonymous one.
The C<isa> variant will use C<create_class_type_constraint> and the C<does>
=head1 COPYRIGHT AND LICENSE
-Copyright 2006-2008 by Infinity Interactive, Inc.
+Copyright 2006-2009 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>
projects / gitmo/Moose.git / blobdiff