NAME

Brick::Composers - This is the description

SYNOPSIS

        use Brick::Constraints::Bucket;

DESCRIPTION

This module defines composing functions in the Brick::Constraints package. Each function takes a list of code refs and returns a single code ref that wraps all of them. The single code ref returns true or false (but defined), as with other constraints.

If a composer cannot create the single code ref (for instance, due to bad input) it returns undef of the empty list, indicating a failure in programming rather than a failure of the data to validate.

__and( LIST OF CODEREFS )

__compose_satisfy_all( LIST OF CODEREFS )

This is AND with NO short-circuiting.

        ( A && B && C )

This function creates a new constraint that returns true if all of its constraints return true. All constraints are checked so there is no short-circuiting. This allows you to get back all of the errors at once.

__or( LIST OF CODEREFS )

__compose_satisfy_any( LIST OF CODEREFS )

This is OR but with NO short-circuiting.

        ( A || B || C )

This function creates a new constraint that returns true if all of its constraints return true. All constraints are checked so there is no short-circuiting.

__none( LIST OF CODEREFS )

__compose_satisfy_none( LIST OF CODEREFS )

        ( NOT A && NOT B && NOT C )

        NOT ( A || B || C )

This function creates a new constraint that returns true if all of its constraints return false. All constraints are checked so there is no short-circuiting.

__compose_satisfy_N( SCALAR, LIST OF CODEREFS )

This function creates a new constraint that returns true if exactly N of its constraints return true. All constraints are checked so there is no short-circuiting.

__compose_satisfy_N_to_M( LIST OF CODEREFS )

This function creates a new constraint that returns true if between N and M (inclusive) of its constraints return true. All constraints are checked so there is no short-circuiting.

__not( CODEREF )

__compose_not( CODEREF )

This composers negates the sense of the code ref. If the code ref returns true, this composer makes it false, and vice versa.

__compose_until_pass

__compose_pass_or_skip

Go through the list of closures, trying each one until one suceeds. Once something succeeds, it returns the name of the subroutine that passed.

If a closure doesn't die, but doesn't return true, this doesn't fail but just moves on. Return true for the first one that passes, short-circuited the rest.

If none of the closures pass (and none of them die), return 0. This might be the odd case of a several selectors (see Brick::Selector), none of which pass.

If one of the subs dies, this composer still dies. This can also die for programming (not logic) errors.

__compose_until_fail

__compose_pass_or_stop

Keep going as long as the closures return true.

The closure that returns undef is a selector.

If a closure doesn't die and doesn't don't fail, just move on. Return true for the first one that passes, short-circuited the rest. If none of the closures pass, die with an error noting that nothing passed.

This can still die for programming (not logic) errors.

        $result         $@                      what            action
        ------------------------------------------------------------
                1               undef           passed          go on to next brick

                undef   undef           selector        stop, return undef, no die
                                                        failed

                undef   string          program         stop, die with string
                                                        error

                undef   ref                     validator       stop, die with ref
                                                        failed

TO DO

TBA

SEE ALSO

TBA

SOURCE AVAILABILITY

This source is in Github:

        https://github.com/briandfoy/brick

AUTHOR

brian d foy, <bdfoy@cpan.org>

COPYRIGHT

Copyright (c) 2007-2014, brian d foy, All Rights Reserved.

You may redistribute this under the same terms as Perl itself.