1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
package Throwable;
# ABSTRACT: a role for classes that can be thrown
$Throwable::VERSION = '0.200012';
use Moo::Role;
use Sub::Quote ();
use Scalar::Util ();
use Carp ();
#pod =head1 SYNOPSIS
#pod
#pod package Redirect;
#pod use Moose;
#pod with 'Throwable';
#pod
#pod has url => (is => 'ro');
#pod
#pod ...then later...
#pod
#pod Redirect->throw({ url => $url });
#pod
#pod =head1 DESCRIPTION
#pod
#pod Throwable is a role for classes that are meant to be thrown as exceptions to
#pod standard program flow. It is very simple and does only two things: saves any
#pod previous value for C<$@> and calls C<die $self>.
#pod
#pod Throwable is implemented with L<Moo>, so you can stick to Moo or use L<Moose>
#pod as you prefer.
#pod
#pod =attr previous_exception
#pod
#pod This attribute is created automatically, and stores the value of C<$@> when the
#pod Throwable object is created. This is done on a I<best effort basis>. C<$@> is
#pod subject to lots of spooky action-at-a-distance. For now, there are clearly
#pod ways that the previous exception could be lost.
#pod
#pod =cut
our %_HORRIBLE_HACK;
has 'previous_exception' => (
is => 'ro',
default => Sub::Quote::quote_sub(q<
if (defined $Throwable::_HORRIBLE_HACK{ERROR}) {
$Throwable::_HORRIBLE_HACK{ERROR}
} elsif (defined $@ and (ref $@ or length $@)) {
$@;
} else {
undef;
}
>),
);
#pod =method throw
#pod
#pod Something::Throwable->throw({ attr => $value });
#pod
#pod This method will call new, passing all arguments along to new, and will then
#pod use the created object as the only argument to C<die>.
#pod
#pod If called on an object that does Throwable, the object will be rethrown.
#pod
#pod =cut
sub throw {
my ($inv) = shift;
if (Scalar::Util::blessed($inv)) {
Carp::confess "throw called on Throwable object with arguments" if @_;
die $inv;
}
local $_HORRIBLE_HACK{ERROR} = $@;
my $throwable = $inv->new(@_);
die $throwable;
}
no Moo::Role;
1;
__END__
=pod
=encoding UTF-8
=head1 NAME
Throwable - a role for classes that can be thrown
=head1 VERSION
version 0.200012
=head1 SYNOPSIS
package Redirect;
use Moose;
with 'Throwable';
has url => (is => 'ro');
...then later...
Redirect->throw({ url => $url });
=head1 DESCRIPTION
Throwable is a role for classes that are meant to be thrown as exceptions to
standard program flow. It is very simple and does only two things: saves any
previous value for C<$@> and calls C<die $self>.
Throwable is implemented with L<Moo>, so you can stick to Moo or use L<Moose>
as you prefer.
=head1 ATTRIBUTES
=head2 previous_exception
This attribute is created automatically, and stores the value of C<$@> when the
Throwable object is created. This is done on a I<best effort basis>. C<$@> is
subject to lots of spooky action-at-a-distance. For now, there are clearly
ways that the previous exception could be lost.
=head1 METHODS
=head2 throw
Something::Throwable->throw({ attr => $value });
This method will call new, passing all arguments along to new, and will then
use the created object as the only argument to C<die>.
If called on an object that does Throwable, the object will be rethrown.
=head1 AUTHORS
=over 4
=item *
Ricardo SIGNES <rjbs@cpan.org>
=item *
Florian Ragwitz <rafl@debian.org>
=back
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2014 by Ricardo SIGNES.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
|
