use Scalar::Util 'blessed';
use Moose::Exporter;
-our $VERSION = '0.64';
+our $VERSION = '0.68';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
}
(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");
+ || __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);
$type_parameter
);
} else {
- Moose->throw_error("Could not locate the base type ($base_type)");
+ __PACKAGE__->_throw_error("Could not locate the base type ($base_type)");
}
}
# 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;
}
my ($type_parameter) = @_;
register_type_constraint(
- # $REGISTRY->get_type_constraint('Maybe')
- # ->generate_constraint_for($type_parameter)
- Moose::Meta::TypeConstraint->new(
- parent => find_type_constraint('Item'),
- constraint => sub {
- my $check = $type_parameter->_compiled_type_constraint;
- return 1 if not(defined($_)) || $check->($_);
- return;
- }
- )
+ $REGISTRY->get_type_constraint('Maybe')->parameterize($type_parameter)
);
}
$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(
. " and cannot be created again in "
. $pkg_defined_in )
if defined $type;
+
+ $name =~ /^[\w:\.]+$/
+ or die qq{$name contains invalid characters for a type name.}
+ . qq{Names can contain alphanumeric character, ":", and "."\n};
}
my %opts = (
my $constraint;
if ( defined $parent
and $parent
- = blessed $parent ? $parent : find_or_parse_type_constraint($parent) )
+ = blessed $parent ? $parent : find_or_create_isa_type_constraint($parent) )
{
$constraint = $parent->create_child_type(%opts);
}
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)
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 {
+ 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
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
=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
This creates a named subtype.
+If you provide a parent that Moose does not recognize, it will
+automatically create a new class type constraint for this name.
+
=item B<subtype ($parent, $where_clause, ?$message)>
This creates an unnamed subtype and will return the type
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)>
=head1 COPYRIGHT AND LICENSE
-Copyright 2006-2008 by Infinity Interactive, Inc.
+Copyright 2006-2009 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>