use B 'svref_2object';
use Sub::Exporter;
-our $VERSION = '0.10';
+our $VERSION = '0.12';
+our $AUTHORITY = 'cpan:STEVAN';
+
+# Prototyped subs must be predeclared because we have a circular dependency
+# with Moose::Meta::Attribute et. al. so in case of us being use'd first the
+# predeclaration ensures the prototypes are in scope when consumers are
+# compiled
+
+sub find_type_constraint ($);
+sub _create_type_constraint ($$$;$$);
+sub _install_type_coercions ($$);
+sub create_type_constraint_union (@);
+sub type ($$;$$);
+sub subtype ($$;$$$);
+sub coerce ($@);
+sub as ($);
+sub from ($);
+sub where (&);
+sub via (&);
+sub message (&);
+sub optimize_as (&);
+sub enum ($;@);
use Moose::Meta::TypeConstraint;
use Moose::Meta::TypeCoercion;
my ($message, $optimized);
for (@_) {
- $message = $_->{message} if exists $_->{message};
+ $message = $_->{message} if exists $_->{message};
$optimized = $_->{optimized} if exists $_->{optimized};
}
- my $pkg_defined_in = scalar(caller(1));
+ my $pkg_defined_in = scalar(caller(0));
+
($TYPES{$name}->[0] eq $pkg_defined_in)
- || confess "The type constraint '$name' has already been created "
- if defined $name && exists $TYPES{$name};
+ || confess ("The type constraint '$name' has already been created in "
+ . $TYPES{$name}->[0] . " and cannot be created again in "
+ . $pkg_defined_in)
+ if defined $name && exists $TYPES{$name};
+
$parent = find_type_constraint($parent) if defined $parent;
my $constraint = Moose::Meta::TypeConstraint->new(
name => $name || '__ANON__',
);
}
- sub export_type_contstraints_as_functions {
+ sub export_type_constraints_as_functions {
my $pkg = caller();
no strict 'refs';
foreach my $constraint (keys %TYPES) {
*{"${pkg}::${constraint}"} = find_type_constraint($constraint)->_compiled_type_constraint;
}
- }
+ }
+
+ *Moose::Util::TypeConstraints::export_type_contstraints_as_functions = \&export_type_constraints_as_functions;
+
+ sub list_all_type_constraints { keys %TYPES }
}
# type constructors
-sub type ($$) {
- my ($name, $check) = @_;
- _create_type_constraint($name, undef, $check);
+sub type ($$;$$) {
+ splice(@_, 1, 0, undef);
+ goto &_create_type_constraint;
}
sub subtype ($$;$$$) {
=> where { $_->can('does') }
=> optimize_as { blessed($_[0]) && $_[0]->can('does') };
+{
+ my @BUILTINS = list_all_type_constraints();
+ sub list_all_builtin_type_constraints { @BUILTINS }
+}
+
1;
__END__
=head1 DESCRIPTION
-This module provides Moose with the ability to create type contraints
-to be are used in both attribute definitions and for method argument
-validation.
+This module provides Moose with the ability to create custom type
+contraints to be used in attribute definition.
=head2 Important Caveat
yet to have been created yet, is to simply do this:
use DateTime;
- subtype 'DateTime' => as Object => where { $_->isa('DateTime') };
+ subtype 'DateTime' => as 'Object' => where { $_->isa('DateTime') };
=head2 Default Type Constraints
B<NOTE:> The C<Undef> type constraint does not work correctly
in every occasion, please use it sparringly.
+
+=head2 Use with Other Constraint Modules
+
+This module should play fairly nicely with other constraint
+modules with only some slight tweaking. The C<where> clause
+in types is expected to be a C<CODE> reference which checks
+it's first argument and returns a bool. Since most constraint
+modules work in a similar way, it should be simple to adapt
+them to work with Moose.
+
+For instance, this is how you could use it with
+L<Declare::Constraints::Simple> to declare a completely new type.
+
+ type 'HashOfArrayOfObjects'
+ => IsHashRef(
+ -keys => HasLength,
+ -values => IsArrayRef( IsObject ));
+
+For more examples see the F<t/204_example_w_DCS.t> test file.
+
+Here is an example of using L<Test::Deep> and it's non-test
+related C<eq_deeply> function.
+
+ type 'ArrayOfHashOfBarsAndRandomNumbers'
+ => where {
+ eq_deeply($_,
+ array_each(subhashof({
+ bar => isa('Bar'),
+ random_number => ignore()
+ })))
+ };
+
+For a complete example see the F<t/205_example_w_TestDeep.t>
+test file.
=head1 FUNCTIONS
Given a list of C<@type_constraint_names>, this will return a
B<Moose::Meta::TypeConstraint::Union> instance.
-=item B<export_type_contstraints_as_functions>
+=item B<export_type_constraints_as_functions>
This will export all the current type constraints as functions
into the caller's namespace. Right now, this is mostly used for
testing, but it might prove useful to others.
+=item B<export_type_contstraints_as_functions>
+
+Alias for the above function.
+
+=item B<list_all_type_constraints>
+
+This will return a list of type constraint names, you can then
+fetch them using C<find_type_constraint ($type_name)> if you
+want to.
+
+=item B<list_all_builtin_type_constraints>
+
+This will return a list of builtin type constraints, meaning,
+those which are defined in this module. See the section
+labeled L<Default Type Constraints> for a complete list.
+
=back
=head2 Type Constraint Constructors
They will then register the type constraints in a global store
where Moose can get to them if it needs to.
-See the L<SYNOPOSIS> for an example of how to use these.
+See the L<SYNOPSIS> for an example of how to use these.
=over 4
=item B<optimize_as>
+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.
+
+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
+are shallow) will not likely need to use this.
+
=back
=head2 Type Coercion Constructors
should be used carefully as it is very powerful and could easily
take off a limb if you are not careful.
-See the L<SYNOPOSIS> for an example of how to use these.
+See the L<SYNOPSIS> for an example of how to use these.
=over 4
projects / gitmo/Moose.git / blobdiff