From Code to Community: Sponsoring The Perl and Raku Conference 2025 Learn more

JJNAPIORK / Valiant-0.002007 / lib / Valiant / Util / Exception.pm 

            

              
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

              
package Valiant::Util::Exception;
use Moo;
use Devel::StackTrace 2.03;
  
has 'trace' => (
  is => 'ro',
  builder => '_build_trace',
  lazy => 1,
);
  sub _build_trace {
    my $self = shift;
    my $skip = 0;
    while (my @c = caller(++$skip)) {
      last if ($c[3] =~ /^(.*)::new$/ || $c[3] =~ /^\S+ (.*)::new \(defined at /)
        && $self->isa($1);
    }
    $skip++;
    Devel::StackTrace->new(
      message => $self->message,
      indent  => 1,
      skip_frames => $skip,
      no_refs => 1,
    );
  }
has 'message' => (
  is => 'ro',
  builder => '_build_message',
  lazy => 1,
  required => 1,
);
  sub _build_message { "Error" }
use overload(
  q{""}    => 'as_string',
  bool     => sub () { 1 },
  fallback => 1,
);
   
sub BUILD { shift->trace }
  
sub as_string {
  my $self = shift;
  if ( $ENV{VALIANT_FULL_EXCEPTION} ) {
    return $self->trace->as_string;
  }
  my @frames;
  my $last_frame;
  my $in_moose = 1;
  for my $frame ( $self->trace->frames ) {
      if ( $in_moose && $frame->package =~ /^(?:Valiant)(?::|$)/ )
      {
          $last_frame = $frame;
          next;
      }
      elsif ($last_frame) {
          push @frames, $last_frame;
          undef $last_frame;
      }
      $in_moose = 0;
      push @frames, $frame;
  }
  # This would be a somewhat pathological case, but who knows
  return $self->trace->as_string unless @frames;
  my $message = ( shift @frames )->as_string( 1, {} ) . "\n";
  $message .= join q{}, map { $_->as_string( 0, {} ) . "\n" } @frames;
  return $message;
}
sub throw {
  my ($class, @args) = @_;
  die $class->new(@args);
}
sub rethrow { die shift }
1;
=head1 NAME
Valiant::Exception - Base exceptions class;
=head1 SYNOPSIS
    # Nothing for end users here
=head1 DESCRIPTION
I just copied this from L<Moose::Exception> since I trust the authors.  You shouldn't
really use this unless you add doing L<Valiant> extensions and need to create a new
exception type.
You won't use any of this unless you are doing L<Valiant> extensions or validators.
=head1 ATTRIBUTES
=head2 trace
Full stack trace if you need it
=head2 message
The actual exception message
=head1 METHODS
This class does the following methods
=head2 as_string
Exception stringy-fied.  Used as an overloading target.
=head1 SEE ALSO
  
L<Valiant>
=head1 AUTHOR
  
See L<Valiant>
=head1 COPYRIGHT & LICENSE
  
See L<Valiant>
=cut