Mojo/Path.pm

filter: Statementstmt 100% 84 / 84 Branchbran 100% 42 / 42 Conditioncond 94.1% 16 / 17 MC/DCmcdc 77.7% 7 / 9 Subroutinesub 100% 20 / 20 Podpod 100% 13 / 13 totaltotal 98.3% 182 / 185 CC 29 SCAR 14.7
CC
29
Cov
99%
canonicalize
9.0
_parse
6.0
to_string
6.0
CRAP 4.3
« Mojo/Loader.pm ↑ Summary Mojo/Headers.pm »
1 package Mojo::Path;
2 32 ▶use Mojo::Base -base;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 32 ▶use overload '@{}' => sub { shift->parts }, bool => sub {1}, '""' => sub { shift->to_string }, fallback => 1;
Subroutine BEGIN: called CC=1 SCAR=0.0
Subroutine __ANON__: called CC=1 SCAR=0.0
Subroutine __ANON__: called CC=1 SCAR=0.0
Subroutine __ANON__: called CC=1 SCAR=0.0
4  
5 32 ▶use Mojo::Util qw(decode encode url_escape url_unescape);
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 32 has charset => 'UTF-8';
8  
9 200 ▶sub canonicalize {
Subroutine canonicalize: called CC=9 SCAR=22.0
Pod documented
10 200 my $self = shift;
11  
12 200 my $parts = $self->parts;
13 200 ▶ for (my $i = 0; $i <= $#$parts;) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i <= $parts->$#*) 416 200 616
14 416 ▶ if (!length $parts->[$i] || $parts->[$i] eq '.' || $parts->[$i] eq '...') { splice @$parts, $i, 1 }
Branch: 2 branches
BranchTrueFalseTotal
if (not length $parts->[$i] or $parts->[$i] eq '.' or $parts->[$i] eq '...') { } 13 403 416
elsif ($i < 1 or $parts->[$i] ne '..' or $$parts[$i - 1] eq '..') { } 384 19 403
Condition100%6/6
not length $parts->[$i] or $parts->[$i] eq "." or $parts->[$i] eq "..."
l!l&&r!l&&!r
85403
not length $parts->[$i] or $parts->[$i] eq "."
l!l&&r!l&&!r
17408
MC/DC100%3/3
not length $parts->[$i] or $parts->[$i] eq "." or $parts->[$i] eq "..."
not length $parts->[$i] $parts->[$i] eq "." $parts->[$i] eq "..."
Truth table100%4/4
not(A) or B or C
A= not length $parts->[$i]B= $parts->[$i] eq "."C= $parts->[$i] eq "..."
ABCresult
1XX1
01X1
0011
0000
15 384 ▶ elsif ($i < 1 || $parts->[$i] ne '..' || $parts->[$i - 1] eq '..') { $i++ }
Condition100%6/6
$i < 1 or $parts->[$i] ne ".." or $$parts[$i - 1] eq ".."
l!l&&r!l&&!r
3632119
$i < 1 or $parts->[$i] ne ".."
l!l&&r!l&&!r
19916440
MC/DC100%3/3
$i < 1 or $parts->[$i] ne ".." or $$parts[$i - 1] eq ".."
$i < 1 $parts->[$i] ne ".." $$parts[$i - 1] eq ".."
Truth table100%4/4
A or B or C
A= $i < 1B= $parts->[$i] ne ".."C= $$parts[$i - 1] eq ".."
ABCresult
1XX1
01X1
0011
0000
16 19 else { splice @$parts, --$i, 2 }
17 }
18  
19 200 ▶ return @$parts ? $self : $self->trailing_slash(undef);
Branch: 1 branch
BranchTrueFalseTotal
@$parts ? : 189 11 200
20 }
21  
22 646 ▶sub clone {
Subroutine clone: called CC=4 SCAR=13.9
Pod documented
23 646 my $self = shift;
24  
25 646 my $clone = $self->new;
26 646 ▶ if (exists $self->{charset}) { $clone->{charset} = $self->{charset} }
Branch: 1 branch
BranchTrueFalseTotal
if (exists $self->{"charset"}) 193 453 646
27 646 ▶ if (my $parts = $self->{parts}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $parts = $self->{'parts'}) { } 72 574 646
28 72 $clone->{$_} = $self->{$_} for qw(leading_slash trailing_slash);
29 72 $clone->{parts} = [@$parts];
30 }
31 574 else { $clone->{path} = $self->{path} }
32  
33 646 return $clone;
34 }
35  
36 25 ▶sub contains { $_[1] eq '/' || $_[0]->to_route =~ m!^\Q$_[1]\E(?:/|$)! }
Subroutine contains: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[1] eq "/" or $_[0]->to_route =~ m[^\Q$_[1]\E(?:/|$)]u 4 21 25
37  
38 678 ▶sub leading_slash { shift->_parse(leading_slash => @_) }
Subroutine leading_slash: called CC=1 SCAR=0.0
Pod documented
39  
40 1139 ▶sub merge {
Subroutine merge: called CC=3 SCAR=11.0
Pod documented
41 1139 my ($self, $path) = @_;
42  
43 # Replace
44 1139 ▶ return $self->parse($path) if $path =~ m!^/!;
Branch: 1 branch
BranchTrueFalseTotal
if $path =~ m[^/]u 932 207 1139
45  
46 # Merge
47 207 ▶ pop @{$self->parts} unless $self->trailing_slash;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->trailing_slash 190 17 207
48 207 $path = $self->new($path);
49 207 push @{$self->parts}, @{$path->parts};
50 207 return $self->trailing_slash($path->trailing_slash);
51 }
52  
53 2225 ▶sub new { @_ > 1 ? shift->SUPER::new->parse(@_) : shift->SUPER::new }
Subroutine new: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
@_ > 1 ? : 251 1974 2225
54  
55 1256 ▶sub parse {
Subroutine parse: called CC=1 SCAR=0.0
Pod documented
56 1256 my $self = shift;
57 1256 $self->{path} = shift;
58 1256 delete @$self{qw(leading_slash parts trailing_slash)};
59 1256 return $self;
60 }
61  
62 1836 ▶sub parts { shift->_parse(parts => @_) }
Subroutine parts: called CC=1 SCAR=0.0
Pod documented
63  
64 92 ▶sub to_abs_string {
Subroutine to_abs_string: called CC=2 SCAR=6.9
Pod documented
65 92 my $path = shift->to_string;
66 92 ▶ return $path =~ m!^/! ? $path : "/$path";
Branch: 1 branch
BranchTrueFalseTotal
$path =~ m[^/]u ? : 80 12 92
67 }
68  
69 12 ▶sub to_dir {
Subroutine to_dir: called CC=2 SCAR=6.9
Pod documented
70 12 my $clone = shift->clone;
71 12 ▶ pop @{$clone->parts} unless $clone->trailing_slash;
Branch: 1 branch
BranchTrueFalseTotal
unless $clone->trailing_slash 10 2 12
72 12 return $clone->trailing_slash(!!@{$clone->parts});
73 }
74  
75 194 ▶sub to_route {
Subroutine to_route: called CC=2 SCAR=6.9
Pod documented
76 194 my $clone = shift->clone;
77 194 ▶ return '/' . join '/', @{$clone->parts}, $clone->trailing_slash ? '' : ();
Branch: 1 branch
BranchTrueFalseTotal
$clone->trailing_slash ? : 13 181 194
78 }
79  
80 1561 ▶sub to_string {
Subroutine to_string: called CC=6 SCAR=17.9
Pod documented
81 1561 my $self = shift;
82  
83 # Path
84 1561 my $charset = $self->charset;
85 1561 ▶ if (defined(my $path = $self->{path})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $path = $self->{"path"})) 991 570 1561
86 991 ▶ $path = encode $charset, $path if $charset;
Branch: 1 branch
BranchTrueFalseTotal
if $charset 990 1 991
87 991 return url_escape $path, '^A-Za-z0-9\-._~!$&\'()*+,;=%:@/';
88 }
89  
90 # Build path
91 570 my @parts = @{$self->parts};
92 570 ▶ @parts = map { encode $charset, $_ } @parts if $charset;
Branch: 1 branch
BranchTrueFalseTotal
if $charset 567 3 570
93 570 my $path = join '/', map { url_escape $_, '^A-Za-z0-9\-._~!$&\'()*+,;=:@' } @parts;
94 570 ▶ $path = "/$path" if $self->leading_slash;
Branch: 1 branch
BranchTrueFalseTotal
if $self->leading_slash 154 416 570
95 570 ▶ $path = "$path/" if $self->trailing_slash;
Branch: 1 branch
BranchTrueFalseTotal
if $self->trailing_slash 43 527 570
96 570 return $path;
97 }
98  
99 1467 ▶sub trailing_slash { shift->_parse(trailing_slash => @_) }
Subroutine trailing_slash: called CC=1 SCAR=0.0
Pod documented
100  
101 3981 ▶sub _parse {
Subroutine _parse: called CC=6 SCAR=17.9
102 3981 my ($self, $name) = (shift, shift);
103  
104 3981 ▶ unless ($self->{parts}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->{"parts"}) 1059 2922 3981
105 1059 ▶ my $path = url_unescape delete($self->{path}) // '';
Condition100%2/2
delete $self->{"path"} // ""
l!l
708351
MC/DC100%1/1
delete $self->{"path"} // ""
delete $self->{"path"}
Truth table100%2/2
A
A= delete $self->{"path"}
Aresult
11
00
106 1059 my $charset = $self->charset;
107 1059 ▶ $path = decode($charset, $path) // $path if $charset;
Branch: 1 branch
BranchTrueFalseTotal
if $charset 1057 2 1059
Condition66%2/3
decode($charset, $path) // $path
l!l&&r!l&&!r
1031260
MC/DC0%0/2
decode($charset, $path) // $path
decode($charset, $path) $path
Truth table66%2/3
A // B
A= decode($charset, $path)B= $path
ABresult
1X1
011
000
108 1059 $self->{leading_slash} = $path =~ s!^/!!;
109 1059 $self->{trailing_slash} = $path =~ s!/$!!;
110 1059 $self->{parts} = [split /\//, $path, -1];
111 }
112  
113 3981 ▶ return $self->{$name} unless @_;
Branch: 1 branch
BranchTrueFalseTotal
unless @_ 3724 257 3981
114 257 $self->{$name} = shift;
115 257 return $self;
116 }
117  
118 32 1;
119  
120 =encoding utf8
121  
122 =head1 NAME
123  
124 Mojo::Path - Path
125  
126 =head1 SYNOPSIS
127  
128 use Mojo::Path;
129  
130 # Parse
131 my $path = Mojo::Path->new('/foo%2Fbar%3B/baz.html');
132 say $path->[0];
133  
134 # Build
135 my $path = Mojo::Path->new('/i/♥');
136 push @$path, 'mojolicious';
137 say "$path";
138  
139 =head1 DESCRIPTION
140  
141 L<Mojo::Path> is a container for paths used by L<Mojo::URL>, based on L<RFC 3986|https://tools.ietf.org/html/rfc3986>.
142  
143 =head1 ATTRIBUTES
144  
145 L<Mojo::Path> implements the following attributes.
146  
147 =head2 charset
148  
149 my $charset = $path->charset;
150 $path = $path->charset('UTF-8');
151  
152 Charset used for encoding and decoding, defaults to C<UTF-8>.
153  
154 # Disable encoding and decoding
155 $path->charset(undef);
156  
157 =head1 METHODS
158  
159 L<Mojo::Path> inherits all methods from L<Mojo::Base> and implements the following new ones.
160  
161 =head2 canonicalize
162  
163 $path = $path->canonicalize;
164  
165 Canonicalize path by resolving C<.> and C<..>, in addition C<...> will be treated as C<.> to protect from path
166 traversal attacks.
167  
168 # "/foo/baz"
169 Mojo::Path->new('/foo/./bar/../baz')->canonicalize;
170  
171 # "/../baz"
172 Mojo::Path->new('/foo/../bar/../../baz')->canonicalize;
173  
174 # "/foo/bar"
175 Mojo::Path->new('/foo/.../bar')->canonicalize;
176  
177 =head2 clone
178  
179 my $clone = $path->clone;
180  
181 Return a new L<Mojo::Path> object cloned from this path.
182  
183 =head2 contains
184  
185 my $bool = $path->contains('/i/♥/mojolicious');
186  
187 Check if path contains given prefix.
188  
189 # True
190 Mojo::Path->new('/foo/bar')->contains('/');
191 Mojo::Path->new('/foo/bar')->contains('/foo');
192 Mojo::Path->new('/foo/bar')->contains('/foo/bar');
193  
194 # False
195 Mojo::Path->new('/foo/bar')->contains('/f');
196 Mojo::Path->new('/foo/bar')->contains('/bar');
197 Mojo::Path->new('/foo/bar')->contains('/whatever');
198  
199 =head2 leading_slash
200  
201 my $bool = $path->leading_slash;
202 $path = $path->leading_slash($bool);
203  
204 Path has a leading slash. Note that this method will normalize the path and that C<%2F> will be treated as C</> for
205 security reasons.
206  
207 # "/foo/bar"
208 Mojo::Path->new('foo/bar')->leading_slash(1);
209  
210 # "foo/bar"
211 Mojo::Path->new('/foo/bar')->leading_slash(0);
212  
213 =head2 merge
214  
215 $path = $path->merge('/foo/bar');
216 $path = $path->merge('foo/bar');
217 $path = $path->merge(Mojo::Path->new);
218  
219 Merge paths. Note that this method will normalize both paths if necessary and that C<%2F> will be treated as C</> for
220 security reasons.
221  
222 # "/baz/yada"
223 Mojo::Path->new('/foo/bar')->merge('/baz/yada');
224  
225 # "/foo/baz/yada"
226 Mojo::Path->new('/foo/bar')->merge('baz/yada');
227  
228 # "/foo/bar/baz/yada"
229 Mojo::Path->new('/foo/bar/')->merge('baz/yada');
230  
231 =head2 new
232  
233 my $path = Mojo::Path->new;
234 my $path = Mojo::Path->new('/foo%2Fbar%3B/baz.html');
235  
236 Construct a new L<Mojo::Path> object and L</"parse"> path if necessary.
237  
238 =head2 parse
239  
240 $path = $path->parse('/foo%2Fbar%3B/baz.html');
241  
242 Parse path.
243  
244 =head2 to_abs_string
245  
246 my $str = $path->to_abs_string;
247  
248 Turn path into an absolute string.
249  
250 # "/i/%E2%99%A5/mojolicious"
251 Mojo::Path->new('/i/%E2%99%A5/mojolicious')->to_abs_string;
252 Mojo::Path->new('i/%E2%99%A5/mojolicious')->to_abs_string;
253  
254 =head2 parts
255  
256 my $parts = $path->parts;
257 $path = $path->parts([qw(foo bar baz)]);
258  
259 The path parts. Note that this method will normalize the path and that C<%2F> will be treated as C</> for security
260 reasons.
261  
262 # Part with slash
263 push @{$path->parts}, 'foo/bar';
264  
265 =head2 to_dir
266  
267 my $dir = $route->to_dir;
268  
269 Clone path and remove everything after the right-most slash.
270  
271 # "/i/%E2%99%A5/"
272 Mojo::Path->new('/i/%E2%99%A5/mojolicious')->to_dir->to_abs_string;
273  
274 # "i/%E2%99%A5/"
275 Mojo::Path->new('i/%E2%99%A5/mojolicious')->to_dir->to_abs_string;
276  
277 =head2 to_route
278  
279 my $route = $path->to_route;
280  
281 Turn path into a route.
282  
283 # "/i/♥/mojolicious"
284 Mojo::Path->new('/i/%E2%99%A5/mojolicious')->to_route;
285 Mojo::Path->new('i/%E2%99%A5/mojolicious')->to_route;
286  
287 =head2 to_string
288  
289 my $str = $path->to_string;
290  
291 Turn path into a string.
292  
293 # "/i/%E2%99%A5/mojolicious"
294 Mojo::Path->new('/i/%E2%99%A5/mojolicious')->to_string;
295  
296 # "i/%E2%99%A5/mojolicious"
297 Mojo::Path->new('i/%E2%99%A5/mojolicious')->to_string;
298  
299 =head2 trailing_slash
300  
301 my $bool = $path->trailing_slash;
302 $path = $path->trailing_slash($bool);
303  
304 Path has a trailing slash. Note that this method will normalize the path and that C<%2F> will be treated as C</> for
305 security reasons.
306  
307 # "/foo/bar/"
308 Mojo::Path->new('/foo/bar')->trailing_slash(1);
309  
310 # "/foo/bar"
311 Mojo::Path->new('/foo/bar/')->trailing_slash(0);
312  
313 =head1 OPERATORS
314  
315 L<Mojo::Path> overloads the following operators.
316  
317 =head2 array
318  
319 my @parts = @$path;
320  
321 Alias for L</"parts">. Note that this will normalize the path and that C<%2F> will be treated as C</> for security
322 reasons.
323  
324 say $path->[0];
325 say for @$path;
326  
327 =head2 bool
328  
329 my $bool = !!$path;
330  
331 Always true.
332  
333 =head2 stringify
334  
335 my $str = "$path";
336  
337 Alias for L</"to_string">.
338  
339 =head1 SEE ALSO
340  
341 L<Mojolicious>, L<Mojolicious::Guides>, L<https://mojolicious.org>.
342  
343 =cut
« Mojo/Loader.pm ↑ Summary Mojo/Headers.pm »