Simple.pm

filter: Statementstmt 76.9% 502 / 652 Branchbran 57.7% 156 / 270 Conditioncond 43.3% 121 / 279 MC/DCmcdc 18.0% 30 / 166 Subroutinesub 78.8% 56 / 71 Podpod 65.0% 13 / 20 totaltotal 60.2% 878 / 1458 CC 268 SCAR 44.9
CC
268
Cov
65%
init_logger
416.3
new
181.4
use_log4perl
135.5
CRAP 89.4
↑ Summary Simple/Scaffold.pm »
1 package CLI::Simple;
2 # a Simple, Fast & Easy way to create scripts
3  
4 11 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 11 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 11 ▶use CLI::Simple::Constants qw(:booleans :chars :log-levels @VALID_OPTIONS @DEFAULT_HELP_SECTIONS :color-config);
Subroutine BEGIN: called CC=1 SCAR=0.0
8 11 ▶use CLI::Simple::Utils qw(normalize_options slurp dmp choose);
Subroutine BEGIN: called CC=1 SCAR=0.0
9 11 ▶use CLI::Simple::DumpSpec qw(_cmd_dump_spec);
Subroutine BEGIN: called CC=1 SCAR=0.0
10 11 ▶use CLI::Simple::Migrate qw(_cmd_migrate);
Subroutine BEGIN: called CC=1 SCAR=0.0
11 11 ▶use CLI::Simple::Scaffold qw(_cmd_scaffold);
Subroutine BEGIN: called CC=1 SCAR=0.0
12 11 ▶use CLI::Simple::Helpers qw(_is_class_name);
Subroutine BEGIN: called CC=1 SCAR=0.0
13 11 ▶use CLI::Simple::Shell;
Subroutine BEGIN: called CC=1 SCAR=0.0
14  
15 11 ▶use Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 11 ▶use Data::Dumper;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 11 ▶use English qw(-no_match_vars);
Subroutine BEGIN: called CC=1 SCAR=0.0
18 11 ▶use FindBin qw($RealBin $RealScript);
Subroutine BEGIN: called CC=1 SCAR=0.0
19 11 ▶use File::Basename qw(basename);
Subroutine BEGIN: called CC=1 SCAR=0.0
20 11 ▶use File::Which qw(which);
Subroutine BEGIN: called CC=1 SCAR=0.0
21 11 ▶use Getopt::Long qw(:config no_ignore_case);
Subroutine BEGIN: called CC=1 SCAR=0.0
22 11 ▶use IO::Interactive;
Subroutine BEGIN: called CC=1 SCAR=0.0
23 11 ▶use List::Util qw(none pairs any);
Subroutine BEGIN: called CC=1 SCAR=0.0
24 11 ▶use Scalar::Util qw(reftype);
Subroutine BEGIN: called CC=1 SCAR=0.0
25  
26 11 our $VERSION = '2.4.0';
27  
28 11 our $GETOPT_EXIT_ON_ERROR = $TRUE;
29 11 our $GETOPT_STATUS;
30 11 our $GETOPT_ERROR_MESSAGE;
31  
32 11 my %GENERATED_ACCESSOR; # tracks accessors mk_accessors itself created, per class
33  
34 11 __PACKAGE__->follow_best_practice;
35 11 __PACKAGE__->mk_accessors(
36 qw(
37 _validate_command
38 _command
39 _command_args
40 _commands
41 _program
42 _abbreviations
43 _options
44 )
45 );
46  
47 11 our $USE_LOGGER = $FALSE;
48 11 our $AUTO_DEFAULT = $FALSE;
49 11 our $AUTO_HELP = $FALSE;
50 11 our $PAGER = $TRUE;
51  
52 11 our %INTERNAL_COMMANDS = (
53 '-generate-completion' => \&_cmd_generate_completion,
54 '-migrate' => \&_cmd_migrate,
55 '-dump-spec' => \&_cmd_dump_spec,
56 '-scaffold' => \&_cmd_scaffold,
57 );
58  
59 11 our @EXPORT_OK = qw($AUTO_HELP $AUTO_DEFAULT $PAGER $USE_LOGGER);
60  
61 11 ▶use parent qw(Exporter Class::Accessor::Fast);
Subroutine BEGIN: called CC=1 SCAR=0.0
62  
63 # CLI::Simple 2.0.0 additions
64  
65 11 our $MANIFEST; # package-level, per-consumer class
66  
67 11 ▶caller or exit __PACKAGE__->main();
Branch: 1 branch
BranchTrueFalseTotal
caller or exit __PACKAGE__->main 11 0 11
68  
69 ########################################################################
70 16 ▶sub import {
Subroutine import: called CC=9 SCAR=29.5
71 ########################################################################
72 16 my ( $class, @args ) = @_;
73  
74 16 my $caller = caller;
75  
76 16 my @yaml_files = grep {/[.]ya?ml\z/xsm} @args;
77  
78 16 ▶ @yaml_files = map { /[*?\[]/xsm ? glob($_) : $_ } @yaml_files;
Branch: 1 branch
BranchTrueFalseTotal
/[*?\[]/msx ? : 2 3 5
79  
80 16 ▶ if ( any { $_ eq ':roles' } @args ) {
Subroutine __ANON__: called CC=1 SCAR=0.2
Branch: 1 branch
BranchTrueFalseTotal
if (&any(sub { $_ eq ":roles"; } , @args)) 0 16 16
81 0 ▶ if ( !${^COMPILING} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (${^COMPILING}) 0 0 0
82 0 ( my $dist = $caller ) =~ s/::/-/gxsm;
83 0 my $yaml_file = lc($dist) . '.yml';
84  
85 0 require File::ShareDir;
86 0 my $path = eval { File::ShareDir::dist_file( $dist, $yaml_file ) };
87  
88 0 ▶ if ( $path && !-e $path ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($path and not -e $path) 0 0 0
Condition0%0/3
$path and not -e $path
!ll&&!rl&&r
000
MC/DC0%0/2
$path and not -e $path
$path not -e $path
Truth table0%0/3
A and not(B)
A= $pathB= not -e $path
ABresult
0X0
100
111
89 0 undef $path;
90 }
91  
92 0 ▶ unshift @yaml_files, $path if $path;
Branch: 1 branch
BranchTrueFalseTotal
if $path 0 0 0
93 }
94 }
95  
96 16 ▶ if (@yaml_files) {
Branch: 1 branch
BranchTrueFalseTotal
if (@yaml_files) 3 13 16
97 3 $class->_load_manifest( $caller, @yaml_files );
98 }
99  
100 # preserve existing Exporter behaviour
101 15 ▶ $class->export_to_level( 1, $class, grep { $_ ne ':roles' && !/[.]ya?ml\z/xsm } @args );
Condition66%2/3
$_ ne ':roles' && !/[.]ya?ml\z/msx
!ll&&!rl&&r
044
MC/DC50%1/2
$_ ne ':roles' && !/[.]ya?ml\z/msx
$_ ne ':roles' !/[.]ya?ml\z/msx
Truth table66%2/3
A && not(B)
A= $_ ne ':roles'B= !/[.]ya?ml\z/msx
ABresult
0X0
100
111
102  
103 15 return;
104 }
105  
106 ########################################################################
107 18 ▶sub _validate_manifest {
Subroutine _validate_manifest: called CC=13 SCAR=27.4
108 ########################################################################
109 18 my ( $class, $manifest, $filename ) = @_;
110  
111 18 my %section_types = (
112 commands => 'HASH',
113 roles => 'HASH',
114 options => 'ARRAY',
115 default_options => 'HASH',
116 extra_options => 'ARRAY',
117 alias => 'HASH',
118 abbreviations => 'SCALAR',
119 version => 'SCALAR',
120 distribution => 'SCALAR',
121 );
122  
123 18 ▶ die sprintf "ERROR: manifest %s must contain a YAML mapping\n", $filename
Branch: 1 branch
BranchTrueFalseTotal
if not ref $manifest or builtin::reftype($manifest) ne "HASH" 0 18 18
Condition33%1/3
not ref $manifest or builtin::reftype($manifest) ne "HASH"
l!l&&r!l&&!r
0018
MC/DC0%0/2
not ref $manifest or builtin::reftype($manifest) ne "HASH"
not ref $manifest builtin::reftype($manifest) ne "HASH"
Truth table33%1/3
not(A) or B
A= not ref $manifestB= builtin::reftype($manifest) ne "HASH"
ABresult
1X1
011
000
124 if !ref $manifest || reftype($manifest) ne 'HASH';
125  
126 18 foreach my $key ( keys %{$manifest} ) {
127 die sprintf "ERROR: unknown manifest key '%s' in %s\n", $key, $filename
128 28 ▶ if !exists $section_types{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $section_types{$key} 0 28 28
129  
130 28 my $expected = $section_types{$key};
131 28 my $value = $manifest->{$key};
132  
133 28 ▶ if ( $expected eq 'SCALAR' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expected eq "SCALAR") 2 26 28
134 2 ▶ die sprintf "ERROR: manifest key '%s' in %s must be a scalar\n", $key, $filename
Branch: 1 branch
BranchTrueFalseTotal
if ref $value 0 2 2
135 if ref $value;
136  
137 2 next;
138 }
139  
140 26 ▶ die sprintf "ERROR: manifest key '%s' in %s must be a %s\n", $key, $filename, $expected
Branch: 1 branch
BranchTrueFalseTotal
if not ref $value or builtin::reftype($value) ne $expected 0 26 26
Condition33%1/3
not ref $value or builtin::reftype($value) ne $expected
l!l&&r!l&&!r
0026
MC/DC0%0/2
not ref $value or builtin::reftype($value) ne $expected
not ref $value builtin::reftype($value) ne $expected
Truth table33%1/3
not(A) or B
A= not ref $valueB= builtin::reftype($value) ne $expected
ABresult
1X1
011
000
141 if !ref $value || reftype($value) ne $expected;
142 }
143  
144 18 foreach my $section (qw(options extra_options)) {
145 36 ▶ foreach my $value ( @{ $manifest->{$section} // [] } ) {
Condition100%2/2
$manifest->{$section} // []
l!l
333
MC/DC100%1/1
$manifest->{$section} // []
$manifest->{$section}
Truth table100%2/2
A
A= $manifest->{$section}
Aresult
11
00
146 6 ▶ die sprintf "ERROR: manifest key '%s' in %s must contain scalar values\n", $section, $filename
Branch: 1 branch
BranchTrueFalseTotal
if ref $value 0 6 6
147 if ref $value;
148 }
149 }
150  
151 18 return;
152 }
153  
154 ########################################################################
155 17 ▶sub _load_manifest {
Subroutine _load_manifest: called CC=25 SCAR=32.9
156 ########################################################################
157 17 my ( $class, $target, @yaml_files ) = @_;
158  
159 17 require YAML::Tiny;
160  
161 17 my $manifest = {};
162 17 my %option_owner;
163 my %default_owner;
164  
165 17 foreach my $yaml_file (@yaml_files) {
166 19 ▶ my $additional = YAML::Tiny::LoadFile($yaml_file)
Branch: 1 branch
BranchTrueFalseTotal
my $additional = YAML::Tiny::LoadFile($yaml_file) or die "ERROR: could not load manifest: $yaml_file\n" 18 0 18
167 or die "ERROR: could not load manifest: $yaml_file\n";
168  
169 18 $class->_validate_manifest( $additional, $yaml_file );
170  
171 18 foreach my $section (qw(commands roles)) {
172 36 ▶ my $entries = $additional->{$section} // {};
Condition100%2/2
$additional->{$section} // {}
l!l
2016
MC/DC100%1/1
$additional->{$section} // {}
$additional->{$section}
Truth table100%2/2
A
A= $additional->{$section}
Aresult
11
00
173  
174 36 foreach my $cmd ( keys %{$entries} ) {
175 die sprintf "ERROR: duplicate command '%s' in %s\n", $cmd, $yaml_file
176 if $yaml_file ne $yaml_files[0]
177 && ( exists $manifest->{commands}{$cmd}
178 25 ▶ || exists $manifest->{roles}{$cmd} );
Branch: 1 branch
BranchTrueFalseTotal
if $yaml_file ne $yaml_files[0] and exists $manifest->{"commands"}{$cmd} || exists $manifest->{"roles"}{$cmd} 0 25 25
Condition50%3/6
$yaml_file ne $yaml_files[0] and exists $manifest->{"commands"}{$cmd} || exists $manifest->{"roles"}{$cmd}
!ll&&!rl&&r
2320
exists $manifest->{"commands"}{$cmd} or exists $manifest->{"roles"}{$cmd}
l!l&&r!l&&!r
002
MC/DC0%0/3
$yaml_file ne $yaml_files[0] and exists $manifest->{"commands"}{$cmd} || exists $manifest->{"roles"}{$cmd}
$yaml_file ne $yaml_files[0] exists $manifest->{"commands"}{$cmd} exists $manifest->{"roles"}{$cmd}
Truth table50%2/4
A and B or C
A= $yaml_file ne $yaml_files[0]B= exists $manifest->{"commands"}{$cmd}C= exists $manifest->{"roles"}{$cmd}
ABCresult
0XX0
1000
11X1
1011
179  
180 25 $manifest->{$section}{$cmd} = $entries->{$cmd};
181 }
182 }
183  
184 # Options belong to a single global namespace, including aliases.
185 18 ▶ foreach my $spec ( @{ $additional->{options} // [] } ) {
Condition100%2/2
$additional->{"options"} // []
l!l
216
MC/DC100%1/1
$additional->{"options"} // []
$additional->{"options"}
Truth table100%2/2
A
A= $additional->{"options"}
Aresult
11
00
186 5 my ($names) = $spec =~ /\A([\w|-]+)/xsm;
187 5 ▶ die sprintf "ERROR: invalid option specification '%s' in %s\n", $spec, $yaml_file
Branch: 1 branch
BranchTrueFalseTotal
unless $names 0 5 5
188 if !$names;
189  
190 5 foreach my $name ( split /[|]/xsm, $names ) {
191 7 ( my $accessor = $name ) =~ s/-/_/gxsm;
192 die sprintf "ERROR: duplicate option '%s' in %s (already declared in %s)\n", $name, $yaml_file, $option_owner{$accessor}
193 7 ▶ if exists $option_owner{$accessor};
Branch: 1 branch
BranchTrueFalseTotal
if exists $option_owner{$accessor} 0 7 7
194  
195 7 $option_owner{$accessor} = $yaml_file;
196 }
197  
198 5 push @{ $manifest->{options} }, $spec;
199 }
200  
201 18 ▶ foreach my $name ( keys %{ $additional->{default_options} // {} } ) {
Condition100%2/2
$additional->{"default_options"} // {}
l!l
117
MC/DC100%1/1
$additional->{"default_options"} // {}
$additional->{"default_options"}
Truth table100%2/2
A
A= $additional->{"default_options"}
Aresult
11
00
202 1 ( my $accessor = $name ) =~ s/-/_/gxsm;
203 die sprintf "ERROR: duplicate default option '%s' in %s (already declared in %s)\n",
204 $name, $yaml_file, $default_owner{$accessor}
205 1 ▶ if exists $default_owner{$accessor};
Branch: 1 branch
BranchTrueFalseTotal
if exists $default_owner{$accessor} 0 1 1
206  
207 1 $default_owner{$accessor} = $yaml_file;
208 1 $manifest->{default_options}{$name} = $additional->{default_options}{$name};
209 }
210  
211 # Accessor declarations may repeat; they do not introduce new switches.
212 18 my %extra_seen;
213  
214 18 ▶ foreach my $name ( @{ $manifest->{extra_options} // [] } ) {
Condition50%1/2
$manifest->{"extra_options"} // []
l!l
018
MC/DC0%0/1
$manifest->{"extra_options"} // []
$manifest->{"extra_options"}
Truth table50%1/2
A
A= $manifest->{"extra_options"}
Aresult
11
00
215 0 ( my $accessor = $name ) =~ s/-/_/gxsm;
216 0 $extra_seen{$accessor} = 1;
217 }
218  
219 18 ▶ foreach my $name ( @{ $additional->{extra_options} // [] } ) {
Condition100%2/2
$additional->{"extra_options"} // []
l!l
117
MC/DC100%1/1
$additional->{"extra_options"} // []
$additional->{"extra_options"}
Truth table100%2/2
A
A= $additional->{"extra_options"}
Aresult
11
00
220 1 ( my $accessor = $name ) =~ s/-/_/gxsm;
221 1 ▶ next if $extra_seen{$accessor}++;
Branch: 1 branch
BranchTrueFalseTotal
if $extra_seen{$accessor}++ 0 1 1
222 1 push @{ $manifest->{extra_options} }, $name;
223 }
224  
225 # Only the primary manifest controls application-wide metadata.
226 18 ▶ if ( $yaml_file eq $yaml_files[0] ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($yaml_file eq $yaml_files[0]) 16 2 18
227 16 foreach my $key ( keys %{$additional} ) {
228 26 ▶ next if any { $key eq $_ } qw(commands roles options default_options extra_options);
Subroutine __ANON__: called CC=1 SCAR=0.0
Branch: 1 branch
BranchTrueFalseTotal
if &any(sub { $key eq $_; } , "commands", "roles", "options", "default_options", "extra_options") 22 4 26
229 4 $manifest->{$key} = $additional->{$key};
230 }
231 }
232 }
233  
234 16 $class->_normalize_manifest($manifest);
235  
236 11 ▶ no strict 'refs'; ## no critic
Subroutine BEGIN: called CC=1 SCAR=0.0
237 11 ${"${target}::_CLI_MANIFEST"} = $manifest;
238  
239 11 return;
240 }
241  
242 ########################################################################
243 16 ▶sub _normalize_manifest {
Subroutine _normalize_manifest: called CC=8 SCAR=20.8
244 ########################################################################
245 16 my ( $class, $manifest ) = @_;
246  
247 16 ▶ my $commands = $manifest->{commands} // {};
Condition100%2/2
$manifest->{"commands"} // {}
l!l
79
MC/DC100%1/1
$manifest->{"commands"} // {}
$manifest->{"commands"}
Truth table100%2/2
A
A= $manifest->{"commands"}
Aresult
11
00
248 16 ▶ my $roles = $manifest->{roles} // {};
Condition100%2/2
$manifest->{"roles"} // {}
l!l
133
MC/DC100%1/1
$manifest->{"roles"} // {}
$manifest->{"roles"}
Truth table100%2/2
A
A= $manifest->{"roles"}
Aresult
11
00
249  
250 16 foreach my $cmd ( keys %{$roles} ) {
251 die sprintf "ERROR: command '%s' is defined in both commands and roles\n", $cmd
252 17 ▶ if exists $commands->{$cmd};
Branch: 1 branch
BranchTrueFalseTotal
if exists $commands->{$cmd} 2 15 17
253 }
254  
255 14 my %selective_roles;
256  
257 14 foreach my $cmd ( keys %{$roles} ) {
258 15 my $value = $roles->{$cmd};
259  
260 15 ▶ my @roles = choose {
Subroutine __ANON__: called CC=4 SCAR=13.9
261 15 ▶ return @{$value}
Branch: 1 branch
BranchTrueFalseTotal
if ref $value and builtin::reftype($value) eq "ARRAY" 2 13 15
Condition100%3/3
ref $value and builtin::reftype($value) eq "ARRAY"
!ll&&!rl&&r
1122
MC/DC100%2/2
ref $value and builtin::reftype($value) eq "ARRAY"
ref $value builtin::reftype($value) eq "ARRAY"
Truth table100%3/3
A and B
A= ref $valueB= builtin::reftype($value) eq "ARRAY"
ABresult
0X0
100
111
262 if ref $value && reftype($value) eq 'ARRAY';
263  
264 13 ▶ return ($value)
Branch: 1 branch
BranchTrueFalseTotal
unless ref $value 11 2 13
265 if !ref $value;
266  
267 2 die sprintf "ERROR: invalid roles specification for command '%s'\n", $cmd;
268 15 };
269  
270 13 foreach my $role (@roles) {
271 15 ▶ die sprintf "ERROR: invalid role '%s' for command '%s'\n", $role, $cmd
Branch: 1 branch
BranchTrueFalseTotal
unless _is_class_name($role) 1 14 15
272 if !_is_class_name($role);
273 }
274  
275 12 $selective_roles{$cmd} = \@roles;
276 }
277  
278 11 $manifest->{_commands} = $commands;
279 11 $manifest->{_roles} = \%selective_roles;
280  
281 11 return;
282 }
283  
284 ########################################################################
285 13 ▶sub _manifest {
Subroutine _manifest: called CC=1 SCAR=0.0
286 ########################################################################
287 13 my ($class) = @_;
288  
289 11 ▶ no strict 'refs'; ## no critic
Subroutine BEGIN: called CC=1 SCAR=0.0
290 13 return ${"${class}::_CLI_MANIFEST"};
291 }
292  
293 ########################################################################
294 6 ▶sub main {
Subroutine main: called CC=16 SCAR=34.8
Pod documented
295 ########################################################################
296 6 my ($class) = @_;
297  
298 6 my $manifest = $class->_manifest;
299  
300 my $cli = $class->new(
301 option_specs => $manifest ? ( $manifest->{options} // [] ) : [],
302 alias => $manifest ? ( $manifest->{alias} // {} ) : {},
303 default_options => $manifest ? ( $manifest->{default_options} // {} ) : {},
304 extra_options => $manifest ? ( $manifest->{extra_options} // [] ) : [],
305 commands => $manifest ? {} : { default => \&usage },
306 manifest_commands => $manifest ? ( $manifest->{_commands} // {} ) : {},
307 command_roles => $manifest ? ( $manifest->{_roles} // {} ) : {},
308 6 ▶ abbreviations => $manifest ? ( $manifest->{abbreviations} // $FALSE ) : $FALSE,
Branch: 8 branches
BranchTrueFalseTotal
$manifest ? : 6 0 6
$manifest ? : 6 0 6
$manifest ? : 6 0 6
$manifest ? : 6 0 6
$manifest ? : 6 0 6
$manifest ? : 6 0 6
$manifest ? : 6 0 6
$manifest ? : 6 0 6
Condition60%9/15
$manifest->{"options"} // []
l!l
06
$manifest->{"alias"} // {}
l!l
15
$manifest->{"default_options"} // {}
l!l
06
$manifest->{"extra_options"} // []
l!l
06
$manifest->{"_commands"} // {}
l!l
60
$manifest->{"_roles"} // {}
l!l
60
$manifest->{"abbreviations"} // $CLI::Simple::FALSE
l!l&&r!l&&!r
150
MC/DC0%0/1
$manifest->{"options"} // []
$manifest->{"options"}
MC/DC100%1/1
$manifest->{"alias"} // {}
$manifest->{"alias"}
MC/DC0%0/1
$manifest->{"default_options"} // {}
$manifest->{"default_options"}
MC/DC0%0/1
$manifest->{"extra_options"} // []
$manifest->{"extra_options"}
MC/DC0%0/1
$manifest->{"_commands"} // {}
$manifest->{"_commands"}
MC/DC0%0/1
$manifest->{"_roles"} // {}
$manifest->{"_roles"}
MC/DC0%0/2
$manifest->{"abbreviations"} // $CLI::Simple::FALSE
$manifest->{"abbreviations"} $CLI::Simple::FALSE
Truth table50%1/2
A
A= $manifest->{"options"}
Aresult
11
00
Truth table100%2/2
A
A= $manifest->{"alias"}
Aresult
11
00
Truth table50%1/2
A
A= $manifest->{"default_options"}
Aresult
11
00
Truth table50%1/2
A
A= $manifest->{"extra_options"}
Aresult
11
00
Truth table50%1/2
A
A= $manifest->{"_commands"}
Aresult
11
00
Truth table50%1/2
A
A= $manifest->{"_roles"}
Aresult
11
00
Truth table66%2/3
A // B
A= $manifest->{"abbreviations"}B= $CLI::Simple::FALSE
ABresult
1X1
011
000
309 );
310  
311 5 return $cli->run;
312 }
313  
314 11 my %LOGGER_ENABLED;
315 my %OPTION_PROVIDERS;
316 11 my %OPTION_PROVIDER_ORDER;
317  
318 ########################################################################
319 75 ▶sub _use_logger {
Subroutine _use_logger: called CC=3 SCAR=12.0
320 ########################################################################
321 75 my ($self) = @_;
322  
323 75 ▶ my $class = ref $self || $self;
Condition66%2/3
ref $self || $self
l!l&&r!l&&!r
46290
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table66%2/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
324  
325 75 ▶ return $LOGGER_ENABLED{$class} // $FALSE;
Condition33%1/3
$LOGGER_ENABLED{$class} // $CLI::Simple::FALSE
l!l&&r!l&&!r
0750
MC/DC0%0/2
$LOGGER_ENABLED{$class} // $CLI::Simple::FALSE
$LOGGER_ENABLED{$class} $CLI::Simple::FALSE
Truth table33%1/3
A // B
A= $LOGGER_ENABLED{$class}B= $CLI::Simple::FALSE
ABresult
1X1
011
000
326 }
327  
328 ########################################################################
329 8 ▶sub use_options {
Subroutine use_options: called CC=8 SCAR=20.8
Pod documented
330 ########################################################################
331  
332 8 my ( $class, @providers ) = @_;
333  
334 8 require Role::Tiny;
335  
336 8 ▶ croak 'Odd number of arguments to use_options'
Branch: 1 branch
BranchTrueFalseTotal
if @providers % 2 1 7 8
337 if @providers % 2;
338  
339 7 ▶ while (@providers) {
Branch: 1 branch
BranchTrueFalseTotal
if (@providers) 8 3 11
340 8 my ( $name, $definition ) = splice @providers, 0, 2;
341  
342 8 ▶ croak sprintf q{Invalid provider name: %s}, $name
Branch: 1 branch
BranchTrueFalseTotal
unless $name =~ /\A[a-z][a-z0-9_]*\z/ 1 7 8
343 if $name !~ /\A[a-z][a-z0-9_]*\z/;
344  
345 croak sprintf q{Duplicate option provider: %s}, $name
346 7 ▶ if exists $OPTION_PROVIDERS{$class}{$name};
Branch: 1 branch
BranchTrueFalseTotal
if exists $OPTION_PROVIDERS{$class}{$name} 1 6 7
347  
348 6 my ($role) = keys %{$definition};
349  
350 croak sprintf q{Invalid provider definition: %s}, $name
351 6 ▶ if keys %{$definition} != 1;
Branch: 1 branch
BranchTrueFalseTotal
if keys %{$definition;} != 1 1 5 6
352  
353 5 my $options = $definition->{$role};
354  
355 5 ▶ croak sprintf q{Invalid option list for provider: %s}, $name
Branch: 1 branch
BranchTrueFalseTotal
if ref $options ne "ARRAY" 1 4 5
356 if ref $options ne 'ARRAY';
357  
358 4 Role::Tiny->apply_roles_to_package( $class, $role );
359  
360 4 ▶ $OPTION_PROVIDER_ORDER{$class} //= [];
Condition100%2/2
$OPTION_PROVIDER_ORDER{$class} //= []
l!l
13
MC/DC100%1/1
$OPTION_PROVIDER_ORDER{$class} //= []
$OPTION_PROVIDER_ORDER{$class}
Truth table100%2/2
A
A= $OPTION_PROVIDER_ORDER{$class}
Aresult
11
00
361  
362 4 push @{ $OPTION_PROVIDER_ORDER{$class} }, $name;
363  
364 $OPTION_PROVIDERS{$class}{$name} = {
365 role => $role,
366 4 options => [ @{$options} ],
367 };
368 }
369  
370 3 return $class;
371 }
372  
373 ########################################################################
374 0 ▶sub use_log4perl {
Subroutine use_log4perl: not called CC=12 SCAR=49.1
Pod documented
375 ########################################################################
376 0 my ( $self, %args ) = @_;
377  
378 0 my @valid_options = qw(
379 log_level
380 level
381 loglevel
382 log-level
383 config
384 color
385 debug_color
386 info_color
387 warn_color
388 error_color
389 trace_color
390 fatal_color
391 );
392  
393 0 foreach my $o ( keys %args ) {
394 die "ERROR: unknown argument ($o)\n"
395 0 ▶ if none { $o eq $_ } @valid_options;
Subroutine __ANON__: not called CC=1 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
if &none(sub { $o eq $_; } , @valid_options) 0 0 0
396 }
397  
398 0 ▶ eval { require Log::Log4perl; 1; }
Branch: 1 branch
BranchTrueFalseTotal
eval { do { require Log::Log4perl; 1 } } or die "use_log4perl() requires Log::Log4perl, which is not installed.\nIt is an opt-in feature, so CLI::Simple does not depend on it.\nIf your app calls use_log4perl(), add 'Log::Log4perl' to your requires/cpanfile.\n" 0 0 0
399 or die "use_log4perl() requires Log::Log4perl, which is not installed.\n"
400 . "It is an opt-in feature, so CLI::Simple does not depend on it.\n"
401 . "If your app calls use_log4perl(), add 'Log::Log4perl' to your requires/cpanfile.\n";
402  
403 0 ▶ my $class = ref $self || $self;
Condition0%0/3
ref $self || $self
l!l&&r!l&&!r
000
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table0%0/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
404  
405 die "ERROR: color and config are mutually exclusive - color uses CLI::Simple's built-in colorized config\n"
406 0 ▶ if $args{color} && $args{config};
Branch: 1 branch
BranchTrueFalseTotal
if $args{"color"} and $args{"config"} 0 0 0
Condition0%0/3
$args{"color"} and $args{"config"}
!ll&&!rl&&r
000
MC/DC0%0/2
$args{"color"} and $args{"config"}
$args{"color"} $args{"config"}
Truth table0%0/3
A and B
A= $args{"color"}B= $args{"config"}
ABresult
0X0
100
111
407  
408 0 my ($level) = grep {defined} @args{qw(log_level log-level loglevel level)};
409 0 ▶ $level //= 'error';
Condition0%0/2
$level //= "error"
l!l
00
MC/DC0%0/1
$level //= "error"
$level
Truth table0%0/2
A
A= $level
Aresult
11
00
410  
411 0 my $log4perl_conf = $args{config};
412  
413 0 ▶ if ( $args{color} && !$log4perl_conf ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($args{"color"} and not $log4perl_conf) 0 0 0
Condition0%0/3
$args{"color"} and not $log4perl_conf
!ll&&!rl&&r
000
MC/DC0%0/2
$args{"color"} and not $log4perl_conf
$args{"color"} not $log4perl_conf
Truth table0%0/3
A and not(B)
A= $args{"color"}B= not $log4perl_conf
ABresult
0X0
100
111
414 0 $log4perl_conf = $self->_set_color_config(%args);
415 }
416  
417 {
418 0 $LOGGER_ENABLED{$class} = $TRUE;
419  
420 11 ▶ no strict 'refs'; ## no critic (ProhibitNoStrict)
Subroutine BEGIN: called CC=1 SCAR=0.0
421 0 ▶ *{"${class}::get_log4perl_conf"} = sub { return $log4perl_conf };
Subroutine __ANON__: not called CC=1 SCAR=6.9
422 0 ▶ *{"${class}::set_log4perl_conf"} = sub { $log4perl_conf = $_[1] };
Subroutine __ANON__: not called CC=1 SCAR=6.9
423 0 ▶ *{"${class}::get_log4perl_level"} = sub { return $level };
Subroutine __ANON__: not called CC=1 SCAR=6.9
424 }
425  
426 0 ▶ if ( !$self->can('set_logger') ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->can("set_logger")) 0 0 0
427 0 $self->mk_accessors('logger');
428 0 $GENERATED_ACCESSOR{$class}{logger} = $TRUE;
429 }
430  
431 0 ▶ if ( !$self->can('set_log_level') ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->can("set_log_level")) 0 0 0
432 0 $self->mk_accessors('log_level');
433 0 $GENERATED_ACCESSOR{$class}{log_level} = $TRUE;
434 }
435  
436 0 return $self;
437 }
438  
439 ########################################################################
440 30 ▶sub new {
Subroutine new: called CC=88 SCAR=52.0
Pod documented
441 ########################################################################
442 30 my ( $class, @params ) = @_;
443  
444 30 my $t0 = time;
445  
446 0 ▶ my %args = ref $params[0] ? %{ $params[0] } : @params;
Branch: 1 branch
BranchTrueFalseTotal
ref $params[0] ? : 0 30 30
447  
448 30 foreach my $o ( keys %args ) {
449 die "ERROR: unknown option '$o'\n"
450 102 ▶ if none { $o eq $_ } @VALID_OPTIONS;
Subroutine __ANON__: called CC=1 SCAR=0.0
Branch: 1 branch
BranchTrueFalseTotal
if &none(sub { $o eq $_; } , @CLI::Simple::VALID_OPTIONS) 1 101 102
451 }
452  
453 my (
454 $default_options, $option_specs, $commands, $command_roles, $manifest_commands, $extra_options,
455 $abbreviations, $error_handler, $alias, $validate_command, $help_sections
456 )
457 = @args{
458 29 qw(default_options option_specs commands command_roles manifest_commands extra_options abbreviations error_handler alias validate_command help_sections)
459 };
460  
461 29 ▶ $validate_command //= $TRUE;
Condition33%1/3
$validate_command //= $CLI::Simple::TRUE
l!l&&r!l&&!r
0290
MC/DC0%0/2
$validate_command //= $CLI::Simple::TRUE
$validate_command $CLI::Simple::TRUE
Truth table33%1/3
A //= B
A= $validate_commandB= $CLI::Simple::TRUE
ABresult
1X1
011
000
462  
463 11 ▶ no strict 'refs'; ## no critic
Subroutine BEGIN: called CC=1 SCAR=0.0
464  
465 29 my $stash = \%{ $class . $DOUBLE_COLON };
466  
467 29 local *alias = *alias; ## no critic ProhibitLocalVars
468  
469 11 ▶ use vars qw($DEFAULT_OPTIONS $EXTRA_OPTIONS $OPTION_SPECS $COMMANDS $LOGGING);
Subroutine BEGIN: called CC=1 SCAR=0.0
470  
471 29 ▶ *DEFAULT_OPTIONS = $stash->{DEFAULT_OPTIONS} // $EMPTY;
Condition66%2/3
$stash->{"DEFAULT_OPTIONS"} // $CLI::Simple::EMPTY
l!l&&r!l&&!r
16130
MC/DC0%0/2
$stash->{"DEFAULT_OPTIONS"} // $CLI::Simple::EMPTY
$stash->{"DEFAULT_OPTIONS"} $CLI::Simple::EMPTY
Truth table66%2/3
A // B
A= $stash->{"DEFAULT_OPTIONS"}B= $CLI::Simple::EMPTY
ABresult
1X1
011
000
472 29 ▶ *EXTRA_OPTIONS = $stash->{EXTRA_OPTIONS} // $EMPTY;
Condition66%2/3
$stash->{"EXTRA_OPTIONS"} // $CLI::Simple::EMPTY
l!l&&r!l&&!r
16130
MC/DC0%0/2
$stash->{"EXTRA_OPTIONS"} // $CLI::Simple::EMPTY
$stash->{"EXTRA_OPTIONS"} $CLI::Simple::EMPTY
Truth table66%2/3
A // B
A= $stash->{"EXTRA_OPTIONS"}B= $CLI::Simple::EMPTY
ABresult
1X1
011
000
473 29 ▶ *OPTION_SPECS = $stash->{OPTION_SPECS} // $EMPTY;
Condition66%2/3
$stash->{"OPTION_SPECS"} // $CLI::Simple::EMPTY
l!l&&r!l&&!r
16130
MC/DC0%0/2
$stash->{"OPTION_SPECS"} // $CLI::Simple::EMPTY
$stash->{"OPTION_SPECS"} $CLI::Simple::EMPTY
Truth table66%2/3
A // B
A= $stash->{"OPTION_SPECS"}B= $CLI::Simple::EMPTY
ABresult
1X1
011
000
474 29 ▶ *COMMANDS = $stash->{COMMANDS} // $EMPTY;
Condition66%2/3
$stash->{"COMMANDS"} // $CLI::Simple::EMPTY
l!l&&r!l&&!r
16130
MC/DC0%0/2
$stash->{"COMMANDS"} // $CLI::Simple::EMPTY
$stash->{"COMMANDS"} $CLI::Simple::EMPTY
Truth table66%2/3
A // B
A= $stash->{"COMMANDS"}B= $CLI::Simple::EMPTY
ABresult
1X1
011
000
475  
476 29 ▶ $default_options //= $DEFAULT_OPTIONS;
Condition66%2/3
$default_options //= $CLI::Simple::DEFAULT_OPTIONS
l!l&&r!l&&!r
7022
MC/DC50%1/2
$default_options //= $CLI::Simple::DEFAULT_OPTIONS
$default_options $CLI::Simple::DEFAULT_OPTIONS
Truth table66%2/3
A //= B
A= $default_optionsB= $CLI::Simple::DEFAULT_OPTIONS
ABresult
1X1
011
000
477 29 ▶ $extra_options //= $EXTRA_OPTIONS;
Condition66%2/3
$extra_options //= $CLI::Simple::EXTRA_OPTIONS
l!l&&r!l&&!r
6023
MC/DC50%1/2
$extra_options //= $CLI::Simple::EXTRA_OPTIONS
$extra_options $CLI::Simple::EXTRA_OPTIONS
Truth table66%2/3
A //= B
A= $extra_optionsB= $CLI::Simple::EXTRA_OPTIONS
ABresult
1X1
011
000
478 29 ▶ $option_specs //= $OPTION_SPECS;
Condition66%2/3
$option_specs //= $CLI::Simple::OPTION_SPECS
l!l&&r!l&&!r
2603
MC/DC50%1/2
$option_specs //= $CLI::Simple::OPTION_SPECS
$option_specs $CLI::Simple::OPTION_SPECS
Truth table66%2/3
A //= B
A= $option_specsB= $CLI::Simple::OPTION_SPECS
ABresult
1X1
011
000
479 29 ▶ $commands //= $COMMANDS;
Condition33%1/3
$commands //= $CLI::Simple::COMMANDS
l!l&&r!l&&!r
2900
MC/DC0%0/2
$commands //= $CLI::Simple::COMMANDS
$commands $CLI::Simple::COMMANDS
Truth table33%1/3
A //= B
A= $commandsB= $CLI::Simple::COMMANDS
ABresult
1X1
011
000
480  
481 29 ▶ $option_specs //= [];
Condition100%2/2
$option_specs //= []
l!l
263
MC/DC100%1/1
$option_specs //= []
$option_specs
Truth table100%2/2
A
A= $option_specs
Aresult
11
00
482 29 ▶ $commands //= {};
Condition50%1/2
$commands //= {}
l!l
290
MC/DC0%0/1
$commands //= {}
$commands
Truth table50%1/2
A
A= $commands
Aresult
11
00
483 29 ▶ $manifest_commands //= {};
Condition100%2/2
$manifest_commands //= {}
l!l
623
MC/DC100%1/1
$manifest_commands //= {}
$manifest_commands
Truth table100%2/2
A
A= $manifest_commands
Aresult
11
00
484 29 ▶ $command_roles //= {};
Condition100%2/2
$command_roles //= {}
l!l
623
MC/DC100%1/1
$command_roles //= {}
$command_roles
Truth table100%2/2
A
A= $command_roles
Aresult
11
00
485  
486 29 foreach my $command ( keys %{$manifest_commands}, keys %{$command_roles} ) {
487 0 ▶ $commands->{$command} //= sub { die "not implemented\n" };
Subroutine __ANON__: not called CC=1 SCAR=2.0
Condition33%1/3
$commands->{$command} //= sub { die "not implemented\n"; }
l!l&&r!l&&!r
080
MC/DC0%0/2
$commands->{$command} //= sub { die "not implemented\n"; }
$commands->{$command} sub { die "not implemented\n"; }
Truth table33%1/3
A //= B
A= $commands->{$command}B= sub { die "not implemented\n"; }
ABresult
1X1
011
000
488 }
489  
490 29 ▶ croak sprintf "ERROR: 'commands' is required\nusage: %s->new( option_specs => specs, commands => commands);\n", __PACKAGE__
Branch: 1 branch
BranchTrueFalseTotal
unless $option_specs and $commands 0 29 29
Condition33%1/3
$option_specs and $commands
!ll&&!rl&&r
0029
MC/DC0%0/2
$option_specs and $commands
$option_specs $commands
Truth table33%1/3
A and B
A= $option_specsB= $commands
ABresult
0X0
100
111
491 if !$option_specs || !$commands;
492  
493 29 my %command_target = map { $_ => $_ } keys %{$commands};
494  
495 29 ▶ $default_options //= {};
Condition100%2/2
$default_options //= {}
l!l
722
MC/DC100%1/1
$default_options //= {}
$default_options
Truth table100%2/2
A
A= $default_options
Aresult
11
00
496  
497 # my $options = { %{$default_options} };
498 29 my $options = {};
499  
500 0 ▶ if ( $class->_use_logger && none { $_ eq 'log-level' } @{$option_specs} ) {
Subroutine __ANON__: not called CC=1 SCAR=2.2
Branch: 1 branch
BranchTrueFalseTotal
if ($class->_use_logger and &none(sub { $_ eq "log-level"; } , @{$option_specs;})) 0 29 29
Condition33%1/3
$class->_use_logger and &none(sub { $_ eq "log-level"; } , @{$option_specs;})
!ll&&!rl&&r
2900
MC/DC0%0/2
$class->_use_logger and &none(sub { $_ eq "log-level"; } , @{$option_specs;})
$class->_use_logger &none(sub { $_ eq "log-level"; } , @{$option_specs;})
Truth table33%1/3
A and B
A= $class->_use_loggerB= &none(sub { $_ eq "log-level"; } , @{$option_specs;})
ABresult
0X0
100
111
501 0 push @{$option_specs}, 'log-level=s';
502 }
503  
504 # if we have an option alias, make sure the option alias spec is set too
505 29 ▶ if ( $alias && ref $alias && $alias->{options} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($alias and ref $alias and $alias->{"options"}) 7 22 29
Condition83%5/6
$alias and ref $alias and $alias->{"options"}
!ll&&!rl&&r
1667
$alias and ref $alias
!ll&&!rl&&r
16013
MC/DC66%2/3
$alias and ref $alias and $alias->{"options"}
$alias ref $alias $alias->{"options"}
Truth table75%3/4
A and B and C
A= $aliasB= ref $aliasC= $alias->{"options"}
ABCresult
0XX0
10X0
1100
1111
506 7 foreach my $p ( pairs %{ $alias->{options} } ) {
507 7 my ( $aka, $name ) = @{$p};
508  
509 # Does an option named $aka already exist (with or without a spec)?
510 7 ▶ my $aka_exists = any {/^\Q$aka\E(?:[^\w-].*)?$/xsm} @{$option_specs};
Subroutine __ANON__: called CC=1 SCAR=0.0
511  
512 7 ▶ if ( !$aka_exists ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($aka_exists) 2 5 7
513  
514 # Find the canonical spec for $name
515 2 my ($spec) = grep {/^\Q$name\E(?:[^\w-].*)?$/xsm} @{$option_specs};
516 2 ▶ croak sprintf 'ERROR: no such option defined: %s', $name if !$spec;
Branch: 1 branch
BranchTrueFalseTotal
unless $spec 0 2 2
517  
518 # Pull just the specifier part (e.g., '=s', ':i', '!', '+', etc.)
519 2 my ($spec_part) = $spec =~ /^\Q$name\E(?:[|].)?([^\w-].*)?$/xsm;
520  
521 2 ▶ $spec_part ||= q{};
Condition50%1/2
$spec_part ||= ""
l!l
20
MC/DC0%0/1
$spec_part ||= ""
$spec_part
Truth table50%1/2
A
A= $spec_part
Aresult
11
00
522  
523 2 push @{$option_specs}, $aka . $spec_part;
524 }
525 }
526 }
527  
528 29 ▶ if ( @ARGV && $ARGV[0] =~ /^-[[:alpha:]]/xsm ) {
Branch: 1 branch
BranchTrueFalseTotal
if (@ARGV and $ARGV[0] =~ /^-[[:alpha:]]/msx) 0 29 29
Condition66%2/3
@ARGV and $ARGV[0] =~ /^-[[:alpha:]]/msx
!ll&&!rl&&r
8210
MC/DC0%0/2
@ARGV and $ARGV[0] =~ /^-[[:alpha:]]/msx
@ARGV $ARGV[0] =~ /^-[[:alpha:]]/msx
Truth table66%2/3
A and B
A= @ARGVB= $ARGV[0] =~ /^-[[:alpha:]]/msx
ABresult
0X0
100
111
529 0 ▶ if ( my $handler = $INTERNAL_COMMANDS{ $ARGV[0] } ) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $handler = $CLI::Simple::INTERNAL_COMMANDS{$ARGV[0]}) 0 0 0
530 0 exit $handler->( $class, $commands, $option_specs );
531 }
532 }
533  
534 29 ▶ $GETOPT_STATUS = sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
535 29 ▶ local $SIG{__WARN__} = sub { $GETOPT_ERROR_MESSAGE = shift; return; };
Subroutine __ANON__: called CC=1 SCAR=0.0
536  
537 29 return GetOptions( $options, @{$option_specs} );
538 }
539 29 ->();
540  
541 29 normalize_options($options);
542  
543 29 my %cli_options;
544  
545 my @accessors
546 29 ▶ = ( @{ $extra_options || [] }, map { ( split /[^\w\-]/xsm )[0] } @{$option_specs} );
Condition100%2/2
$extra_options || []
l!l
623
MC/DC100%1/1
$extra_options || []
$extra_options
Truth table100%2/2
A
A= $extra_options
Aresult
11
00
547  
548 29 foreach (@accessors) {
549 31 ▶ die "ERROR: accessor must be a scalar\n" # somebody did @extra_options = [qw( a b c )] ???
Branch: 1 branch
BranchTrueFalseTotal
if ref $_ 0 31 31
550 if ref $_;
551  
552 31 s/\-/_/xsmg;
553  
554 # can() can't tell "a human hand-wrote this method" apart from
555 # "mk_accessors already generated this on an earlier ->new() call
556 # for this same class" -- both look identical. Only the latter is
557 # fine (constructing multiple instances of the same class within
558 # one process is completely normal); only the former is the
559 # genuine naming collision this check exists to catch. Track what
560 # this class has already generated, per class, so a repeat
561 # construction doesn't get mistaken for a hand-written conflict.
562  
563 31 ▶ if ( !$GENERATED_ACCESSOR{$class}{$_} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($GENERATED_ACCESSOR{$class}{$_}) 10 21 31
564 10 ▶ die "ERROR: accessor for $_ already exists!\n"
Branch: 1 branch
BranchTrueFalseTotal
if $class->can('get_' . $_) or $class->can('set_' . $_) 0 10 10
Condition33%1/3
$class->can('get_' . $_) or $class->can('set_' . $_)
l!l&&r!l&&!r
0010
MC/DC0%0/2
$class->can('get_' . $_) or $class->can('set_' . $_)
$class->can('get_' . $_) $class->can('set_' . $_)
Truth table33%1/3
A or B
A= $class->can('get_' . $_)B= $class->can('set_' . $_)
ABresult
1X1
011
000
565 if $class->can( 'get_' . $_ ) || $class->can( 'set_' . $_ );
566  
567 10 $class->mk_accessors($_);
568  
569 10 $GENERATED_ACCESSOR{$class}{$_} = $TRUE;
570 }
571  
572 31 $cli_options{$_} = $options->{$_};
573 }
574  
575 29 ▶ if ( !$error_handler && !$GETOPT_STATUS ) {
Branch: 2 branches
BranchTrueFalseTotal
if (not $error_handler || $CLI::Simple::GETOPT_STATUS) { } 2 27 29
elsif (not $CLI::Simple::GETOPT_STATUS) { } 0 27 27
Condition66%2/3
$error_handler || $CLI::Simple::GETOPT_STATUS
l!l&&r!l&&!r
0272
MC/DC50%1/2
$error_handler || $CLI::Simple::GETOPT_STATUS
$error_handler $CLI::Simple::GETOPT_STATUS
Truth table66%2/3
A || B
A= $error_handlerB= $CLI::Simple::GETOPT_STATUS
ABresult
1X1
011
000
576 2 print {*STDERR} $GETOPT_ERROR_MESSAGE;
577 2 ▶ if ($GETOPT_EXIT_ON_ERROR) {
Branch: 1 branch
BranchTrueFalseTotal
if ($CLI::Simple::GETOPT_EXIT_ON_ERROR) 2 0 2
578 2 _leave($FAILURE);
579 }
580 }
581 elsif ( !$GETOPT_STATUS ) {
582 0 ▶ if ( !$error_handler->($GETOPT_ERROR_MESSAGE) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&$error_handler($CLI::Simple::GETOPT_ERROR_MESSAGE)) 0 0 0
583 0 _leave($FAILURE);
584 }
585 }
586  
587 27 ▶ croak "ERROR: alias must be a hash ref with keys 'options' or 'commands'\n"
Branch: 1 branch
BranchTrueFalseTotal
if $alias and not ref $alias 0 27 27
Condition66%2/3
$alias and not ref $alias
!ll&&!rl&&r
14130
MC/DC0%0/2
$alias and not ref $alias
$alias not ref $alias
Truth table66%2/3
A and not(B)
A= $aliasB= not ref $alias
ABresult
0X0
100
111
588 if $alias && !ref $alias;
589  
590 27 ▶ if ($alias) {
Branch: 1 branch
BranchTrueFalseTotal
if ($alias) 13 14 27
591 13 ▶ if ( $alias->{options} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($alias->{"options"}) 7 6 13
592 7 foreach my $p ( pairs %{ $alias->{options} } ) {
593 7 my ( $aka, $name ) = @{$p};
594 7 $aka =~ s/[-]/_/gxsm;
595 7 $name =~ s/[-]/_/gxsm;
596  
597 7 ▶ if ( defined $cli_options{$name} ) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $cli_options{$name}) { } 6 1 7
elsif (defined $cli_options{$aka}) { } 1 0 1
598 6 $cli_options{$aka} = $cli_options{$name};
599 }
600 elsif ( defined $cli_options{$aka} ) {
601 1 $cli_options{$name} = $cli_options{$aka};
602 }
603 }
604 }
605  
606 # command aliases are a convenience so someone doesn't have to add
607 # to $commands manually
608  
609 13 ▶ if ( $alias->{commands} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($alias->{"commands"}) 2 11 13
610 2 foreach my $p ( pairs %{ $alias->{commands} } ) {
611 2 my ( $aka, $name ) = @{$p};
612  
613 croak sprintf "ERROR: no command: %s\n", $name
614 2 ▶ if !$commands->{$name};
Branch: 1 branch
BranchTrueFalseTotal
unless $commands->{$name} 0 2 2
615  
616 2 $commands->{$aka} = $commands->{$name};
617 2 $command_target{$aka} = $name;
618 }
619 }
620 }
621  
622 27 my $self = $class->SUPER::new( \%cli_options );
623 27 $self->set__options($options);
624  
625 27 ▶ if ( !$self->can('get_help_sections') ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $self->can('get_help_sections')) { } 16 11 27
626 16 $self->mk_accessors('help_sections');
627 16 $GENERATED_ACCESSOR{$class}{help_sections} = $TRUE;
628 }
629 else {
630 11 ▶ $help_sections //= $self->get_help_sections;
Condition33%1/3
$help_sections //= $self->get_help_sections
l!l&&r!l&&!r
0011
MC/DC0%0/2
$help_sections //= $self->get_help_sections
$help_sections $self->get_help_sections
Truth table33%1/3
A //= B
A= $help_sectionsB= $self->get_help_sections
ABresult
1X1
011
000
631 }
632  
633 27 ▶ $help_sections //= $default_options->{help_sections} // [@DEFAULT_HELP_SECTIONS];
Condition50%2/4
$help_sections //= $default_options->{"help_sections"} // [@CLI::Simple::DEFAULT_HELP_SECTIONS]
l!l
027
$default_options->{"help_sections"} // [@CLI::Simple::DEFAULT_HELP_SECTIONS]
l!l
027
MC/DC0%0/1
$help_sections //= $default_options->{"help_sections"} // [@CLI::Simple::DEFAULT_HELP_SECTIONS]
$help_sections
Truth table50%1/2
A
A= $help_sections
Aresult
11
00
634  
635 27 $self->set_help_sections($help_sections);
636  
637 # AUTO_DEFAULT uses the only command as the default
638 27 ▶ if ( $AUTO_DEFAULT && scalar keys %{$commands} == 1 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($CLI::Simple::AUTO_DEFAULT and scalar keys %{$commands;} == 1) 2 25 27
Condition100%3/3
$CLI::Simple::AUTO_DEFAULT and scalar keys %{$commands;} == 1
!ll&&!rl&&r
2412
MC/DC100%2/2
$CLI::Simple::AUTO_DEFAULT and scalar keys %{$commands;} == 1
$CLI::Simple::AUTO_DEFAULT scalar keys %{$commands;} == 1
Truth table100%3/3
A and B
A= $CLI::Simple::AUTO_DEFAULTB= scalar keys %{$commands;} == 1
ABresult
0X0
100
111
639 2 my ($command) = keys %{$commands};
640  
641 2 ▶ if ( @ARGV && $ARGV[0] ne $command ) {
Branch: 2 branches
BranchTrueFalseTotal
if (@ARGV and $ARGV[0] ne $command) { } 1 1 2
elsif (not @ARGV) { } 1 0 1
Condition66%2/3
@ARGV and $ARGV[0] ne $command
!ll&&!rl&&r
101
MC/DC50%1/2
@ARGV and $ARGV[0] ne $command
@ARGV $ARGV[0] ne $command
Truth table66%2/3
A and B
A= @ARGVB= $ARGV[0] ne $command
ABresult
0X0
100
111
642 1 unshift @ARGV, $command;
643 }
644 elsif ( !@ARGV ) {
645 1 unshift @ARGV, $command;
646 }
647 }
648  
649 27 ▶ my $command = shift @ARGV // $EMPTY;
Condition66%2/3
shift @ARGV // $CLI::Simple::EMPTY
l!l&&r!l&&!r
1980
MC/DC0%0/2
shift @ARGV // $CLI::Simple::EMPTY
shift @ARGV $CLI::Simple::EMPTY
Truth table66%2/3
A // B
A= shift @ARGVB= $CLI::Simple::EMPTY
ABresult
1X1
011
000
650  
651 27 ▶ if ( !$command ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($command) 8 19 27
652 8 ▶ if ( $commands->{default} ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($commands->{'default'}) { } 0 8 8
elsif ($CLI::Simple::AUTO_HELP) { } 1 7 8
653 0 ▶ $command = ref $commands->{default} ? 'default' : $commands->{default};
Branch: 1 branch
BranchTrueFalseTotal
ref $commands->{'default'} ? : 0 0 0
654 }
655 elsif ($AUTO_HELP) {
656 1 $command = 'help';
657 }
658 }
659  
660 27 $self->set__validate_command($validate_command);
661  
662 27 $self->set__command($command);
663  
664 27 $self->set__command_args( [@ARGV] );
665  
666 27 $self->set__commands($commands);
667  
668 27 $self->set__program("$RealBin/$RealScript");
669  
670 27 ▶ if ( $command eq 'help' || ( $self->can('get_help') && $self->get_help ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($command eq "help" or $self->can("get_help") and $self->get_help) 1 26 27
Condition50%3/6
$command eq "help" or $self->can("get_help") and $self->get_help
l!l&&r!l&&!r
1026
$self->can("get_help") and $self->get_help
!ll&&!rl&&r
2600
MC/DC33%1/3
$command eq "help" or $self->can("get_help") and $self->get_help
$command eq "help" $self->can("get_help") $self->get_help
Truth table50%2/4
A or B and C
A= $command eq "help"B= $self->can("get_help")C= $self->get_help
ABCresult
1XX1
0111
00X0
0100
671 # custom help function?
672  
673 1 my $help = $commands->{help};
674  
675 1 ▶ if ( !$help ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($help) 1 0 1
676 1 $self->usage;
677 }
678  
679 0 ▶ if ( ref $help && reftype($help) eq 'ARRAY' ) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $help and builtin::reftype($help) eq 'ARRAY') { } 0 0 0
Condition0%0/3
ref $help and builtin::reftype($help) eq "ARRAY"
!ll&&!rl&&r
000
MC/DC0%0/2
ref $help and builtin::reftype($help) eq "ARRAY"
ref $help builtin::reftype($help) eq "ARRAY"
Truth table0%0/3
A and B
A= ref $helpB= builtin::reftype($help) eq "ARRAY"
ABresult
0X0
100
111
680 0 $help->[0]->( $self, $TRUE );
681 }
682 else {
683 0 $help->( $self, $TRUE );
684 }
685 }
686  
687 26 ▶ $self->set__abbreviations( $abbreviations // $FALSE );
Condition66%2/3
$abbreviations // $CLI::Simple::FALSE
l!l&&r!l&&!r
8180
MC/DC0%0/2
$abbreviations // $CLI::Simple::FALSE
$abbreviations $CLI::Simple::FALSE
Truth table66%2/3
A // B
A= $abbreviationsB= $CLI::Simple::FALSE
ABresult
1X1
011
000
688  
689 26 $self->validate_command;
690 24 $command = $self->command;
691  
692 24 ▶ if ($command) {
Branch: 1 branch
BranchTrueFalseTotal
if ($command) 17 7 24
693 17 ▶ my $target_command = $command_target{$command} // $command;
Condition33%1/3
$command_target{$command} // $command
l!l&&r!l&&!r
1700
MC/DC0%0/2
$command_target{$command} // $command
$command_target{$command} $command
Truth table33%1/3
A // B
A= $command_target{$command}B= $command
ABresult
1X1
011
000
694  
695 17 ▶ if ( exists $command_roles->{$target_command} ) {
Branch: 2 branches
BranchTrueFalseTotal
if (exists $command_roles->{$target_command}) { } 5 12 17
elsif (exists $manifest_commands->{$target_command}) { } 1 11 12
696 5 my $roles = $command_roles->{$target_command};
697  
698 5 require Role::Tiny;
699 5 Role::Tiny->apply_roles_to_package( $class, @{$roles} );
700  
701 5 ( my $method = "cmd_$target_command" ) =~ s/-/_/gxsm;
702  
703 5 ▶ die sprintf "ERROR: roles for command '%s' do not implement %s\n", $target_command, $method
Branch: 1 branch
BranchTrueFalseTotal
unless $class->can($method) 1 4 5
704 if !$class->can($method);
705  
706 4 my $handler = $class->can($method);
707  
708 4 $commands->{$target_command} = $handler;
709 4 $commands->{$command} = $handler;
710 }
711 elsif ( exists $manifest_commands->{$target_command} ) {
712  
713 #
714 # Legacy semantics: selecting ONE legacy command opts into
715 # composition of the entire legacy role set.
716 #
717  
718 1 my %seen;
719 1 ▶ my @roles = grep { !$seen{$_}++ && _is_class_name($_) } values %{$manifest_commands};
Condition33%1/3
!$seen{$_}++ && _is_class_name($_)
!ll&&!rl&&r
002
MC/DC0%0/2
!$seen{$_}++ && _is_class_name($_)
!$seen{$_}++ _is_class_name($_)
Truth table33%1/3
not(A) && B
A= !$seen{$_}++B= _is_class_name($_)
ABresult
0X0
100
111
720  
721 1 require Role::Tiny;
722 1 Role::Tiny->apply_roles_to_package( $class, @roles );
723  
724 1 foreach my $cmd ( keys %{$manifest_commands} ) {
725 2 my $value = $manifest_commands->{$cmd};
726  
727 2 ▶ my $method = choose {
Subroutine __ANON__: called CC=2 SCAR=7.1
728 2 ▶ return $value
Branch: 1 branch
BranchTrueFalseTotal
unless _is_class_name($value) 0 2 2
729 if !_is_class_name($value);
730  
731 2 ( my $m = "cmd_$cmd" ) =~ s/-/_/gxsm;
732 2 return $m;
733 2 };
734  
735 2 ▶ die sprintf "ERROR: %s does not implement %s\n", $value, $method
Branch: 1 branch
BranchTrueFalseTotal
unless $class->can($method) 0 2 2
736 if !$class->can($method);
737  
738 2 $commands->{$cmd} = $class->can($method);
739 }
740  
741 #
742 # Restore aliases now that the placeholder handlers have
743 # been replaced by the real legacy dispatch handlers.
744 #
745  
746 1 foreach my $aka ( keys %command_target ) {
747 2 my $target = $command_target{$aka};
748  
749 next
750 2 ▶ if $aka eq $target;
Branch: 1 branch
BranchTrueFalseTotal
if $aka eq $target 2 0 2
751  
752 $commands->{$aka} = $commands->{$target}
753 0 ▶ if exists $commands->{$target};
Branch: 1 branch
BranchTrueFalseTotal
if exists $commands->{$target} 0 0 0
754 }
755 }
756 }
757  
758 23 $self->init_logger;
759  
760 23 my %resolved = map { $_ => 1 } keys %{$options};
761 23 $self->resolve_option_providers( \%resolved, \@accessors );
762 22 $self->init_defaults( $default_options, \%resolved );
763  
764 22 ▶ $self->can('init') && $self->init();
Branch: 1 branch
BranchTrueFalseTotal
$self->can("init") and $self->init 0 22 22
765  
766 22 return $self;
767 }
768  
769 ########################################################################
770 0 ▶sub options {
Subroutine options: not called CC=1 SCAR=6.9
Pod documented
771 ########################################################################
772 0 my ($self) = @_;
773  
774 0 return $self->get__options;
775 }
776  
777 ########################################################################
778 23 ▶sub resolve_option_providers {
Subroutine resolve_option_providers: called CC=16 SCAR=31.0
Pod undocumented
779 ########################################################################
780 23 my ( $self, $resolved, $eligible_names ) = @_;
781  
782 23 ▶ my $class = ref $self || $self;
Condition33%1/3
ref $self || $self
l!l&&r!l&&!r
2300
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table33%1/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
783 23 ▶ $resolved //= {};
Condition50%1/2
$resolved //= {}
l!l
230
MC/DC0%0/1
$resolved //= {}
$resolved
Truth table50%1/2
A
A= $resolved
Aresult
11
00
784  
785 23 ▶ my %eligible = map { $_ => 1 } @{ $eligible_names // [] };
Condition50%1/2
$eligible_names // []
l!l
230
MC/DC0%0/1
$eligible_names // []
$eligible_names
Truth table50%1/2
A
A= $eligible_names
Aresult
11
00
786  
787 23 ▶ foreach my $name ( @{ $OPTION_PROVIDER_ORDER{$class} // [] } ) {
Condition100%2/2
$OPTION_PROVIDER_ORDER{$class} // []
l!l
221
MC/DC100%1/1
$OPTION_PROVIDER_ORDER{$class} // []
$OPTION_PROVIDER_ORDER{$class}
Truth table100%2/2
A
A= $OPTION_PROVIDER_ORDER{$class}
Aresult
11
00
788 2 my $provider = $OPTION_PROVIDERS{$class}{$name};
789 2 my @requested = @{ $provider->{options} };
790 2 ▶ if ( !@requested ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@requested) 0 2 2
791 0 @requested = keys %eligible;
792 }
793  
794 2 my %seen;
795 2 ▶ my @unresolved = grep { !$seen{$_}++ && exists $eligible{$_} && !exists $resolved->{$_} } @requested;
Condition50%3/6
!$seen{$_}++ && exists $eligible{$_} && !exists $resolved->{$_}
!ll&&!rl&&r
011
not $seen{$_}++ and exists $eligible{$_}
!ll&&!rl&&r
002
MC/DC33%1/3
!$seen{$_}++ && exists $eligible{$_} && !exists $resolved->{$_}
not $seen{$_}++ exists $eligible{$_} !exists $resolved->{$_}
Truth table50%2/4
not(A) and B && not(C)
A= not $seen{$_}++B= exists $eligible{$_}C= !exists $resolved->{$_}
ABCresult
0XX0
10X0
1100
1111
796 2 ▶ next if !@unresolved;
Branch: 1 branch
BranchTrueFalseTotal
unless @unresolved 1 1 2
797  
798 1 my $init = q{_} . $name . q{_init};
799 1 my $resolver = q{_} . $name . q{_resolve};
800  
801 1 ▶ croak sprintf q{Option provider '%s' has no resolver '%s'}, $name, $resolver
Branch: 1 branch
BranchTrueFalseTotal
unless $self->can($resolver) 0 1 1
802 if !$self->can($resolver);
803  
804 1 ▶ if ( $self->can($init) ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->can($init)) 0 1 1
805 0 $self->$init();
806 }
807  
808 1 my $values = $self->$resolver(@unresolved);
809 1 ▶ croak sprintf q{Option provider '%s' must return a hash reference}, $name
Branch: 1 branch
BranchTrueFalseTotal
if not ref $values or builtin::reftype($values) ne "HASH" 0 1 1
Condition33%1/3
not ref $values or builtin::reftype($values) ne "HASH"
l!l&&r!l&&!r
001
MC/DC0%0/2
not ref $values or builtin::reftype($values) ne "HASH"
not ref $values builtin::reftype($values) ne "HASH"
Truth table33%1/3
not(A) or B
A= not ref $valuesB= builtin::reftype($values) ne "HASH"
ABresult
1X1
011
000
810 if !ref $values || reftype($values) ne 'HASH';
811  
812 1 my %allowed = map { $_ => 1 } @unresolved;
813 1 foreach my $option ( keys %{$values} ) {
814 croak sprintf q{Option provider '%s' returned unrequested option '%s'}, $name, $option
815 1 ▶ if !exists $allowed{$option};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $allowed{$option} 1 0 1
816  
817 0 $self->set( $option, $values->{$option} );
818 0 $resolved->{$option} = 1;
819 }
820 }
821  
822 22 return $self;
823 }
824  
825 ########################################################################
826 22 ▶sub init_defaults {
Subroutine init_defaults: called CC=6 SCAR=18.7
Pod undocumented
827 ########################################################################
828 22 my ( $self, $default_options, $resolved ) = @_;
829 22 ▶ $resolved //= {};
Condition50%1/2
$resolved //= {}
l!l
220
MC/DC0%0/1
$resolved //= {}
$resolved
Truth table50%1/2
A
A= $resolved
Aresult
11
00
830  
831 22 foreach my $o ( keys %{$default_options} ) {
832 1 ▶ next if !$self->can( 'set_' . $o );
Branch: 1 branch
BranchTrueFalseTotal
unless $self->can('set_' . $o) 0 1 1
833 1 ▶ next if exists $resolved->{$o};
Branch: 1 branch
BranchTrueFalseTotal
if exists $resolved->{$o} 0 1 1
834 1 ▶ next if defined $self->get($o);
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->get($o) 0 1 1
835  
836 1 $self->set( $o, $default_options->{$o} );
837 }
838  
839 22 return $self;
840 }
841  
842 ########################################################################
843 4 ▶sub _pod_has_section {
Subroutine _pod_has_section: called CC=4 SCAR=13.9
844 ########################################################################
845 4 my ( $filename, $section ) = @_;
846  
847 4 ▶ open my $fh, '<', $filename
Branch: 1 branch
BranchTrueFalseTotal
open my $fh, "<", $filename or return $CLI::Simple::FALSE 4 0 4
848 or return $FALSE;
849  
850 4 ▶ while ( my $line = <$fh> ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $line = readline $fh)) 163 1 164
851 163 ▶ return $TRUE
Branch: 1 branch
BranchTrueFalseTotal
if $line =~ /\A=head1\s+\Q$section\E\s*\z/msx 3 160 163
852 if $line =~ /\A=head1\s+\Q$section\E\s*\z/xsm;
853 }
854  
855 1 return $FALSE;
856 }
857  
858 ########################################################################
859 5 ▶sub _get_help_sections {
Subroutine _get_help_sections: called CC=5 SCAR=16.1
860 ########################################################################
861 5 my ( $self, $input ) = @_;
862  
863 5 my $sections = $self->get_help_sections;
864  
865 return $sections
866 5 ▶ if @{$sections} != @DEFAULT_HELP_SECTIONS;
Branch: 1 branch
BranchTrueFalseTotal
if @{$sections;} != @CLI::Simple::DEFAULT_HELP_SECTIONS 1 4 5
867  
868 4 for my $idx ( 0 .. $#DEFAULT_HELP_SECTIONS ) {
869 20 ▶ return $sections
Branch: 1 branch
BranchTrueFalseTotal
if $sections->[$idx] ne $CLI::Simple::DEFAULT_HELP_SECTIONS[$idx] 0 20 20
870 if $sections->[$idx] ne $DEFAULT_HELP_SECTIONS[$idx];
871 }
872  
873 4 ▶ return [ _pod_has_section( $input, 'USAGE' )
Branch: 1 branch
BranchTrueFalseTotal
_pod_has_section($input, 'USAGE') ? : 3 1 4
874 ? 'USAGE'
875 : 'SYNOPSIS',
876 'DESCRIPTION/Commands', 'DESCRIPTION/Options', 'OPTIONS', ];
877 }
878  
879 ########################################################################
880 7 ▶sub _leave {
Subroutine _leave: called CC=2 SCAR=7.1
881 ########################################################################
882 7 my (@args) = @_;
883  
884 7 ▶ my ($exit_code) = ref $args[0] ? $args[1] : $args[0];
Branch: 1 branch
BranchTrueFalseTotal
ref $args[0] ? : 0 7 7
885  
886 7 exit $exit_code;
887 }
888  
889 ########################################################################
890 0 ▶sub _set_color_config {
Subroutine _set_color_config: not called CC=7 SCAR=40.3
891 ########################################################################
892 0 my ( $self, %args ) = @_;
893  
894 return sprintf $LOG4PERL_CONF,
895 $args{debug_color} // $LOG4PERL_COLOR_DEBUG,
896 $args{info_color} // $LOG4PERL_COLOR_INFO,
897 $args{warn_color} // $LOG4PERL_COLOR_WARN,
898 $args{error_color} // $LOG4PERL_COLOR_ERROR,
899 $args{fatal_color} // $LOG4PERL_COLOR_FATAL,
900 0 ▶ $args{trace_color} // $LOG4PERL_COLOR_TRACE;
Condition0%0/18
$args{"debug_color"} // $CLI::Simple::LOG4PERL_COLOR_DEBUG
l!l&&r!l&&!r
000
$args{"info_color"} // $CLI::Simple::LOG4PERL_COLOR_INFO
l!l&&r!l&&!r
000
$args{"warn_color"} // $CLI::Simple::LOG4PERL_COLOR_WARN
l!l&&r!l&&!r
000
$args{"error_color"} // $CLI::Simple::LOG4PERL_COLOR_ERROR
l!l&&r!l&&!r
000
$args{"fatal_color"} // $CLI::Simple::LOG4PERL_COLOR_FATAL
l!l&&r!l&&!r
000
$args{"trace_color"} // $CLI::Simple::LOG4PERL_COLOR_TRACE
l!l&&r!l&&!r
000
MC/DC0%0/2
$args{"debug_color"} // $CLI::Simple::LOG4PERL_COLOR_DEBUG
$args{"debug_color"} $CLI::Simple::LOG4PERL_COLOR_DEBUG
MC/DC0%0/2
$args{"info_color"} // $CLI::Simple::LOG4PERL_COLOR_INFO
$args{"info_color"} $CLI::Simple::LOG4PERL_COLOR_INFO
MC/DC0%0/2
$args{"warn_color"} // $CLI::Simple::LOG4PERL_COLOR_WARN
$args{"warn_color"} $CLI::Simple::LOG4PERL_COLOR_WARN
MC/DC0%0/2
$args{"error_color"} // $CLI::Simple::LOG4PERL_COLOR_ERROR
$args{"error_color"} $CLI::Simple::LOG4PERL_COLOR_ERROR
MC/DC0%0/2
$args{"fatal_color"} // $CLI::Simple::LOG4PERL_COLOR_FATAL
$args{"fatal_color"} $CLI::Simple::LOG4PERL_COLOR_FATAL
MC/DC0%0/2
$args{"trace_color"} // $CLI::Simple::LOG4PERL_COLOR_TRACE
$args{"trace_color"} $CLI::Simple::LOG4PERL_COLOR_TRACE
Truth table0%0/3
A // B
A= $args{"debug_color"}B= $CLI::Simple::LOG4PERL_COLOR_DEBUG
ABresult
1X1
011
000
Truth table0%0/3
A // B
A= $args{"info_color"}B= $CLI::Simple::LOG4PERL_COLOR_INFO
ABresult
1X1
011
000
Truth table0%0/3
A // B
A= $args{"warn_color"}B= $CLI::Simple::LOG4PERL_COLOR_WARN
ABresult
1X1
011
000
Truth table0%0/3
A // B
A= $args{"error_color"}B= $CLI::Simple::LOG4PERL_COLOR_ERROR
ABresult
1X1
011
000
Truth table0%0/3
A // B
A= $args{"fatal_color"}B= $CLI::Simple::LOG4PERL_COLOR_FATAL
ABresult
1X1
011
000
Truth table0%0/3
A // B
A= $args{"trace_color"}B= $CLI::Simple::LOG4PERL_COLOR_TRACE
ABresult
1X1
011
000
901 }
902  
903 ########################################################################
904 23 ▶sub init_logger {
Subroutine init_logger: called CC=23 SCAR=60.3
Pod undocumented
905 ########################################################################
906 23 my ($self) = @_;
907  
908 23 ▶ if ( $self->_use_logger && $self->can('get_log4perl_conf') ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_use_logger and $self->can("get_log4perl_conf")) 0 23 23
Condition33%1/3
$self->_use_logger and $self->can("get_log4perl_conf")
!ll&&!rl&&r
2300
MC/DC0%0/2
$self->_use_logger and $self->can("get_log4perl_conf")
$self->_use_logger $self->can("get_log4perl_conf")
Truth table33%1/3
A and B
A= $self->_use_loggerB= $self->can("get_log4perl_conf")
ABresult
0X0
100
111
909  
910 0 my $config = $self->get_log4perl_conf;
911  
912 0 ▶ my $color = $self->can('get_color') && defined $self->get_color ? $self->get_color : $config && $config eq $LOG4PERL_CONF;
Branch: 1 branch
BranchTrueFalseTotal
$self->can('get_color') && defined $self->get_color ? : 0 0 0
Condition0%0/6
$self->can("get_color") and defined $self->get_color
!ll&&!rl&&r
000
$config and $config eq $CLI::Simple::LOG4PERL_CONF
!ll&&!rl&&r
000
MC/DC0%0/2
$self->can("get_color") and defined $self->get_color
$self->can("get_color") defined $self->get_color
MC/DC0%0/2
$config and $config eq $CLI::Simple::LOG4PERL_CONF
$config $config eq $CLI::Simple::LOG4PERL_CONF
Truth table0%0/3
A and B
A= $self->can("get_color")B= defined $self->get_color
ABresult
0X0
100
111
Truth table0%0/3
A and B
A= $configB= $config eq $CLI::Simple::LOG4PERL_CONF
ABresult
0X0
100
111
913  
914 0 ▶ $color = $color && eval { require Term::ANSIColor; 1; };
Condition0%0/3
$color && eval { do { require Term::ANSIColor; 1 } }
!ll&&!rl&&r
000
MC/DC0%0/2
$color && eval { do { require Term::ANSIColor; 1 } }
$color eval { do { require Term::ANSIColor; 1 } }
Truth table0%0/3
A && B
A= $colorB= eval { do { require Term::ANSIColor; 1 } }
ABresult
0X0
100
111
915  
916 # color on, but not done through use_log4perl?
917 0 ▶ if ( $color && !$config ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($color and not $config) { } 0 0 0
elsif (not $color and $config and $config =~ /screencoloredlevels/imsx) { } 0 0 0
Condition0%0/3
$color and not $config
!ll&&!rl&&r
000
MC/DC0%0/2
$color and not $config
$color not $config
Truth table0%0/3
A and not(B)
A= $colorB= not $config
ABresult
0X0
100
111
918 0 $config = $self->_set_color_config;
919 }
920 ▶ elsif ( !$color && $config && $config =~ /screencoloredlevels/xsmi ) {
Condition0%0/6
not $color and $config and $config =~ /screencoloredlevels/imsx
!ll&&!rl&&r
000
not $color and $config
!ll&&!rl&&r
000
MC/DC0%0/3
not $color and $config and $config =~ /screencoloredlevels/imsx
not $color $config $config =~ /screencoloredlevels/imsx
Truth table0%0/4
not(A) and B and C
A= not $colorB= $configC= $config =~ /screencoloredlevels/imsx
ABCresult
0XX0
10X0
1100
1111
921 0 $config = q{};
922 }
923  
924 0 $self->set_log4perl_conf($config);
925  
926 0 ▶ if ($config) {
Branch: 1 branch
BranchTrueFalseTotal
if ($config) { } 0 0 0
927 0 ▶ Log::Log4perl->init( ref $config ? $config : \$config );
Branch: 1 branch
BranchTrueFalseTotal
ref $config ? : 0 0 0
928 }
929 else {
930 0 Log::Log4perl->easy_init( $LOG_LEVELS{error} );
931 }
932  
933 0 my $logger = Log::Log4perl->get_logger(q{});
934  
935 0 $self->set_logger($logger);
936  
937 }
938 23 ▶ return $self
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_use_logger and $self->can("get_logger") and $self->get_logger 23 0 23
Condition33%2/6
$self->_use_logger and $self->can("get_logger") and $self->get_logger
!ll&&!rl&&r
2300
$self->_use_logger and $self->can("get_logger")
!ll&&!rl&&r
2300
MC/DC0%0/3
$self->_use_logger and $self->can("get_logger") and $self->get_logger
$self->_use_logger $self->can("get_logger") $self->get_logger
Truth table25%1/4
A and B and C
A= $self->_use_loggerB= $self->can("get_logger")C= $self->get_logger
ABCresult
0XX0
10X0
1100
1111
939 if !$self->_use_logger || !$self->can('get_logger') || !$self->get_logger;
940  
941 0 my $commands = $self->commands;
942 0 my $command = $self->command;
943  
944 0 my $command_level;
945  
946 0 ▶ if ( $command && ref( $commands->{$command} ) && reftype( $commands->{$command} ) eq 'ARRAY' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($command and ref $commands->{$command} and builtin::reftype($commands->{$command}) eq "ARRAY") 0 0 0
Condition0%0/6
$command and ref $commands->{$command} and builtin::reftype($commands->{$command}) eq "ARRAY"
!ll&&!rl&&r
000
$command and ref $commands->{$command}
!ll&&!rl&&r
000
MC/DC0%0/3
$command and ref $commands->{$command} and builtin::reftype($commands->{$command}) eq "ARRAY"
$command ref $commands->{$command} builtin::reftype($commands->{$command}) eq "ARRAY"
Truth table0%0/4
A and B and C
A= $commandB= ref $commands->{$command}C= builtin::reftype($commands->{$command}) eq "ARRAY"
ABCresult
0XX0
10X0
1100
1111
947 0 ( undef, $command_level ) = @{ $commands->{$command} };
948 }
949  
950 0 ▶ my $level = $self->get_log_level // $command_level // $self->get_log4perl_level;
Condition0%0/6
($self->get_log_level // $command_level) // $self->get_log4perl_level
l!l&&r!l&&!r
000
$self->get_log_level // $command_level
l!l&&r!l&&!r
000
MC/DC0%0/3
($self->get_log_level // $command_level) // $self->get_log4perl_level
$self->get_log_level $command_level $self->get_log4perl_level
Truth table0%0/4
A // B // C
A= $self->get_log_levelB= $command_levelC= $self->get_log4perl_level
ABCresult
1XX1
01X1
0011
0000
951  
952 0 $self->set_log_level($level);
953  
954 0 ▶ $self->get_logger->level( $LOG_LEVELS{$level} // $LOG_LEVELS{info} );
Condition0%0/3
$CLI::Simple::LOG_LEVELS{$level} // $CLI::Simple::LOG_LEVELS{"info"}
l!l&&r!l&&!r
000
MC/DC0%0/2
$CLI::Simple::LOG_LEVELS{$level} // $CLI::Simple::LOG_LEVELS{"info"}
$CLI::Simple::LOG_LEVELS{$level} $CLI::Simple::LOG_LEVELS{"info"}
Truth table0%0/3
A // B
A= $CLI::Simple::LOG_LEVELS{$level}B= $CLI::Simple::LOG_LEVELS{"info"}
ABresult
1X1
011
000
955  
956 0 return $self;
957 }
958  
959 ########################################################################
960 0 ▶sub get_kv_args {
Subroutine get_kv_args: not called CC=2 SCAR=17.9
Pod undocumented
961 ########################################################################
962 0 my ($self) = @_;
963  
964 0 my @arg_list = @{ $self->get__command_args };
965  
966 0 my %args;
967  
968 0 foreach (@arg_list) {
969 0 my ( $k, $v ) = split /=/xsm;
970 0 $args{$k} = $v;
971 }
972  
973 0 return %args;
974 }
975  
976 ########################################################################
977 0 ▶sub set_args {
Subroutine set_args: not called CC=1 SCAR=6.9
Pod documented
978 ########################################################################
979 0 my ( $self, $args ) = @_;
980  
981 0 $self->set__command_args($args);
982  
983 0 return $args;
984 }
985  
986 ########################################################################
987 4 ▶sub get_args {
Subroutine get_args: called CC=5 SCAR=16.1
Pod documented
988 ########################################################################
989 4 my ( $self, @vars ) = @_;
990  
991 4 my $command_args = $self->get__command_args;
992  
993 4 ▶ return wantarray ? @{$command_args} : $command_args
Branch: 2 branches
BranchTrueFalseTotal
unless @vars 2 2 4
wantarray ? : 2 0 2
994 if !@vars;
995  
996 2 ▶ @vars = map { $_ ? $_ : '<undef>' } @vars;
Branch: 1 branch
BranchTrueFalseTotal
$_ ? : 5 1 6
997  
998 2 my %args;
999 2 @args{@vars} = @{$command_args}[ 0 .. $#vars ];
1000  
1001 2 delete $args{'<undef>'};
1002  
1003 2 ▶ return wantarray ? %args : \%args;
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 1 1 2
1004 }
1005  
1006 ########################################################################
1007 0 ▶sub default_command {
Subroutine default_command: not called CC=1 SCAR=6.9
Pod undocumented
1008 ########################################################################
1009 0 goto &usage;
1010 }
1011  
1012 ########################################################################
1013 5 ▶sub usage {
Subroutine usage: called CC=8 SCAR=26.3
Pod documented
1014 ########################################################################
1015 5 my ($self) = @_;
1016  
1017 5 require Pod::Usage;
1018  
1019 5 ▶ my $wrapper = $ENV{MODULINO_WRAPPER} // q{};
Condition50%1/2
$ENV{"MODULINO_WRAPPER"} // ""
l!l
05
MC/DC0%0/1
$ENV{"MODULINO_WRAPPER"} // ""
$ENV{"MODULINO_WRAPPER"}
Truth table50%1/2
A
A= $ENV{"MODULINO_WRAPPER"}
Aresult
11
00
1020  
1021 5 ▶ my $input = $wrapper eq 'cli-simple' ? $INC{'CLI/Simple/Shell.pm'} : $self->get__program;
Branch: 1 branch
BranchTrueFalseTotal
$wrapper eq 'cli-simple' ? : 0 5 5
1022  
1023 5 ▶ if ( $wrapper && $wrapper ne 'cli-simple' && $ENV{MODULINO_MODULE_NAME} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($wrapper and $wrapper ne "cli-simple" and $ENV{"MODULINO_MODULE_NAME"}) 0 5 5
Condition33%2/6
$wrapper and $wrapper ne "cli-simple" and $ENV{"MODULINO_MODULE_NAME"}
!ll&&!rl&&r
500
$wrapper and $wrapper ne "cli-simple"
!ll&&!rl&&r
500
MC/DC0%0/3
$wrapper and $wrapper ne "cli-simple" and $ENV{"MODULINO_MODULE_NAME"}
$wrapper $wrapper ne "cli-simple" $ENV{"MODULINO_MODULE_NAME"}
Truth table25%1/4
A and B and C
A= $wrapperB= $wrapper ne "cli-simple"C= $ENV{"MODULINO_MODULE_NAME"}
ABCresult
0XX0
10X0
1100
1111
1024 0 ( my $module_file = $ENV{MODULINO_MODULE_NAME} ) =~ s{::}{/}gxsm;
1025 0 $input = $INC{"$module_file.pm"};
1026 }
1027  
1028 5 ▶ if ( $PAGER && IO::Interactive::is_interactive ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($CLI::Simple::PAGER and IO::Interactive::is_interactive()) 0 5 5
Condition66%2/3
$CLI::Simple::PAGER and IO::Interactive::is_interactive()
!ll&&!rl&&r
410
MC/DC0%0/2
$CLI::Simple::PAGER and IO::Interactive::is_interactive()
$CLI::Simple::PAGER IO::Interactive::is_interactive()
Truth table66%2/3
A and B
A= $CLI::Simple::PAGERB= IO::Interactive::is_interactive()
ABresult
0X0
100
111
1029 0 eval {
1030 0 require IO::Pager;
1031 0 IO::Pager->new(*STDOUT);
1032 };
1033 }
1034  
1035 5 my $sections = $self->_get_help_sections($input);
1036  
1037 5 Pod::Usage::pod2usage(
1038 -noperldoc => 1,
1039 -exitval => 'NOEXIT',
1040 -input => $input,
1041 -verbose => 99,
1042 -sections => $sections,
1043 );
1044  
1045 5 return _leave($FAILURE);
1046 }
1047  
1048 ########################################################################
1049 0 ▶sub example {
Subroutine example: not called CC=1 SCAR=6.9
Pod undocumented
1050 ########################################################################
1051 0 require File::ShareDir;
1052  
1053 0 print {*STDOUT} slurp File::ShareDir::dist_file( 'CLI-Simple', 'MyScript.pm' );
1054  
1055 0 return 0;
1056 }
1057  
1058 ########################################################################
1059 61 ▶sub command {
Subroutine command: called CC=2 SCAR=7.6
Pod documented
1060 ########################################################################
1061 61 my ( $self, $command ) = @_;
1062  
1063 61 ▶ if ($command) {
Branch: 1 branch
BranchTrueFalseTotal
if ($command) 0 61 61
1064 0 $self->set__command($command);
1065 }
1066  
1067 61 return $self->get__command;
1068 }
1069  
1070 ########################################################################
1071 0 ▶sub command_args {
Subroutine command_args: not called CC=3 SCAR=24.8
Pod documented
1072 ########################################################################
1073 0 my ( $self, @args ) = @_;
1074  
1075 0 ▶ return $self->get__command_args
Branch: 1 branch
BranchTrueFalseTotal
unless @args 0 0 0
1076 if !@args;
1077  
1078 0 ▶ if ( ref $args[0] ) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $args[0]) 0 0 0
1079 0 $self->set__command_args( $args[0] );
1080 0 return;
1081 }
1082  
1083 0 $self->set__command_args( [@args] );
1084  
1085 0 return;
1086 }
1087  
1088 ########################################################################
1089 30 ▶sub commands {
Subroutine commands: called CC=4 SCAR=18.7
Pod documented
1090 ########################################################################
1091 30 my ( $self, $command, $handler ) = @_;
1092  
1093 30 my $commands = $self->get__commands;
1094  
1095 30 ▶ if ( $command && $handler ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($command and $handler) 0 30 30
Condition33%1/3
$command and $handler
!ll&&!rl&&r
3000
MC/DC0%0/2
$command and $handler
$command $handler
Truth table33%1/3
A and B
A= $commandB= $handler
ABresult
0X0
100
111
1096  
1097 0 ▶ croak "ERROR: usage: commands([command, subref])\n"
Branch: 1 branch
BranchTrueFalseTotal
if builtin::reftype($handler) ne "CODE" 0 0 0
1098 if reftype($handler) ne 'CODE';
1099  
1100 0 $commands->{$command} = $handler;
1101 }
1102  
1103 30 return $commands;
1104 }
1105  
1106 ########################################################################
1107 11 ▶sub program {
Subroutine program: called CC=1 SCAR=0.0
Pod undocumented
1108 ########################################################################
1109 11 my ($self) = @_;
1110  
1111 11 return $self->get__program;
1112 }
1113  
1114 ########################################################################
1115 26 ▶sub validate_command {
Subroutine validate_command: called CC=7 SCAR=19.5
Pod documented
1116 ########################################################################
1117 26 my ($self) = @_;
1118  
1119 26 my $command = $self->command;
1120  
1121 return
1122 26 ▶ if !$command || !$self->get__validate_command;
Branch: 1 branch
BranchTrueFalseTotal
unless $command and $self->get__validate_command 7 19 26
Condition66%2/3
$command and $self->get__validate_command
!ll&&!rl&&r
7019
MC/DC50%1/2
$command and $self->get__validate_command
$command $self->get__validate_command
Truth table66%2/3
A and B
A= $commandB= $self->get__validate_command
ABresult
0X0
100
111
1123  
1124 19 my $commands = $self->commands;
1125  
1126 return $command
1127 19 ▶ if defined $commands->{$command};
Branch: 1 branch
BranchTrueFalseTotal
if defined $commands->{$command} 15 4 19
1128  
1129 4 ▶ croak sprintf "Unknown command: %s\n", $command
Branch: 1 branch
BranchTrueFalseTotal
unless $self->get__abbreviations 1 3 4
1130 if !$self->get__abbreviations;
1131  
1132 3 my $abbreviation = $command;
1133  
1134 3 my @matches = grep {/^$abbreviation/xsm} keys %{$commands};
1135  
1136 3 ▶ croak sprintf "Unknown command: %s\n", $command
Branch: 1 branch
BranchTrueFalseTotal
unless @matches 0 3 3
1137 if !@matches;
1138  
1139 3 ▶ if ( @matches == 1 ) {
Branch: 1 branch
BranchTrueFalseTotal
if (@matches == 1) 2 1 3
1140 2 $command = $matches[0]; # Unique match - accept
1141 2 $self->set__command($command);
1142 2 return $command;
1143 }
1144  
1145 1 croak sprintf "Ambiguous command '$abbreviation'; could match: %s\n", join q{,}, @matches;
1146 }
1147  
1148 ########################################################################
1149 0 ▶sub _cmd_generate_completion {
Subroutine _cmd_generate_completion: not called CC=4 SCAR=27.5
1150 ########################################################################
1151 0 my ( $class, $commands, $option_specs ) = @_;
1152  
1153 11 ▶ no strict 'refs'; ## no critic
Subroutine BEGIN: called CC=1 SCAR=0.0
1154 0 my $stash = \%{ $class . '::' };
1155  
1156 0 my $cmd_list = join q{ }, sort grep { !/^-/xsm } keys %{$commands};
1157  
1158 0 ▶ my $program = $ENV{MODULINO_WRAPPER} // do {
Condition0%0/3
$ENV{"MODULINO_WRAPPER"} // do { (my $name = $class) =~ s/::/-/gmsx; lc $name }
l!l&&r!l&&!r
000
MC/DC0%0/2
$ENV{"MODULINO_WRAPPER"} // do { (my $name = $class) =~ s/::/-/gmsx; lc $name }
$ENV{"MODULINO_WRAPPER"} do { (my $name = $class) =~ s/::/-/gmsx; lc $name }
Truth table0%0/3
A // B
A= $ENV{"MODULINO_WRAPPER"}B= do { (my $name = $class) =~ s/::/-/gmsx; lc $name }
ABresult
1X1
011
000
1159 0 ( my $name = $class ) =~ s/::/-/gxsm;
1160 0 lc $name;
1161 };
1162  
1163 0 my @flags;
1164 my @value_opts;
1165  
1166 0 for my $spec ( @{$option_specs} ) {
1167 0 my ($name) = $spec =~ /\A([\w-]+)/xsm;
1168 0 $name =~ s/_/-/gxsm;
1169  
1170 0 ▶ if ( $spec =~ /[=:]/xsm ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($spec =~ /[=:]/msx) { } 0 0 0
1171 0 push @value_opts, "--$name";
1172 }
1173 else {
1174 0 push @flags, "--$name";
1175 }
1176 }
1177  
1178 0 my $flags = join q{ }, sort @flags;
1179 0 my $value_opts = join q{ }, sort @value_opts;
1180  
1181 0 printf {*STDOUT} <<'END_COMPLETION', $program, $cmd_list, $value_opts, $flags, $program, $program;
1182 _%s() {
1183 local cur prev words cword
1184 _init_completion || return
1185  
1186 local commands="%s"
1187 local value_opts="%s"
1188 local flags="%s"
1189  
1190 if [[ $cword -eq 1 ]]; then
1191 if [[ "$cur" == --* ]]; then
1192 COMPREPLY=( $(compgen -W "$flags $value_opts" -- "$cur") )
1193 else
1194 COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
1195 fi
1196 return
1197 fi
1198  
1199 case $prev in
1200 $value_opts)
1201 COMPREPLY=( $(compgen -f -- "$cur") )
1202 return ;;
1203 esac
1204  
1205 COMPREPLY=( $(compgen -W "$flags $value_opts" -- "$cur") )
1206 }
1207  
1208 complete -F _%s %s
1209 END_COMPLETION
1210  
1211 0 return $SUCCESS;
1212 }
1213  
1214 ########################################################################
1215 11 ▶sub run {
Subroutine run: called CC=8 SCAR=27.7
Pod documented
1216 ########################################################################
1217 11 my ($self) = @_;
1218  
1219 11 my $command = $self->command;
1220  
1221 ######################################################################
1222 # a blank command means that we did not have a default && AUTO_HELP
1223 # is off scripter has deliberately decided to allow running of
1224 # init() phase w/o a run phase
1225 ######################################################################
1226  
1227 11 ▶ return $SUCCESS
Branch: 1 branch
BranchTrueFalseTotal
unless $command 0 11 11
1228 if !$command;
1229  
1230 11 my $commands = $self->commands;
1231  
1232 11 my $program = $self->program;
1233  
1234 11 my $handler = $commands->{$command};
1235  
1236 11 ▶ if ( $handler && !ref $handler ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($handler and not ref $handler) 0 11 11
Condition33%1/3
$handler and not ref $handler
!ll&&!rl&&r
0110
MC/DC0%0/2
$handler and not ref $handler
$handler not ref $handler
Truth table33%1/3
A and not(B)
A= $handlerB= not ref $handler
ABresult
0X0
100
111
1237 0 $handler = $commands->{$handler}; # default?
1238 }
1239  
1240 11 ▶ die "ERROR: no such command '$command' has been registered.\n"
Branch: 1 branch
BranchTrueFalseTotal
unless $handler 0 11 11
1241 if !$handler;
1242  
1243 11 ▶ if ( ref $handler ne 'ARRAY' ) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $handler ne "ARRAY") 11 0 11
1244 11 my $result = $handler->($self);
1245 11 return $result;
1246 }
1247  
1248 0 my ( $sub, $log_level ) = @{$handler};
1249  
1250 0 ▶ croak "ERROR: invalid specification for $command\n"
Branch: 1 branch
BranchTrueFalseTotal
if not ref $sub or builtin::reftype($sub) ne "CODE" 0 0 0
Condition0%0/3
not ref $sub or builtin::reftype($sub) ne "CODE"
l!l&&r!l&&!r
000
MC/DC0%0/2
not ref $sub or builtin::reftype($sub) ne "CODE"
not ref $sub builtin::reftype($sub) ne "CODE"
Truth table0%0/3
not(A) or B
A= not ref $subB= builtin::reftype($sub) ne "CODE"
ABresult
1X1
011
000
1251 if !ref $sub || reftype($sub) ne 'CODE';
1252  
1253 0 return $sub->($self);
1254 }
1255  
1256 11 1;
1257  
1258 ## no critic (RequirePodSections)
1259  
1260 __END__
↑ Summary Simple/Scaffold.pm »