blib/lib/App/Test/Generator/SchemaExtractor.pm

filter: Statementstmt 84.8% 2942 / 3467 Branchbran 75.5% 1788 / 2366 Conditioncond 64.3% 760 / 1182 MC/DCmcdc 43.8% 297 / 678 Subroutinesub 91.7% 134 / 146 Podpod 100% 3 / 3 totaltotal 75.5% 5924 / 7842 CC 1718 SCAR 43.5
CC
1718
Cov
78%
_parse_schema_hash
756.0
_analyze_pod
373.1
_analyze_output_from_pod
221.9
CRAP 77.5
« bin/fuzz-harness-generator ↑ Summary lib/App/Test/Generator/TestStrategy.pm »
1 package App::Test::Generator::SchemaExtractor;
2  
3 157 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 157 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 157 ▶use autodie qw(:all);
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 157 ▶use App::Test::Generator::Model::Method;
Subroutine BEGIN: called CC=1 SCAR=0.0
8 157 ▶use App::Test::Generator::Analyzer::Complexity;
Subroutine BEGIN: called CC=1 SCAR=0.0
9 157 ▶use App::Test::Generator::Analyzer::Return;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 157 ▶use App::Test::Generator::Analyzer::ReturnMeta;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 157 ▶use App::Test::Generator::Analyzer::SideEffect;
Subroutine BEGIN: called CC=1 SCAR=0.0
12 157 ▶use App::Test::Generator::Provenance qw(
Subroutine BEGIN: called CC=1 SCAR=0.0
13 SOURCE_VALIDATOR SOURCE_INPUT_SPEC SOURCE_POD
14 SOURCE_CODE SOURCE_SIGNATURE SOURCE_FIELD
15 157 );
16  
17 157 ▶use Carp qw(carp croak);
Subroutine BEGIN: called CC=1 SCAR=0.0
18 157 ▶use PPI;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 157 ▶use Pod::Simple::Text;
Subroutine BEGIN: called CC=1 SCAR=0.0
20 157 ▶use File::Basename;
Subroutine BEGIN: called CC=1 SCAR=0.0
21 157 ▶use File::Path qw(make_path);
Subroutine BEGIN: called CC=1 SCAR=0.0
22 157 ▶use Params::Get;
Subroutine BEGIN: called CC=1 SCAR=0.0
23 157 ▶use Safe;
Subroutine BEGIN: called CC=1 SCAR=0.0
24 157 ▶use Scalar::Util qw(looks_like_number refaddr);
Subroutine BEGIN: called CC=1 SCAR=0.0
25 157 ▶use YAML::XS;
Subroutine BEGIN: called CC=1 SCAR=0.0
26 157 ▶use IPC::Open3;
Subroutine BEGIN: called CC=1 SCAR=0.0
27 157 ▶use JSON::MaybeXS qw(encode_json decode_json);
Subroutine BEGIN: called CC=1 SCAR=0.0
28 157 ▶use Readonly;
Subroutine BEGIN: called CC=1 SCAR=0.0
29 157 ▶use Symbol qw(gensym);
Subroutine BEGIN: called CC=1 SCAR=0.0
30  
31 # --------------------------------------------------
32 # Confidence score thresholds for input and output analysis
33 # --------------------------------------------------
34 157 Readonly my $CONFIDENCE_HIGH_THRESHOLD => 60;
35 157 Readonly my $CONFIDENCE_MEDIUM_THRESHOLD => 35;
36 157 Readonly my $CONFIDENCE_LOW_THRESHOLD => 15;
37  
38 # --------------------------------------------------
39 # Confidence level label strings
40 # --------------------------------------------------
41 157 Readonly my $LEVEL_HIGH => 'high';
42 157 Readonly my $LEVEL_MEDIUM => 'medium';
43 157 Readonly my $LEVEL_LOW => 'low';
44 157 Readonly my $LEVEL_VERY_LOW => 'very_low';
45 157 Readonly my $LEVEL_NONE => 'none';
46  
47 # --------------------------------------------------
48 # Analysis limits
49 # --------------------------------------------------
50 157 Readonly my $DEFAULT_MAX_PARAMETERS => 20;
51 157 Readonly my $DEFAULT_CONFIDENCE_THRESH => 0.5;
52 157 Readonly my $POD_WALK_LIMIT => 200;
53 157 Readonly my $SIGNATURE_TIMEOUT_SECS => 3;
54 157 Readonly my $MEMORY_LIMIT_BYTES => 50_000_000;
55  
56 # --------------------------------------------------
57 # Patterns for rejecting dangerous signature expressions
58 # in _compile_signature_isolated
59 # --------------------------------------------------
60 157 Readonly my $UNSAFE_KEYWORD_RE => qr/\b(?:system|exec|open|fork|require|do|eval|qx)\b/;
61 157 Readonly my $UNSAFE_CHAR_RE => qr/[`{};]/;
62  
63 # --------------------------------------------------
64 # strict_pod levels — integer values stored internally
65 # but referred to by name everywhere in code
66 # --------------------------------------------------
67 157 Readonly my $STRICT_POD_OFF => 0;
68 157 Readonly my $STRICT_POD_WARN => 1;
69 157 Readonly my $STRICT_POD_FATAL => 2;
70  
71 # --------------------------------------------------
72 # Numeric boundary values for test hint generation
73 # --------------------------------------------------
74 157 Readonly my $INT32_MAX => 2_147_483_647;
75  
76 # --------------------------------------------------
77 # Boolean return score thresholds
78 # --------------------------------------------------
79 157 Readonly my $BOOLEAN_SCORE_THRESHOLD => 30;
80  
81 =head1 NAME
82  
83 App::Test::Generator::SchemaExtractor - Extract test schemas from Perl modules
84  
85 =head1 VERSION
86  
87 Version 0.49
88  
89 =cut
90  
91 157 our $VERSION = '0.49';
92  
93 =head1 SYNOPSIS
94  
95 use App::Test::Generator::SchemaExtractor;
96  
97 my $extractor = App::Test::Generator::SchemaExtractor->new(
98 input_file => 'lib/MyModule.pm',
99 output_dir => 'schemas/',
100 verbose => 1,
101 );
102  
103 my $schemas = $extractor->extract_all();
104  
105 =head1 DESCRIPTION
106  
107 App::Test::Generator::SchemaExtractor analyzes Perl modules and generates
108 structured YAML schema files suitable for automated test generation by L<App::Test::Generator>.
109 This module employs
110 static analysis techniques to infer parameter types, constraints, and
111 method behaviors directly from your source code.
112  
113 =head2 Analysis Methods
114  
115 The extractor combines multiple analysis approaches for a comprehensive schema generation:
116  
117 =over 4
118  
119 =item * B<POD Documentation Analysis>
120  
121 Parses embedded documentation to extract:
122 - Parameter names, types, and descriptions from =head2 sections
123 - Method signatures with positional parameters
124 - Return value specifications from "Returns:" sections
125 - Constraints (ranges, patterns, required/optional status)
126 - Semantic type detection (email, URL, filename)
127  
128 =item * B<Code Pattern Detection>
129  
130 Analyzes source code using PPI to identify:
131 - Method signatures and parameter extraction patterns
132 - Type validation (ref(), isa(), blessed())
133 - Constraint patterns (length checks, numeric comparisons, regex matches)
134 - Return statement analysis and value type inference
135 - Object instantiation requirements and accessor methods
136  
137 =item * B<Signature Analysis>
138  
139 Examines method declarations for:
140 - Parameter names and positional information
141 - Instance vs. class method detection
142 - Method modifiers (Moose-style before/after/around)
143 - Various parameter declaration styles (shift, @_ assignment)
144  
145 =item * B<Heuristic Inference>
146  
147 Applies Perl-specific domain knowledge:
148 - Boolean return detection from method names (is_*, has_*, can_*)
149 - Common Perl idioms and coding patterns
150 - Context awareness (scalar vs list, wantarray usage)
151 - Object-oriented patterns (constructors, accessors, chaining)
152  
153 =back
154  
155 =head2 Generated Schema Structure
156  
157 The extracted schemas follow this YAML structure:
158  
159 function: method_name
160 module: Package::Name
161 input:
162 param1:
163 type: string
164 min: 3
165 max: 50
166 optional: 0
167 position: 0
168 param2:
169 type: integer
170 min: 0
171 max: 100
172 optional: 1
173 position: 1
174 output:
175 type: boolean
176 value: 1
177 new: Package::Name # if object instantiation required
178 config:
179 test_empty: 1
180 test_nuls: 0
181 test_undef: 0
182 test_non_ascii: 0
183  
184 =head2 Advanced Detection Capabilities
185  
186 =over 4
187  
188 =item * B<Accessor Method Detection>
189  
190 Automatically identifies getter, setter, and combined accessor methods
191 by analyzing common patterns like C<return $self-E<gt>{property}> and
192 C<$self-E<gt>{property} = $value>.
193  
194 =item * B<Params::Get Integration>
195  
196 Recognises parameters extracted via C<Params::Get::get_params('key', \@_)>,
197 treating the quoted key as a named parameter equivalent to a traditional
198 C<my ($self, $key) = @_> signature. This prevents false positives from
199 C<--strict-pod> when the method body never declares an explicit C<$key>
200 variable.
201  
202 =item * B<Direct-Index Self Style>
203  
204 Recognises C<my $self = $_[0]> as a valid method-invocant pattern. Parameters
205 at C<$_[1]>, C<$_[2]>, etc. are extracted as positional parameters. Without
206 this, the signature fallback would incorrectly pick up C<my (...) = @_> from
207 inner closures defined in the method body and treat those variables as the
208 outer method's parameters.
209  
210 =item * B<Boolean Return Inference>
211  
212 Detects boolean-returning methods through multiple signals:
213 - Method name patterns (is_*, has_*, can_*)
214 - Return patterns (consistent 1/0 returns)
215 - POD descriptions ("returns true on success")
216 - Ternary operators with boolean results
217  
218 =item * B<Context Awareness>
219  
220 Identifies methods that use C<wantarray> and can return different
221 values in scalar vs list context.
222  
223 =item * B<Object Lifecycle Management>
224  
225 Detects instance methods requiring object instantiation and
226 automatically adds the C<new> field to schemas.
227  
228 =item * B<Enhanced Object Detection>
229  
230 The extractor includes sophisticated object detection capabilities that go beyond simple instance method identification:
231  
232 =over 4
233  
234 =item * B<Factory Method Recognition>
235  
236 Automatically identifies methods that create and return object instances, such as methods named C<create_*>, C<make_*>, C<build_*>, or C<get_*>. Factory methods are correctly classified as class methods that don't require pre-existing objects for testing.
237  
238 =item * B<Singleton Pattern Detection>
239  
240 Recognizes singleton patterns through multiple signals: method names like C<instance> or C<get_instance>, static variables holding instance references, lazy initialization patterns (C<$instance ||= new()>), and consistent return of the same instance variable.
241  
242 =item * B<Constructor Parameter Analysis>
243  
244 Examines C<new> methods to determine required and optional parameters, validation requirements, and default values. This enables test generators to provide appropriate constructor arguments when object instantiation is needed.
245  
246 =item * B<Inheritance Relationship Handling>
247  
248 Detects parent classes through C<use parent>, C<use base>, and C<@ISA> declarations. Identifies when methods use C<SUPER::> calls and determines whether the current class or a parent class constructor should be used for object instantiation.
249  
250 =item * B<External Object Dependency Detection>
251  
252 Identifies when methods create or depend on objects from other classes, enabling proper test setup with mock objects or real dependencies.
253  
254 =back
255  
256 These enhancements ensure that generated test schemas accurately reflect the object-oriented structure of the code, leading to more meaningful and effective test generation.
257  
258 =back
259  
260 =head2 Confidence Scoring
261  
262 Each generated schema includes detailed confidence assessments:
263  
264 =over 4
265  
266 =item * B<High Confidence>
267  
268 Multiple independent analysis sources converge on consistent,
269 well-constrained parameters with explicit validation logic and
270 comprehensive documentation.
271  
272 =item * B<Medium Confidence>
273  
274 Reasonable evidence from code patterns or partial documentation,
275 but may lack comprehensive constraints or have some ambiguities.
276  
277 =item * B<Low Confidence>
278  
279 Minimal evidence - primarily based on naming conventions,
280 default assumptions, or single-source analysis.
281  
282 =item * B<Very Low Confidence>
283  
284 Barely any detectable signals - schema should be thoroughly
285 reviewed before use in test generation.
286  
287 =back
288  
289 =head2 Use Cases
290  
291 =over 4
292  
293 =item * B<Automated Test Generation>
294  
295 Generate comprehensive test suites with L<App::Test::Generator> using
296 extracted schemas as input. The schemas provide the necessary structure
297 for generating both positive and negative test cases.
298  
299 =item * B<API Documentation Generation>
300  
301 Supplement existing documentation with automatically inferred interface
302 specifications, parameter requirements, and return types.
303  
304 =item * B<Code Quality Assessment>
305  
306 Identify methods with poor documentation, inconsistent parameter handling,
307 or unclear interfaces that may benefit from refactoring.
308  
309 =item * B<Refactoring Assistance>
310  
311 Detect method dependencies, object instantiation requirements, and
312 parameter usage patterns to inform refactoring decisions.
313  
314 =item * B<Legacy Code Analysis>
315  
316 Quickly understand the interface contracts of legacy Perl codebases
317 without extensive manual code reading.
318  
319 =back
320  
321 =head2 Integration with Testing Ecosystem
322  
323 The generated schemas are specifically designed to work with the
324 L<App::Test::Generator> ecosystem:
325  
326 # Extract schemas from your module
327 my $extractor = App::Test::Generator::SchemaExtractor->new(...);
328 my $schemas = $extractor->extract_all();
329  
330 # Use with test generator (typically as separate steps)
331 # fuzz-harness-generator -r schemas/method_name.yml
332  
333 =head2 Limitations and Considerations
334  
335 =over 4
336  
337 =item * B<Dynamic Code Patterns>
338  
339 Highly dynamic code (string evals, AUTOLOAD, symbolic references)
340 may not be fully detected by static analysis.
341  
342 =item * B<Complex Validation Logic>
343  
344 Sophisticated validation involving multiple parameters or external
345 dependencies may require manual schema refinement.
346  
347 =item * B<Confidence Heuristics>
348  
349 Confidence scores are based on heuristics and should be reviewed
350 by developers familiar with the codebase.
351  
352 =item * B<Perl Idiom Recognition>
353  
354 Some Perl-specific idioms may require custom pattern recognition
355 beyond the built-in detectors.
356  
357 =item * B<Documentation Dependency>
358  
359 Analysis quality improves significantly with comprehensive POD
360 documentation following consistent patterns.
361  
362 =back
363  
364 =head2 Best Practices for Optimal Results
365  
366 =over 4
367  
368 =item * B<Comprehensive POD Documentation>
369  
370 Write detailed POD with explicit parameter documentation using
371 consistent patterns like C<$param - type (constraints), description>.
372  
373 =item * B<Consistent Coding Patterns>
374  
375 Use consistent parameter validation patterns and method signatures
376 throughout your codebase.
377  
378 =item * B<Schema Review Process>
379  
380 Review and refine automatically generated schemas, particularly
381 those with low confidence scores.
382  
383 =item * B<Descriptive Naming>
384  
385 Use descriptive method and parameter names that clearly indicate
386 purpose and expected types.
387  
388 =item * B<Progressive Enhancement>
389  
390 Start with automatically generated schemas and progressively
391 refine them based on test results and code understanding.
392  
393 =back
394  
395 The module is particularly valuable for large codebases where manual schema
396 creation would be prohibitively time-consuming, and for maintaining test
397 coverage as code evolves through continuous integration pipelines.
398  
399 =head2 Advanced Type Detection
400  
401 The schema extractor includes enhanced type detection capabilities that identify specialized Perl types beyond basic strings and integers.
402 L<DateTime> and L<Time::Piece> objects are detected through isa() checks and method call patterns, while date strings (ISO 8601, YYYY-MM-DD) and UNIX timestamps are recognized through regex validation and numeric range checks.
403 File handles and file paths are identified via I/O operations and file test operators, coderefs are detected through ref() checks and invocation patterns, and enum-like parameters are extracted from validation code including regex patterns (C</^(a|b|c)$/>), hash lookups, grep statements, and if/elsif chains.
404 These detected types are preserved in the generated YAML schemas with appropriate semantic annotations, enabling test generators to create more accurate and meaningful test cases.
405  
406 =head3 Example Advanced Type Schema
407  
408 For a method like:
409  
410 sub process_event {
411 my ($self, $timestamp, $status, $callback) = @_;
412 croak unless $timestamp > 1000000000;
413 croak unless $status =~ /^(active|pending|complete)$/;
414 croak unless ref($callback) eq 'CODE';
415 $callback->($timestamp, $status);
416 }
417  
418 The extractor generates:
419  
420 ---
421 function: process_event
422 module: MyModule
423 input:
424 timestamp:
425 type: integer
426 # min: 0
427 # max: 2147483647
428 position: 0
429 _note: Unix timestamp
430 semantic: unix_timestamp
431 status:
432 type: string
433 enum:
434 - active
435 - pending
436 - complete
437 position: 1
438 _note: 'Must be one of: active, pending, complete'
439 callback:
440 type: coderef
441 position: 2
442 _note: 'CODE reference - provide sub { } in tests'
443  
444 =head1 RELATIONSHIP DETECTION
445  
446 The schema extractor detects relationships and dependencies between parameters,
447 enabling more sophisticated validation and test generation.
448  
449 =head2 Relationship Types
450  
451 =over 4
452  
453 =item * B<mutually_exclusive>
454  
455 Parameters that cannot be used together.
456  
457 die if $file && $content; # Can't specify both
458  
459 Generated schema:
460  
461 relationships:
462 - type: mutually_exclusive
463 params: [file, content]
464 description: Cannot specify both file and content
465  
466 =item * B<required_group>
467  
468 At least one parameter from the group must be specified (OR logic).
469  
470 die unless $id || $name; # Must provide one
471  
472 Generated schema:
473  
474 relationships:
475 - type: required_group
476 params: [id, name]
477 logic: or
478 description: Must specify either id or name
479  
480 =item * B<conditional_requirement>
481  
482 If one parameter is specified, another becomes required (IF-THEN logic).
483  
484 die if $async && !$callback; # async requires callback
485  
486 Generated schema:
487  
488 relationships:
489 - type: conditional_requirement
490 if: async
491 then_required: callback
492 description: When async is specified, callback is required
493  
494 =item * B<dependency>
495  
496 One parameter depends on another being present.
497  
498 die "Port requires host" if $port && !$host;
499  
500 Generated schema:
501  
502 relationships:
503 - type: dependency
504 param: port
505 requires: host
506 description: port requires host to be specified
507  
508 =item * B<value_constraint>
509  
510 Specific value requirements between parameters.
511  
512 die if $ssl && $port != 443; # ssl requires port 443
513  
514 Generated schema:
515  
516 relationships:
517 - type: value_constraint
518 if: ssl
519 then: port
520 operator: ==
521 value: 443
522 description: When ssl is specified, port must equal 443
523  
524 =item * B<value_conditional>
525  
526 Parameter required when another has a specific value.
527  
528 die if $mode eq 'secure' && !$key;
529  
530 Generated schema:
531  
532 relationships:
533 - type: value_conditional
534 if: mode
535 equals: secure
536 then_required: key
537 description: When mode equals 'secure', key is required
538  
539 =back
540  
541 =head2 Default Value Extraction
542  
543 The extractor comprehensively extracts default values from both code and POD documentation:
544  
545 =head3 Code Pattern Recognition
546  
547 Extracts defaults from multiple Perl idioms:
548  
549 =over 4
550  
551 =item * Logical OR operator: C<$param = $param || 'default'>
552  
553 =item * Defined-or operator: C<$param //= 'default'>
554  
555 =item * Ternary operator: C<$param = defined $param ? $param : 'default'>
556  
557 =item * Unless conditional: C<$param = 'default' unless defined $param>
558  
559 =item * Chained defaults: C<$param = $param || $self->{_default} || 'fallback'>
560  
561 =item * Multi-line patterns: C<$param = {} unless $param>
562  
563 =back
564  
565 =head3 POD Pattern Recognition
566  
567 Extracts defaults from documentation:
568  
569 =over 4
570  
571 =item * Standard format: C<Default: 'value'>
572  
573 =item * Alternative format: C<Defaults to: 'value'>
574  
575 =item * Inline format: C<Optional, default: 'value'>
576  
577 =item * Parameter lists: C<$param - type, default 'value'>
578  
579 =back
580  
581 =head3 Value Processing
582  
583 Properly handles:
584  
585 =over 4
586  
587 =item * String literals with quotes and escape sequences
588  
589 =item * Numeric values (integers and floats)
590  
591 =item * Boolean values (true/false converted to 1/0)
592  
593 =item * Empty data structures ([] and {})
594  
595 =item * Special values (undef, __PACKAGE__)
596  
597 =item * Complex expressions (preserved as-is when unevaluatable)
598  
599 =item * Quote operators (q{}, qq{}, qw{})
600  
601 =back
602  
603 =head3 Type Inference
604  
605 When a parameter has a default value but no explicit type annotation,
606 the type is automatically inferred from the default:
607  
608 $options = {} # inferred as hashref
609 $items = [] # inferred as arrayref
610 $count = 42 # inferred as integer
611 $ratio = 3.14 # inferred as number
612 $enabled = 1 # inferred as boolean
613  
614 =head2 Context-Aware Return Analysis
615  
616 The extractor provides comprehensive analysis of method return behavior,
617 including context sensitivity, error handling conventions, and method chaining patterns.
618  
619 When a method's POD contains a C<=head4 Output> block in
620 L<Params::Validate::Strict> schema format, the C<type> declared there is
621 used as the authoritative output type and takes precedence over all
622 heuristic code analysis:
623  
624 =head4 Output
625  
626 {
627 type => 'hashref',
628 }
629  
630 This is the recommended way to document methods whose return type would
631 otherwise be misidentified (e.g. a method that returns C<$self-E<gt>{cache}>
632 where the cache happens to hold a hashref).
633  
634 Using parentheses as the outer container emits C<type: array>, indicating a
635 list-returning method. L<App::Test::Generator> 0.39+ (with L<Test::Returns>
636 0.03+) captures these results in list context automatically:
637  
638 =head4 Output
639  
640 (
641 {
642 type => 'hashref',
643 },
644 ...
645 )
646  
647 =head3 List vs Scalar Context Detection
648  
649 Automatically detects methods that return different values based on calling context:
650  
651 sub get_items {
652 my $self = $_[0];
653 return wantarray ? @items : scalar(@items);
654 }
655  
656 Detection captures:
657  
658 =over 4
659  
660 =item * C<_context_aware> flag - Method uses wantarray
661  
662 =item * C<_list_context> - Type returned in list context (e.g., 'array')
663  
664 =item * C<_scalar_context> - Type returned in scalar context (e.g., 'integer')
665  
666 =back
667  
668 Recognizes both ternary operator patterns and conditional return patterns.
669  
670 =head3 Void Context Methods
671  
672 Identifies methods that don't return meaningful values:
673  
674 =over 4
675  
676 =item * Setters (C<set_*> methods)
677  
678 =item * Mutators (C<add_*, remove_*, delete_*, clear_*, reset_*, update_*>)
679  
680 =item * Loggers (C<log, debug, warn, error, info>)
681  
682 =item * Methods with only empty returns
683  
684 =back
685  
686 Example:
687  
688 sub set_name {
689 my ($self, $name) = @_;
690 $self->{name} = $name;
691 return; # Void context
692 }
693  
694 Sets C<_void_context> flag and C<type =E<gt> 'void'>.
695  
696 =head3 Method Chaining Detection
697  
698 Identifies chainable methods that return C<$self> for fluent interfaces:
699  
700 sub set_width {
701 my ($self, $width) = @_;
702 $self->{width} = $width;
703 return $self; # Chainable
704 }
705  
706 Detection provides:
707  
708 =over 4
709  
710 =item * C<_returns_self> - Returns invocant for chaining
711  
712 =item * C<class> - The class name being returned
713  
714 =back
715  
716 Also detects chaining documentation in POD (keywords: "chainable", "fluent interface",
717 "returns self", "method chaining").
718  
719 =head3 Error Return Conventions
720  
721 Analyzes how methods signal errors:
722  
723 B<Pattern Detection:>
724  
725 =over 4
726  
727 =item * C<undef_on_error> - Explicit C<return undef if/unless condition>
728  
729 =item * C<implicit_undef> - Bare C<return if/unless condition>
730  
731 =item * C<empty_list> - C<return ()> for list context errors
732  
733 =item * C<zero_on_error> - Returns 0/false for boolean error indication
734  
735 =item * C<exception_handling> - Uses eval blocks with error checking
736  
737 =back
738  
739 B<Example Analysis:>
740  
741 sub fetch_user {
742 my ($self, $id) = @_;
743  
744 return undef unless $id; # undef_on_error
745 return undef if $id < 0; # undef_on_error
746  
747 return $self->{users}{$id};
748 }
749  
750 Results in:
751  
752 _error_return: 'undef'
753 _success_failure_pattern: 1
754 _error_handling: {
755 undef_on_error: ['$id', '$id < 0']
756 }
757  
758 B<Success/Failure Pattern:>
759  
760 Methods that return different types for success vs. failure are flagged with
761 C<_success_failure_pattern>. Common patterns:
762  
763 =over 4
764  
765 =item * Returns value on success, undef on failure
766  
767 =item * Returns true on success, false on failure
768  
769 =item * Returns data on success, empty list on failure
770  
771 =back
772  
773 =head3 Success Indicator Detection
774  
775 Methods that always return true (typically for side effects):
776  
777 sub update_status {
778 my ($self, $status) = @_;
779 $self->{status} = $status;
780 return 1; # Success indicator
781 }
782  
783 Sets C<_success_indicator> flag when method consistently returns 1.
784  
785 =head3 Schema Output
786  
787 Enhanced return analysis adds these fields to method schemas:
788  
789 output:
790 type: boolean # Inferred return type
791 _context_aware: 1 # Uses wantarray
792 _list_context:
793 type: array
794 _scalar_context:
795 type: integer
796 _returns_self: 1 # Returns $self
797 _void_context: 1 # No meaningful return
798 _success_indicator: 1 # Always returns true
799 _error_return: undef # How errors are signaled
800 _success_failure_pattern: 1 # Mixed return types
801 _error_handling: # Detailed error patterns
802 undef_on_error: [...]
803 exception_handling: 1
804  
805 This comprehensive analysis enables:
806  
807 =over 4
808  
809 =item * Better test generation (testing both contexts, error paths)
810  
811 =item * Documentation generation (clear error conventions)
812  
813 =item * API design validation (consistent error handling)
814  
815 =item * Contract specification (precise return behavior)
816  
817 =back
818  
819 =head2 Example
820  
821 For a method like:
822  
823 sub connect {
824 my ($self, $host, $port, $ssl, $file, $content) = @_;
825  
826 die if $file && $content; # mutually exclusive
827 die unless $host || $file; # required group
828 die "Port requires host" if $port && !$host; # dependency
829 die if $ssl && $port != 443; # value constraint
830  
831 # ... connection logic
832 }
833  
834 The extractor generates:
835  
836 relationships:
837 - type: mutually_exclusive
838 params: [file, content]
839 description: Cannot specify both file and content
840 - type: required_group
841 params: [host, file]
842 logic: or
843 description: Must specify either host or file
844 - type: dependency
845 param: port
846 requires: host
847 description: port requires host to be specified
848 - type: value_constraint
849 if: ssl
850 then: port
851 operator: ==
852 value: 443
853 description: When ssl is specified, port must equal 443
854  
855 =head1 MODERN PERL FEATURES
856  
857 This module adds support for:
858  
859 =head2 Subroutine Signatures (Perl 5.20+)
860  
861 sub connect($host, $port = 3306, %options) {
862 ...
863 }
864  
865 Extracts: required params, optional params with defaults, slurpy params
866  
867 =head2 Type Constraints (Perl 5.36+)
868  
869 sub calculate($x :Int, $y :Num) {
870 ...
871 }
872  
873 Recognizes: Int, Num, Str, Bool, ArrayRef, HashRef, custom classes
874  
875 =head3 Subroutine Attributes
876  
877 sub get_value :lvalue :Returns(Int) {
878 ...
879 }
880  
881 Detects: :lvalue, :method, :Returns(Type), custom attributes
882  
883 =head2 Postfix Dereferencing (Perl 5.20+)
884  
885 my @array = $arrayref->@*;
886 my %hash = $hashref->%*;
887 my @slice = $arrayref->@[1,3,5];
888  
889 Tracks usage of modern dereferencing syntax
890  
891 =head2 Field Declarations (Perl 5.38+)
892  
893 field $host :param = 'localhost';
894 field $port :param(port_number) = 3306;
895 field $logger :param :isa(Log::Any);
896  
897 Extracts fields and maps them to parameters
898  
899 =head2 Modern Perl Features Support
900  
901 The schema extractor supports modern Perl syntax introduced in versions 5.20, 5.36, and 5.38+.
902  
903 =head3 Subroutine Signatures (Perl 5.20+)
904  
905 Automatically extracts parameters from native Perl signatures:
906  
907 use feature 'signatures';
908  
909 sub connect($host, $port = 3306, $database = undef) {
910 ...
911 }
912  
913 Extracted schema includes:
914  
915 =over 4
916  
917 =item * Parameter positions
918  
919 =item * Optional vs required parameters
920  
921 =item * Default values from signature
922  
923 =item * Slurpy parameters (@array, %hash)
924  
925 =back
926  
927 B<Example:>
928  
929 # Signature with defaults
930 sub process($file, %options) { ... }
931  
932 # Extracts:
933 # $file: position 0, required
934 # %options: position 1, optional, slurpy hash
935  
936 =head3 Type Constraints in Signatures (Perl 5.36+)
937  
938 Recognizes type constraints in signature parameters:
939  
940 sub calculate($x :Int, $y :Num, $name :Str = "result") {
941 return $x + $y;
942 }
943  
944 Supported constraint types:
945  
946 =over 4
947  
948 =item * C<:Int, :Integer> -> integer
949  
950 =item * C<:Num, :Number> -> number
951  
952 =item * C<:Str, :String> -> string
953  
954 =item * C<:Bool, :Boolean> -> boolean
955  
956 =item * C<:ArrayRef, :Array> -> arrayref
957  
958 =item * C<:HashRef, :Hash> -> hashref
959  
960 =item * C<:ClassName> -> object with isa constraint
961  
962 =back
963  
964 Type constraints are combined with defaults when both are present.
965  
966 =head3 Subroutine Attributes
967  
968 Extracts and documents subroutine attributes:
969  
970 sub get_value :lvalue {
971 my $self = shift;
972 return $self->{value};
973 }
974  
975 sub calculate :Returns(Int) :method {
976 my ($self, $x, $y) = @_;
977 return $x + $y;
978 }
979  
980 Recognized attributes stored in C<_attributes> field:
981  
982 =over 4
983  
984 =item * C<:lvalue> - Method can be assigned to
985  
986 =item * C<:method> - Explicitly marked as method
987  
988 =item * C<:Returns(Type)> - Declares return type
989  
990 =item * Custom attributes with values: C<:MyAttr(value)>
991  
992 =back
993  
994 =head3 Postfix Dereferencing (Perl 5.20+)
995  
996 Detects usage of postfix dereferencing syntax:
997  
998 use feature 'postderef';
999  
1000 sub process_array {
1001 my ($self, $arrayref) = @_;
1002 my @array = $arrayref->@*; # Array dereference
1003 my @slice = $arrayref->@[1,3,5]; # Array slice
1004 return @array;
1005 }
1006  
1007 sub process_hash {
1008 my ($self, $hashref) = @_;
1009 my %hash = $hashref->%*; # Hash dereference
1010 return keys %hash;
1011 }
1012  
1013 Tracked features stored in C<_modern_features>:
1014  
1015 =over 4
1016  
1017 =item * C<array_deref> - Uses C<-E<gt>@*>
1018  
1019 =item * C<hash_deref> - Uses C<-E<gt>%*>
1020  
1021 =item * C<scalar_deref> - Uses C<-E<gt>$*>
1022  
1023 =item * C<code_deref> - Uses C<-E<gt>&*>
1024  
1025 =item * C<array_slice> - Uses C<-E<gt>@[...]>
1026  
1027 =item * C<hash_slice> - Uses C<-E<gt>%{...}>
1028  
1029 =back
1030  
1031 =head3 Field Declarations (Perl 5.38+)
1032  
1033 Extracts field declarations from class syntax and maps them to method parameters:
1034  
1035 use feature 'class';
1036  
1037 class DatabaseConnection {
1038 field $host :param = 'localhost';
1039 field $port :param = 3306;
1040 field $username :param(user);
1041 field $password :param;
1042 field $logger :param :isa(Log::Any);
1043  
1044 method connect() {
1045 # Fields available as instance variables
1046 }
1047 }
1048  
1049 Field attributes:
1050  
1051 =over 4
1052  
1053 =item * C<:param> - Field is a constructor parameter (uses field name)
1054  
1055 =item * C<:param(name)> - Field maps to parameter with different name
1056  
1057 =item * C<:isa(Class)> - Type constraint for the field
1058  
1059 =item * Default values in field declarations
1060  
1061 =back
1062  
1063 Extracted schema includes both field information in C<_fields> and merged parameter
1064 information in C<input>, allowing proper validation of class constructors.
1065  
1066 =head3 Mixed Modern and Traditional Syntax
1067  
1068 The extractor handles code that mixes modern and traditional syntax:
1069  
1070 sub modern($x, $y = 5) {
1071 # Modern signature with default
1072 }
1073  
1074 sub traditional {
1075 my ($self, $x, $y) = @_;
1076 $y //= 5; # Traditional default in code
1077 # Both extract same parameter information
1078 }
1079  
1080 Priority order for parameter information:
1081  
1082 =over 4
1083  
1084 =item 1. Signature declarations (highest priority)
1085  
1086 =item 2. Field declarations (for class methods)
1087  
1088 =item 3. POD documentation
1089  
1090 =item 4. Code analysis (lowest priority)
1091  
1092 =back
1093  
1094 This ensures that explicit declarations in signatures take precedence over
1095 inferred information from code analysis.
1096  
1097 =head3 Backwards Compatibility
1098  
1099 All modern Perl feature detection is optional and automatic:
1100  
1101 =over 4
1102  
1103 =item * Traditional C<sub> declarations continue to work
1104  
1105 =item * Code without modern features extracts parameters as before
1106  
1107 =item * Modern features are additive - they enhance rather than replace existing extraction
1108  
1109 =item * Each parameter carries one C<_source> value -- C<validator>, C<input_spec>, C<pod>, C<code>, C<signature> or C<field> -- which the harness uses for its type-checking decisions
1110  
1111 =item * Each constraint that can come from more than one place also carries its own provenance in C<_constraint_source>, a hashref keyed by C<min>, C<max>, C<memberof>, C<matches>, C<nomatch> and C<notmemberof>. A minimum documented in POD and a maximum enforced by the code on the same field therefore stay separate decisions: the documented one is a hint for valid data, the enforced one is a check
1112  
1113 =back
1114  
1115 =head2 _yamltest_hints
1116  
1117 Each method schema returned by L</extract_all> now optionally includes a
1118 C<_yamltest_hints> key, which provides guidance for automated test generation
1119 based on the code analysis.
1120  
1121 This is intended to help L<App::Test::Generator> create meaningful tests,
1122 including boundary and invalid input cases, without manually specifying them.
1123  
1124 The structure is a hashref with the following keys:
1125  
1126 =over 4
1127  
1128 =item * boundary_values
1129  
1130 An arrayref of numeric values that represent boundaries detected from
1131 comparisons in the code. These are derived from literals in statements
1132 like C<$x < 0> or C<$y >= 255>. The generator can use these to create
1133 boundary tests.
1134  
1135 Example:
1136  
1137 _yamltest_hints:
1138 boundary_values: [0, 1, 100, 255]
1139  
1140 =item * invalid_inputs
1141  
1142 An arrayref of values that are likely to be rejected by the method,
1143 based on checks like C<defined>, empty strings, or numeric validations.
1144  
1145 Example:
1146  
1147 _yamltest_hints:
1148 invalid_inputs: [undef, '', -1]
1149  
1150 =item * equivalence_classes
1151  
1152 An arrayref intended to capture detected equivalence classes or patterns
1153 among inputs. Currently this is empty by default, but future enhancements
1154 may populate it based on detected input groupings.
1155  
1156 Example:
1157  
1158 _yamltest_hints:
1159 equivalence_classes: []
1160  
1161 =back
1162  
1163 =head3 Usage
1164  
1165 When calling C<extract_all>, each method schema will include
1166 C<_yamltest_hints> if any hints were detected:
1167  
1168 my $schemas = $extractor->extract_all;
1169 my $hints = $schemas->{example_method}->{_yamltest_hints};
1170  
1171 You can then feed these hints into automated test generators to produce
1172 negative tests, boundary tests, and parameter-specific test cases.
1173  
1174 =head3 Notes
1175  
1176 =over 4
1177  
1178 =item * Hints are inferred heuristically from code and validation statements.
1179  
1180 =item * Not all inputs are guaranteed to be detected; the feature is additive
1181 and will never remove information from the schema.
1182  
1183 =item * Currently, equivalence classes are not populated, but the field exists
1184 for future extension.
1185  
1186 =item * Boundary and invalid input hints are deduplicated to avoid repeated
1187 test values.
1188  
1189 =back
1190  
1191 =head3 Examples
1192  
1193 Given a method like:
1194  
1195 sub example {
1196 my ($x) = @_;
1197 die "negative" if $x < 0;
1198 return unless defined($x);
1199 return $x * 2;
1200 }
1201  
1202 After running:
1203  
1204 my $extractor = App::Test::Generator::SchemaExtractor->new(
1205 input_file => 'TestHints.pm',
1206 output_dir => '/tmp',
1207 quiet => 1,
1208 );
1209  
1210 my $schemas = $extractor->extract_all;
1211  
1212 The schema for the method "example" will include:
1213  
1214 $schemas->{example} = {
1215 function => 'example',
1216 _confidence => {
1217 input => 'unknown',
1218 output => 'unknown',
1219 },
1220 input => {
1221 x => {
1222 type => 'scalar',
1223 optional => 0,
1224 }
1225 },
1226 output => {
1227 type => 'scalar',
1228 },
1229 _yamltest_hints => {
1230 boundary_values => [0, 1],
1231 invalid_inputs => [undef, -1],
1232 equivalence_classes => [],
1233 },
1234 _notes => '...',
1235 _analysis => {
1236 input_confidence => 'low',
1237 output_confidence => 'unknown',
1238 confidence_factors => {
1239 input => {...},
1240 output => {...},
1241 },
1242 overall_confidence => 'low',
1243 },
1244 _fields => {},
1245 _modern_features => {},
1246 _attributes => {},
1247 };
1248  
1249 =head1 METHODS
1250  
1251 =head2 new
1252  
1253 Construct a new SchemaExtractor for a given Perl source file.
1254  
1255 my $extractor = App::Test::Generator::SchemaExtractor->new(
1256 input_file => 'lib/MyModule.pm', # Required
1257 output_dir => 'schemas/', # Optional - only needed if writing schemas
1258 verbose => 1, # Default: 0
1259 include_private => 1, # Default: 0
1260 max_parameters => 50, # Default: 20
1261 confidence_threshold => 0.7, # Default: 0.5
1262 strict_pod => 0|1|2, # Default: 0 (off)
1263 allow_signature_exec => 1, # Default: 0 (off)
1264 );
1265  
1266 =head3 Arguments
1267  
1268 =over 4
1269  
1270 =item * C<$input_file>
1271  
1272 Path to the Perl source file to analyse. Required. Must exist on disk.
1273  
1274 =item * C<output_dir>
1275  
1276 Directory to write generated schema YAML files. Optional - only
1277 required if C<_write_schema> will be called. Callers passing
1278 C<no_write =E<gt> 1> to C<extract_all> do not need to supply it.
1279  
1280 =item * C<verbose>
1281  
1282 Print progress messages to stdout during analysis. Optional, default 0.
1283  
1284 =item * C<include_private>
1285  
1286 Include methods whose names begin with C<_> in the analysis. Optional,
1287 default 0. Methods whose name begins with C<_new>, C<_init>, or
1288 C<_build> are always included regardless of this setting (a prefix
1289 match, so e.g. C<_build_attribute> and C<_init_logger> qualify too,
1290 matching common Moose builder/initializer naming conventions).
1291  
1292 =item * C<max_parameters>
1293  
1294 Safety limit on the number of parameters analysed per method to prevent
1295 runaway processing on pathological code. Optional, default 20.
1296  
1297 =item * C<confidence_threshold>
1298  
1299 Minimum confidence score (0.0-1.0) below which a schema is marked with
1300 C<_low_confidence =E<gt> 1>. Optional, default 0.5.
1301  
1302 =item * C<strict_pod>
1303  
1304 Controls POD/code agreement validation. C<0> disables validation,
1305 C<1> emits warnings, C<2> croaks on first disagreement. Also accepts
1306 the strings C<off>, C<warn>, and C<fatal>. Optional, default 0.
1307  
1308 =item * C<allow_signature_exec>
1309  
1310 Opt-in flag allowing extraction of parameter types from a
1311 L<Type::Params> C<signature_for()> declaration. This requires actually
1312 running the C<signature_for> expression (sliced from the target
1313 module's own source) in a forked C<perl -T> process, since
1314 L<Type::Params> types are runtime objects that cannot be introspected
1315 statically. Every other extraction path in this module is static
1316 (L<PPI>-only) analysis that never executes any of the target module's
1317 code; this is the one exception. Optional, default 0 (the
1318 C<signature_for> path is silently skipped, with a warning under
1319 C<verbose>, when off). Only enable this for modules whose code you
1320 already trust enough to execute.
1321  
1322 =back
1323  
1324 =head3 Returns
1325  
1326 A blessed hashref. Croaks if C<input_file> is missing or does not
1327 exist on disk.
1328  
1329 =head3 Side effects
1330  
1331 Reads and parses the input file using L<PPI> at construction time.
1332  
1333 =head3 API specification
1334  
1335 =head4 input
1336  
1337 {
1338 input_file => { type => SCALAR },
1339 output_dir => { type => SCALAR, optional => 1 },
1340 verbose => { type => SCALAR, optional => 1 },
1341 include_private => { type => SCALAR, optional => 1 },
1342 max_parameters => { type => SCALAR, optional => 1 },
1343 confidence_threshold => { type => SCALAR, optional => 1 },
1344 strict_pod => { type => SCALAR, optional => 1 },
1345 allow_signature_exec => { type => SCALAR, optional => 1 },
1346 }
1347  
1348 =head4 output
1349  
1350 {
1351 type => OBJECT,
1352 isa => 'App::Test::Generator::SchemaExtractor',
1353 }
1354  
1355 =cut
1356  
1357 1140 ▶sub new {
Subroutine new: called CC=9 SCAR=22.0
Pod documented
1358 1140 my $class = shift;
1359  
1360 # Handle hash or hashref arguments
1361 1140 ▶ my $params = Params::Get::get_params('input_file', @_) || {};
Condition50%1/2
Params::Get::get_params('input_file', @_) || {}
l!l
11380
MC/DC0%0/1
Params::Get::get_params('input_file', @_) || {}
Params::Get::get_params('input_file', @_)
Truth table50%1/2
A
A= Params::Get::get_params('input_file', @_)
Aresult
11
00
1362  
1363 1138 ▶ croak(__PACKAGE__, ': input_file required') unless exists $params->{input_file};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{"input_file"} 0 1138 1138
1364  
1365 my $self = {
1366 input_file => $params->{input_file},
1367 # output_dir is optional — only required if _write_schema will be called.
1368 # Callers using extract_all(no_write => 1) do not need to supply it.
1369 output_dir => $params->{output_dir},
1370 verbose => $params->{verbose} // 0,
1371 include_private => $params->{include_private} // 0, # include _private methods
1372 confidence_threshold => $params->{confidence_threshold} // $DEFAULT_CONFIDENCE_THRESH,
1373 max_parameters => $params->{max_parameters} // $DEFAULT_MAX_PARAMETERS, # safety limit
1374 strict_pod => _validate_strictness_level($params->{strict_pod}), # Enable strict POD checking
1375 1138 ▶ allow_signature_exec => $params->{allow_signature_exec} // 0, # opt-in: execute Type::Params signature_for() exprs from the target module
Condition100%12/12
$params->{"verbose"} // 0
l!l
341797
$params->{"include_private"} // 0
l!l
1321006
$params->{"confidence_threshold"} // $DEFAULT_CONFIDENCE_THRESH
l!l&&r!l&&!r
131855152
$params->{"max_parameters"} // $DEFAULT_MAX_PARAMETERS
l!l&&r!l&&!r
128858152
$params->{"allow_signature_exec"} // 0
l!l
1291008
MC/DC100%1/1
$params->{"verbose"} // 0
$params->{"verbose"}
MC/DC100%1/1
$params->{"include_private"} // 0
$params->{"include_private"}
MC/DC100%2/2
$params->{"confidence_threshold"} // $DEFAULT_CONFIDENCE_THRESH
$params->{"confidence_threshold"} $DEFAULT_CONFIDENCE_THRESH
MC/DC100%2/2
$params->{"max_parameters"} // $DEFAULT_MAX_PARAMETERS
$params->{"max_parameters"} $DEFAULT_MAX_PARAMETERS
MC/DC100%1/1
$params->{"allow_signature_exec"} // 0
$params->{"allow_signature_exec"}
Truth table100%2/2
A
A= $params->{"verbose"}
Aresult
11
00
Truth table100%2/2
A
A= $params->{"include_private"}
Aresult
11
00
Truth table100%3/3
A // B
A= $params->{"confidence_threshold"}B= $DEFAULT_CONFIDENCE_THRESH
ABresult
1X1
011
000
Truth table100%3/3
A // B
A= $params->{"max_parameters"}B= $DEFAULT_MAX_PARAMETERS
ABresult
1X1
011
000
Truth table100%2/2
A
A= $params->{"allow_signature_exec"}
Aresult
11
00
1376 };
1377  
1378 # Validate input file exists
1379 1137 ▶ unless (-f $self->{input_file}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (-f $self->{"input_file"}) 3 1134 1137
1380 3 croak(__PACKAGE__, ": Input file '$self->{input_file}' does not exist");
1381 }
1382  
1383 1134 return bless $self, $class;
1384 }
1385  
1386 =head2 extract_all
1387  
1388 Extract schemas for all qualifying methods in the module and return
1389 them as a hashref.
1390  
1391 my $schemas = $extractor->extract_all();
1392  
1393 # Suppress writing .yml files to disk
1394 my $schemas = $extractor->extract_all(no_write => 1);
1395  
1396 =head3 Arguments
1397  
1398 =over 4
1399  
1400 =item * C<no_write>
1401  
1402 When true, schema files are not written to C<output_dir>. The returned
1403 hashref is still fully populated. Useful when the caller wants to
1404 inspect or augment schemas before deciding whether to write them.
1405 Optional, default 0.
1406  
1407 =back
1408  
1409 =head3 Returns
1410  
1411 A hashref mapping method name strings to schema hashrefs. Each schema
1412 contains at minimum the keys C<function>, C<module>, C<input>,
1413 C<output>, and C<_analysis>. See L</Generated Schema Structure> for
1414 the full structure.
1415  
1416 =head3 Side effects
1417  
1418 Parses the input file with L<PPI>. Writes one YAML file per method to
1419 C<output_dir> unless C<no_write> is set. Creates C<output_dir> if it
1420 does not exist and writing is enabled.
1421  
1422 =head3 Notes
1423  
1424 Private methods (names beginning with C<_>) are excluded unless
1425 C<include_private =E<gt> 1> was passed to C<new>. Duplicate method
1426 names are deduplicated with a warning logged to stdout in verbose mode.
1427  
1428 POD/code agreement validation is applied if C<strict_pod> was set in
1429 C<new>. At level 2 (fatal), the first disagreement causes an immediate
1430 croak.
1431  
1432 =head3 API specification
1433  
1434 =head4 input
1435  
1436 {
1437 self => { type => OBJECT, isa => 'App::Test::Generator::SchemaExtractor' },
1438 no_write => { type => SCALAR, optional => 1 },
1439 }
1440  
1441 =head4 output
1442  
1443 {
1444 type => HASHREF,
1445 keys => {
1446 '*' => {
1447 type => HASHREF,
1448 keys => {
1449 function => { type => SCALAR },
1450 module => { type => SCALAR },
1451 input => { type => HASHREF },
1452 output => { type => HASHREF },
1453 _analysis => { type => HASHREF },
1454 },
1455 },
1456 },
1457 }
1458  
1459 =cut
1460  
1461 297 ▶sub extract_all {
Subroutine extract_all: called CC=70 SCAR=43.3
Pod documented
1462 297 my $self = shift;
1463 297 ▶ my $params = Params::Get::get_params(undef, @_) || {};
Condition100%2/2
Params::Get::get_params(undef, @_) || {}
l!l
91206
MC/DC100%1/1
Params::Get::get_params(undef, @_) || {}
Params::Get::get_params(undef, @_)
Truth table100%2/2
A
A= Params::Get::get_params(undef, @_)
Aresult
11
00
1464  
1465 297 $self->_log("Parsing $self->{input_file}...");
1466 297 $self->_log('Strict POD mode: ' . (qw(off warn fatal))[$self->{strict_pod}]);
1467  
1468 # $! is not meaningful here — PPI does not set errno on failure
1469 my $document = PPI::Document->new($self->{input_file})
1470 297 ▶ or croak "Failed to parse $self->{input_file}";
Branch: 1 branch
BranchTrueFalseTotal
my $document = "PPI::Document"->new($self->{"input_file"}) or croak(qq[Failed to parse $self->{"input_file"}]) 297 0 297
1471  
1472 # Store document for later use
1473 297 $self->{_document} = $document;
1474  
1475 297 my $package_name = $self->_extract_package_name($document);
1476 297 ▶ $self->{_package_name} //= $package_name;
Condition66%2/3
$self->{"_package_name"} //= $package_name
l!l&&r!l&&!r
28980
MC/DC0%0/2
$self->{"_package_name"} //= $package_name
$self->{"_package_name"} $package_name
Truth table66%2/3
A //= B
A= $self->{"_package_name"}B= $package_name
ABresult
1X1
011
000
1477 297 $self->_log("Package: $package_name");
1478  
1479 297 my $methods = $self->_find_methods($document);
1480 297 $self->_log('Found ' . scalar(@$methods) . ' methods (pre-dedup)');
1481  
1482 297 my %schemas;
1483 my %delegates;
1484 297 my $ctor_body;
1485 297 foreach my $method (@{$methods}) {
1486 768 $self->_log("\nAnalyzing method: $method->{name}");
1487  
1488 768 my $schema = $self->_analyze_method($method);
1489 764 $schemas{$method->{name}} = $schema;
1490 764 $schema->{'module'} = $package_name;
1491 764 ▶ $ctor_body = $method->{body} if($method->{name} eq 'new');
Branch: 1 branch
BranchTrueFalseTotal
if $method->{"name"} eq "new" 93 671 764
1492  
1493 764 my $target = $self->_delegated_method($method->{body});
1494 764 ▶ $delegates{$method->{name}} = $target if defined($target);
Branch: 1 branch
BranchTrueFalseTotal
if defined $target 2 762 764
1495 }
1496  
1497 # Second pass: enrich instance-method schemas with constructor args so the
1498 # fuzz harness can build $self automatically. The new() schema (if present)
1499 # provides type info; we generate one representative value per required param.
1500 # Enrichable: new: {} (no-arg ctor) or new: {hash} (with args).
1501 # Unenrichable (coderef/object params): leave new: as the package-name string
1502 # so _write_schema still emits new: ~ and self-fuzz.t keeps skipping those.
1503 293 ▶ if (exists $schemas{new}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $schemas{"new"}) 93 200 293
1504 93 my $ctor_args = $self->_ctor_representative_args($schemas{new});
1505 93 ▶ if (defined $ctor_args) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $ctor_args) 75 18 93
1506 75 for my $method_name (keys %schemas) {
1507 244 ▶ next if $method_name eq 'new';
Branch: 1 branch
BranchTrueFalseTotal
if $method_name eq "new" 75 169 244
1508 169 my $schema = $schemas{$method_name};
1509 169 ▶ next unless exists $schema->{new} && defined $schema->{new};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $schema->{"new"} and defined $schema->{"new"} 12 157 169
Condition66%2/3
exists $schema->{"new"} and defined $schema->{"new"}
!ll&&!rl&&r
120157
MC/DC50%1/2
exists $schema->{"new"} and defined $schema->{"new"}
exists $schema->{"new"} defined $schema->{"new"}
Truth table66%2/3
A and B
A= exists $schema->{"new"}B= defined $schema->{"new"}
ABresult
0X0
100
111
1510 157 $schema->{new} = $ctor_args;
1511 157 $self->_log(" ENRICH: $method_name new: enriched with ctor args");
1512 }
1513 }
1514 }
1515  
1516 # A constructor can refuse to build the package itself: an abstract base
1517 # class croaks on direct instantiation, and a constructor that croaks over
1518 # an argument the extractor cannot supply cannot be built either. Either
1519 # way no harness can get a $self, so the instance methods are not fuzzable
1520 # this way: leaving new: as the package name makes _write_schema emit
1521 # new: ~, which callers report as skipped rather than failed.
1522 293 ▶ if($ctor_body && $schemas{new} && _constructor_refuses_direct_instantiation($ctor_body, $schemas{new})) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ctor_body and $schemas{"new"} and _constructor_refuses_direct_instantiation($ctor_body, $schemas{"new"})) 2 291 293
Condition83%5/6
$ctor_body and $schemas{"new"} and _constructor_refuses_direct_instantiation($ctor_body, $schemas{"new"})
!ll&&!rl&&r
200912
$ctor_body and $schemas{"new"}
!ll&&!rl&&r
200093
MC/DC66%2/3
$ctor_body and $schemas{"new"} and _constructor_refuses_direct_instantiation($ctor_body, $schemas{"new"})
$ctor_body $schemas{"new"} _constructor_refuses_direct_instantiation($ctor_body, $schemas{"new"})
Truth table75%3/4
A and B and C
A= $ctor_bodyB= $schemas{"new"}C= _constructor_refuses_direct_instantiation($ctor_body, $schemas{"new"})
ABCresult
0XX0
10X0
1100
1111
1523 # The class itself cannot be constructed, so its new() is expected to
1524 # die rather than return an object.
1525 2 $schemas{new}{output} = { _STATUS => 'DIES' };
1526 2 for my $method_name (keys %schemas) {
1527 4 ▶ next if($method_name eq 'new');
Branch: 1 branch
BranchTrueFalseTotal
if $method_name eq "new" 2 2 4
1528 2 my $schema = $schemas{$method_name};
1529 2 ▶ next unless(exists($schema->{new}) && defined($schema->{new}));
Branch: 1 branch
BranchTrueFalseTotal
unless exists $schema->{"new"} and defined $schema->{"new"} 0 2 2
Condition33%1/3
exists $schema->{"new"} and defined $schema->{"new"}
!ll&&!rl&&r
002
MC/DC0%0/2
exists $schema->{"new"} and defined $schema->{"new"}
exists $schema->{"new"} defined $schema->{"new"}
Truth table33%1/3
A and B
A= exists $schema->{"new"}B= defined $schema->{"new"}
ABresult
0X0
100
111
1530 2 $schema->{new} = $package_name;
1531 2 $self->_log(" UNBUILDABLE: $method_name new: ~ ($package_name refuses to be built)");
1532 }
1533 }
1534  
1535 # Third pass: contracts the type inference cannot see in the signature.
1536 # A routine can document behaviour in its body that changes what the
1537 # harness may assert: an abstract method always dies, a routine returning
1538 # a list must be called in list context, one that returns nothing has no
1539 # output to validate, and a parameter checked against a pattern rejects
1540 # values outside it. A routine that reads a file it is given cannot be
1541 # fuzzed with a synthesized value at all.
1542 293 foreach my $method (@{$methods}) {
1543 764 my $schema = $schemas{$method->{name}};
1544 764 ▶ next unless($schema && ref($schema->{output}) eq 'HASH');
Branch: 1 branch
BranchTrueFalseTotal
unless $schema and ref $schema->{"output"} eq "HASH" 0 764 764
Condition33%1/3
$schema and ref $schema->{"output"} eq "HASH"
!ll&&!rl&&r
00764
MC/DC0%0/2
$schema and ref $schema->{"output"} eq "HASH"
$schema ref $schema->{"output"} eq "HASH"
Truth table33%1/3
A and B
A= $schemaB= ref $schema->{"output"} eq "HASH"
ABresult
0X0
100
111
1545 764 ▶ my $body = $method->{body} // '';
Condition50%1/2
$method->{"body"} // ""
l!l
7640
MC/DC0%0/1
$method->{"body"} // ""
$method->{"body"}
Truth table50%1/2
A
A= $method->{"body"}
Aresult
11
00
1546  
1547 764 ▶ if($body =~ /\bcroak\b[^;\n]*must be implemented by subclass/) {
Branch: 4 branches
BranchTrueFalseTotal
if ($body =~ /\bcroak\b[^;\n]*must be implemented by subclass/) { } 7 757 764
elsif ($body =~ /\breturn\s+\@\{/ and ($method->{'pod'} // '') =~ /\b(?:a\s+)?list\s+of\b|\breturns?\s+a\s+list\b/i) { } 7 750 757
elsif ($body =~ /\breturn\s*;/ and not $body =~ /\breturn\s+[^\s;]/) { } 9 741 750
elsif ($body =~ /\breturn\s+\\?[A-Z]\w*(?:::\w+)+(?:->)?\w*\s*\(/) { } 3 738 741
1548 7 $schema->{output}{_STATUS} = 'DIES';
1549 ▶ } elsif(($body =~ /\breturn\s+@\{/) && (($method->{pod} // '') =~ /\b(?:a\s+)?list\s+of\b|\breturns?\s+a\s+list\b/i)) {
Condition80%4/5
$body =~ /\breturn\s+\@\{/ and ($method->{"pod"} // "") =~ /\b(?:a\s+)?list\s+of\b|\breturns?\s+a\s+list\b/i
!ll&&!rl&&r
739117
$method->{"pod"} // ""
l!l
180
MC/DC50%1/2
$body =~ /\breturn\s+\@\{/ and ($method->{"pod"} // "") =~ /\b(?:a\s+)?list\s+of\b|\breturns?\s+a\s+list\b/i
$body =~ /\breturn\s+\@\{/ $method->{"pod"}
Truth table66%2/3
A and B
A= $body =~ /\breturn\s+\@\{/B= $method->{"pod"}
ABresult
0X0
100
111
1550 # Called in scalar context a list return yields its count, so the
1551 # harness has to capture the list. Only when the POD says the
1552 # routine returns a list, not an arrayref.
1553 7 $schema->{output}{type} = 'array';
1554 ▶ } elsif(($body =~ /\breturn\s*;/) && ($body !~ /\breturn\s+[^\s;]/)) {
Condition100%3/3
$body =~ /\breturn\s*;/ and not $body =~ /\breturn\s+[^\s;]/
!ll&&!rl&&r
73749
MC/DC100%2/2
$body =~ /\breturn\s*;/ and not $body =~ /\breturn\s+[^\s;]/
$body =~ /\breturn\s*;/ not $body =~ /\breturn\s+[^\s;]/
Truth table100%3/3
A and not(B)
A= $body =~ /\breturn\s*;/B= not $body =~ /\breturn\s+[^\s;]/
ABresult
0X0
100
111
1555 # The routine returns nothing: say so, rather than omitting the
1556 # type. 'void' is the documented way to describe that (see
1557 # _detect_void_context), and the harness validates no return
1558 # value for it.
1559 9 $schema->{output}{type} = 'void';
1560 } elsif($body =~ /\breturn\s+\\?[A-Z]\w*(?:::\w+)+(?:->)?\w*\s*\(/) {
1561 # Delegated to another package: its result type is not visible here.
1562 3 delete $schema->{output}{type};
1563 }
1564  
1565 764 ▶ if(my $skip = _requires_input_file($body, $schema->{input})) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $skip = _requires_input_file($body, $schema->{"input"})) 18 746 764
1566 18 $schema->{skip} = $skip;
1567 }
1568  
1569 # A method that reads required keys out of a constructor hashref cannot
1570 # be given a working object: the harness has no schema to put there.
1571 764 ▶ if(ref($schema->{new}) eq 'HASH' && %{$schema->{new}}) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $schema->{"new"} eq "HASH" and %{$schema->{"new"};}) 54 710 764
Condition100%3/3
ref $schema->{"new"} eq "HASH" and %{$schema->{"new"};}
!ll&&!rl&&r
60910154
MC/DC100%2/2
ref $schema->{"new"} eq "HASH" and %{$schema->{"new"};}
ref $schema->{"new"} eq "HASH" %{$schema->{"new"};}
Truth table100%3/3
A and B
A= ref $schema->{"new"} eq "HASH"B= %{$schema->{"new"};}
ABresult
0X0
100
111
1572 54 foreach my $param (keys %{$schema->{new}}) {
1573 96 my $p = quotemeta($param);
1574 # Read directly, or through a local copy of the hashref.
1575 96 ▶ my $reads_keys = ($body =~ /\$self->\{\s*['"]?$p['"]?\s*\}->\{/)
Condition66%4/6
$body =~ /\$self->\{\s*['"]?${p}['"]?\s*\}->\{/ || $body =~ /my\s+\$(\w+)\s*=\s*\$self->\{\s*['"]?${p}['"]?\s*\}/ && $body =~ /\$$1->\{/
l!l&&r!l&&!r
0888
$body =~ /my\s+\$(\w+)\s*=\s*\$self->\{\s*['"]?${p}['"]?\s*\}/ and $body =~ /\$$1->\{/
!ll&&!rl&&r
8808
MC/DC33%1/3
$body =~ /\$self->\{\s*['"]?${p}['"]?\s*\}->\{/ || $body =~ /my\s+\$(\w+)\s*=\s*\$self->\{\s*['"]?${p}['"]?\s*\}/ && $body =~ /\$$1->\{/
$body =~ /\$self->\{\s*['"]?${p}['"]?\s*\}->\{/ $body =~ /my\s+\$(\w+)\s*=\s*\$self->\{\s*['"]?${p}['"]?\s*\}/ $body =~ /\$$1->\{/
Truth table50%2/4
A || B and C
A= $body =~ /\$self->\{\s*['"]?${p}['"]?\s*\}->\{/B= $body =~ /my\s+\$(\w+)\s*=\s*\$self->\{\s*['"]?${p}['"]?\s*\}/C= $body =~ /\$$1->\{/
ABCresult
1XX1
0111
00X0
0100
1576 || ($body =~ /my\s+\$(\w+)\s*=\s*\$self->\{\s*['"]?$p['"]?\s*\}/ && $body =~ /\$$1->\{/);
1577 96 ▶ next unless($reads_keys && ($body =~ /\bcroak\b/));
Branch: 1 branch
BranchTrueFalseTotal
unless $reads_keys and $body =~ /\bcroak\b/ 91 5 96
Condition100%3/3
$reads_keys and $body =~ /\bcroak\b/
!ll&&!rl&&r
8835
MC/DC100%2/2
$reads_keys and $body =~ /\bcroak\b/
$reads_keys $body =~ /\bcroak\b/
Truth table100%3/3
A and B
A= $reads_keysB= $body =~ /\bcroak\b/
ABresult
0X0
100
111
1578 5 ▶ $schema->{new} = $self->{_package_name} if($self->{_package_name});
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"_package_name"} 5 0 5
1579 5 last;
1580 }
1581 }
1582  
1583 764 ▶ _next_parameter: foreach my $param_name (keys %{$schema->{input} // {}}) {
Condition100%2/2
$schema->{"input"} // {}
l!l
72935
MC/DC100%1/1
$schema->{"input"} // {}
$schema->{"input"}
Truth table100%2/2
A
A= $schema->{"input"}
Aresult
11
00
1584 676 my $spec = $schema->{input}{$param_name};
1585 676 ▶ next unless(ref($spec) eq 'HASH');
Branch: 1 branch
BranchTrueFalseTotal
unless ref $spec eq "HASH" 0 676 676
1586 676 my $p = quotemeta($param_name);
1587  
1588 676 ▶ if($body =~ /ref\(\s*\$args\{\s*['"]?$p['"]?\s*\}\s*\)\s*(?:ne|eq)\s*['"]CODE['"]/
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /ref\(\s*\$args\{\s*['"]?${p}['"]?\s*\}\s*\)\s*(?:ne|eq)\s*['"]CODE['"]/ or $body =~ /\$args\{\s*['"]?${p}['"]?\s*\}\s*->\s*\(/) 4 672 676
Condition100%3/3
$body =~ /ref\(\s*\$args\{\s*['"]?${p}['"]?\s*\}\s*\)\s*(?:ne|eq)\s*['"]CODE['"]/ or $body =~ /\$args\{\s*['"]?${p}['"]?\s*\}\s*->\s*\(/
l!l&&r!l&&!r
31672
MC/DC100%2/2
$body =~ /ref\(\s*\$args\{\s*['"]?${p}['"]?\s*\}\s*\)\s*(?:ne|eq)\s*['"]CODE['"]/ or $body =~ /\$args\{\s*['"]?${p}['"]?\s*\}\s*->\s*\(/
$body =~ /ref\(\s*\$args\{\s*['"]?${p}['"]?\s*\}\s*\)\s*(?:ne|eq)\s*['"]CODE['"]/ $body =~ /\$args\{\s*['"]?${p}['"]?\s*\}\s*->\s*\(/
Truth table100%3/3
A or B
A= $body =~ /ref\(\s*\$args\{\s*['"]?${p}['"]?\s*\}\s*\)\s*(?:ne|eq)\s*['"]CODE['"]/B= $body =~ /\$args\{\s*['"]?${p}['"]?\s*\}\s*->\s*\(/
ABresult
1X1
011
000
1589 || $body =~ /\$args\{\s*['"]?$p['"]?\s*\}\s*->\s*\(/) {
1590 4 $spec->{type} = 'coderef';
1591 4 next _next_parameter;
1592 }
1593  
1594 # The value is checked against a file-level constant set: the module
1595 # member list is the documented domain, e.g. add_evidence's category.
1596 672 ▶ if($body =~ /my\s+\$(\w+)\s*=\s*\$args\{\s*['"]?$p['"]?\s*\}/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /my\s+\$(\w+)\s*=\s*\$args\{\s*['"]?${p}['"]?\s*\}/) 13 659 672
1597 13 my $var = $1;
1598 13 ▶ if($body =~ /[\$%](\w+)\s*\{\s*\$$var\s*\}/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /[\$%](\w+)\s*\{\s*\$$var\s*\}/) 7 6 13
1599 7 my $const = $1;
1600 7 ▶ my $source = $self->{_document} ? $self->{_document}->serialize : '';
Branch: 1 branch
BranchTrueFalseTotal
$self->{'_document'} ? : 7 0 7
1601 7 ▶ if($source =~ /%$const\s*(?:=|=>)\s*.*?qw\s*[\(\{\[]([^\)\}\]]+)[\)\}\]]/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($source =~ /%$const\s*(?:=|=>)\s*.*?qw\s*[\(\{\[]([^\)\}\]]+)[\)\}\]]/s) 7 0 7
1602 7 my @values = split(' ', $1);
1603 7 ▶ $spec->{memberof} = \@values if(@values);
Branch: 1 branch
BranchTrueFalseTotal
if @values 7 0 7
1604 }
1605 }
1606 }
1607  
1608 # A routine that checks the value against a pattern and croaks is a
1609 # validator for that parameter: values outside the pattern are
1610 # documented to die, so the pattern belongs in the schema.
1611 672 my $pattern;
1612 672 ▶ if($body =~ /\$args\{\s*['"]?$p['"]?\s*\}\s*=~\s*\/([^\/\n]+)\//) {
Branch: 2 branches
BranchTrueFalseTotal
if ($body =~ m[\$args\{\s*['"]?${p}['"]?\s*\}\s*=~\s*/([^/\n]+)/]) { } 4 668 672
elsif ($body =~ m[\$$p\b\s*=~\s*/([^/\n]+)/]) { } 23 645 668
1613 4 $pattern = $1;
1614 } elsif($body =~ /\$$p\b\s*=~\s*\/([^\/\n]+)\//) {
1615 23 $pattern = $1;
1616 }
1617 672 ▶ if(defined($pattern) && ($body =~ /\bcroak\b[^;\n]*(?:not a valid|invalid)/i)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $pattern and $body =~ /\bcroak\b[^;\n]*(?:not a valid|invalid)/i) 9 663 672
Condition100%3/3
defined $pattern and $body =~ /\bcroak\b[^;\n]*(?:not a valid|invalid)/i
!ll&&!rl&&r
645189
MC/DC100%2/2
defined $pattern and $body =~ /\bcroak\b[^;\n]*(?:not a valid|invalid)/i
defined $pattern $body =~ /\bcroak\b[^;\n]*(?:not a valid|invalid)/i
Truth table100%3/3
A and B
A= defined $patternB= $body =~ /\bcroak\b[^;\n]*(?:not a valid|invalid)/i
ABresult
0X0
100
111
1618 9 $spec->{matches} = $pattern;
1619 9 $spec->{_source} = SOURCE_VALIDATOR;
1620 }
1621 }
1622 }
1623  
1624 # A constructor that parses a file it is given cannot be built by the
1625 # harness either, so its instance methods get new: ~ like any other
1626 # unbuildable class.
1627 293 ▶ if($schemas{new} && $schemas{new}{skip}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schemas{"new"} and $schemas{"new"}{"skip"}) 4 289 293
Condition100%3/3
$schemas{"new"} and $schemas{"new"}{"skip"}
!ll&&!rl&&r
200894
MC/DC100%2/2
$schemas{"new"} and $schemas{"new"}{"skip"}
$schemas{"new"} $schemas{"new"}{"skip"}
Truth table100%3/3
A and B
A= $schemas{"new"}B= $schemas{"new"}{"skip"}
ABresult
0X0
100
111
1628 4 for my $method_name (keys %schemas) {
1629 14 ▶ next if($method_name eq 'new');
Branch: 1 branch
BranchTrueFalseTotal
if $method_name eq "new" 4 10 14
1630 10 my $schema = $schemas{$method_name};
1631 10 ▶ next unless(exists($schema->{new}) && defined($schema->{new}));
Branch: 1 branch
BranchTrueFalseTotal
unless exists $schema->{"new"} and defined $schema->{"new"} 0 10 10
Condition33%1/3
exists $schema->{"new"} and defined $schema->{"new"}
!ll&&!rl&&r
0010
MC/DC0%0/2
exists $schema->{"new"} and defined $schema->{"new"}
exists $schema->{"new"} defined $schema->{"new"}
Truth table33%1/3
A and B
A= exists $schema->{"new"}B= defined $schema->{"new"}
ABresult
0X0
100
111
1632 10 $schema->{new} = $package_name;
1633 10 $self->_log(" UNBUILDABLE: $method_name new: ~ ($package_name constructor needs an input file)");
1634 }
1635 }
1636  
1637 # A routine whose whole body is `return $self->other(\@_)` has
1638 # exactly other()'s input contract. CGI::Info::get_cookie is such a
1639 # forwarder, and without this it looked like it took no parameters at all,
1640 # so the harness called it with none and died on the required cookie_name.
1641 293 for my $method_name (sort keys %delegates) {
1642 2 my $target = $delegates{$method_name};
1643 2 ▶ next if $method_name eq $target;
Branch: 1 branch
BranchTrueFalseTotal
if $method_name eq $target 0 2 2
1644 2 my $target_schema = $schemas{$target};
1645 next unless $target_schema && ref($target_schema->{input}) eq 'HASH'
1646 2 ▶ && scalar(keys %{$target_schema->{input}});
Branch: 1 branch
BranchTrueFalseTotal
unless $target_schema and ref $target_schema->{"input"} eq "HASH" and scalar keys %{$$target_schema{"input"};} 1 1 2
Condition80%4/5
$target_schema and ref $target_schema->{"input"} eq "HASH" and scalar keys %{$$target_schema{"input"};}
!ll
11
$target_schema and ref $target_schema->{"input"} eq "HASH"
!ll&&!rl&&r
101
MC/DC50%1/2
$target_schema and ref $target_schema->{"input"} eq "HASH" and scalar keys %{$$target_schema{"input"};}
$target_schema ref $target_schema->{"input"} eq "HASH"
Truth table66%2/3
A and B
A= $target_schemaB= ref $target_schema->{"input"} eq "HASH"
ABresult
0X0
100
111
1647  
1648 1 my $schema = $schemas{$method_name};
1649 1 ▶ next unless $schema;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema 0 1 1
1650 1 ▶ next if ref($schema->{input}) eq 'HASH' && scalar(keys %{$schema->{input}});
Branch: 1 branch
BranchTrueFalseTotal
if ref $schema->{"input"} eq "HASH" and scalar keys %{$$schema{"input"};} 0 1 1
Condition50%1/2
ref $schema->{"input"} eq "HASH" and scalar keys %{$$schema{"input"};}
!ll
01
MC/DC0%0/1
ref $schema->{"input"} eq "HASH" and scalar keys %{$$schema{"input"};}
ref $schema->{"input"} eq "HASH"
Truth table50%1/2
A
A= ref $schema->{"input"} eq "HASH"
Aresult
00
11
1651  
1652 $schema->{input} = {
1653 1 map { $_ => { %{$target_schema->{input}{$_}} } } sort keys %{$target_schema->{input}}
1654 };
1655 $schema->{_confidence}{input} = {
1656 1 'level' => 'medium',
1657 'factors' => [ "Forwarded to $target()" ]
1658 };
1659 1 push @{$schema->{_notes}}, "input inherited from $target(), which this routine forwards \@_ to";
1660 1 $self->_log(" DELEGATE: $method_name input inherited from $target");
1661 }
1662  
1663 293 ▶ unless ($params->{no_write}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($params->{"no_write"}) 206 87 293
1664 206 for my $method_name (keys %schemas) {
1665 528 $self->_write_schema($method_name, $schemas{$method_name});
1666 }
1667 }
1668  
1669 293 return \%schemas;
1670 }
1671  
1672 # --------------------------------------------------
1673 # _delegated_method
1674 #
1675 # Purpose: Detect a routine whose whole body
1676 # forwards its arguments to another
1677 # method of the same object.
1678 #
1679 # Entry: $code - the subroutine's source text.
1680 #
1681 # Exit: Returns the name of the method it
1682 # forwards to, or undef when the routine
1683 # does anything else.
1684 #
1685 # Side effects: None.
1686 #
1687 # Notes: Only the bare `return $self->other(\@_)`
1688 # shape counts. Such a forwarder has
1689 # exactly the target's input contract,
1690 # which extract_all() copies so that the
1691 # harness passes the right arguments
1692 # (CGI::Info::get_cookie -> cookie).
1693 # --------------------------------------------------
1694 764 ▶sub _delegated_method {
Subroutine _delegated_method: called CC=3 SCAR=11.0
1695 764 my ($self, $code) = @_;
1696  
1697 764 ▶ return unless defined($code);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $code 0 764 764
1698  
1699 764 (my $body = $code) =~ s/\A\s*sub\s+\w+\s*//;
1700 764 $body =~ s/\s+/ /g;
1701  
1702 764 ▶ return $body =~ /\A\{ (?:my \$self = shift; )?return \$self->(\w+)\(\s*\\\@_\s*\); \}\z/ ? $1 : undef;
Branch: 1 branch
BranchTrueFalseTotal
$body =~ /\A\{ (?:my \$self = shift; )?return \$self->(\w+)\(\s*\\\@_\s*\); \}\z/ ? : 2 762 764
1703 }
1704  
1705 # --------------------------------------------------
1706 # _extract_package_name
1707 #
1708 # Purpose: Extract the Perl package name from a
1709 # PPI document, or from the cached value
1710 # stored at construction time.
1711 #
1712 # Entry: $document - a PPI::Document, or undef
1713 # to use $self->{_document}.
1714 #
1715 # Exit: Returns the package namespace string,
1716 # or an empty string if no package
1717 # statement is found.
1718 #
1719 # Side effects: Stores the package name in
1720 # $self->{_package_name} if not already
1721 # set.
1722 #
1723 # Notes: Croaks if more than one package
1724 # declaration is found — multi-package
1725 # files are not supported.
1726 # --------------------------------------------------
1727 356 ▶sub _extract_package_name {
Subroutine _extract_package_name: called CC=7 SCAR=19.6
1728 356 my ($self, $document) = @_;
1729  
1730 356 ▶ if(!defined($document)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $document) 59 297 356
1731 59 $document = $self->{_document};
1732 }
1733 356 ▶ my $pkgs = $document->find('PPI::Statement::Package') || [];
Condition100%2/2
$document->find('PPI::Statement::Package') || []
l!l
3488
MC/DC100%1/1
$document->find('PPI::Statement::Package') || []
$document->find('PPI::Statement::Package')
Truth table100%2/2
A
A= $document->find('PPI::Statement::Package')
Aresult
11
00
1734 356 ▶ if(@$pkgs == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (@$pkgs == 0) 8 348 356
1735 8 my $package_stmt = $document->find_first('PPI::Statement::Package');
1736 8 ▶ return $package_stmt ? $package_stmt->namespace() : '';
Branch: 1 branch
BranchTrueFalseTotal
$package_stmt ? : 0 8 8
1737 }
1738 348 ▶ croak('More than one package declaration found') if @$pkgs > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @$pkgs > 1 0 348 348
1739 348 ▶ $self->{_package_name} //= $pkgs->[0]->namespace();
Condition66%2/3
$self->{"_package_name"} //= $pkgs->[0]->namespace
l!l&&r!l&&!r
602880
MC/DC0%0/2
$self->{"_package_name"} //= $pkgs->[0]->namespace
$self->{"_package_name"} $pkgs->[0]->namespace
Truth table66%2/3
A //= B
A= $self->{"_package_name"}B= $pkgs->[0]->namespace
ABresult
1X1
011
000
1740 348 return $pkgs->[0]->namespace();
1741 }
1742  
1743 # --------------------------------------------------
1744 # _find_methods
1745 #
1746 # Purpose: Locate all subroutine and method
1747 # declarations in a PPI document,
1748 # including Moose-style method modifiers
1749 # and Perl 5.38 class/method syntax.
1750 #
1751 # Entry: $document - a PPI::Document.
1752 #
1753 # Exit: Returns an arrayref of method hashrefs,
1754 # each containing: name, node, body, pod,
1755 # type, and optionally modifier, class,
1756 # and fields keys.
1757 # Private methods (names beginning with
1758 # _) are excluded unless include_private
1759 # was set in new(), except for _new,
1760 # _init, and _build which are always
1761 # included.
1762 #
1763 # Side effects: Logs progress and warnings to stdout
1764 # when verbose is set.
1765 #
1766 # Notes: Duplicate method names are silently
1767 # deduplicated — the second occurrence
1768 # is dropped with a verbose warning.
1769 # Class/method detection is regex-based
1770 # and may misbehave on complex code.
1771 # --------------------------------------------------
1772 300 ▶sub _find_methods {
Subroutine _find_methods: called CC=18 SCAR=32.2
1773 300 my ($self, $document) = @_;
1774  
1775 300 ▶ my $subs = $document->find('PPI::Statement::Sub') || [];
Condition100%2/2
$document->find('PPI::Statement::Sub') || []
l!l
2973
MC/DC100%1/1
$document->find('PPI::Statement::Sub') || []
$document->find('PPI::Statement::Sub')
Truth table100%2/2
A
A= $document->find('PPI::Statement::Sub')
Aresult
11
00
1776 # Only fetch statements that begin with a Moose modifier keyword —
1777 # fetching ALL PPI::Statement nodes on a large file returns thousands
1778 # of nodes and then discards nearly all of them in the loop below.
1779 422114 ▶ my $sub_decls = $document->find(sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
1780 422114 ▶ $_[1]->isa('PPI::Statement')
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Statement") and $_[1]->content =~ /^\s*(?:before|after|around)\b/ 42802 379312 422114
1781 && $_[1]->content =~ /^\s*(?:before|after|around)\b/
1782 300 ▶ }) || [];
Condition100%2/2
$document->find(sub { $_[1]->isa('PPI::Statement') and $_[1]->content =~ /^\s*(?:before|after|around)\b/; } ) || []
l!l
3297
MC/DC100%1/1
$document->find(sub { $_[1]->isa('PPI::Statement') and $_[1]->content =~ /^\s*(?:before|after|around)\b/; } ) || []
$document->find(sub { $_[1]->isa('PPI::Statement') and $_[1]->content =~ /^\s*(?:before|after|around)\b/; } )
Truth table100%2/2
A
A= $document->find(sub { $_[1]->isa('PPI::Statement') and $_[1]->content =~ /^\s*(?:before|after|around)\b/; } )
Aresult
11
00
1783  
1784 300 my @methods;
1785 300 foreach my $sub (@$subs) {
1786 1432 my $name = $sub->name();
1787  
1788 1432 ▶ next unless defined $name; # Skip anonymous routines
Branch: 1 branch
BranchTrueFalseTotal
unless defined $name 0 1432 1432
1789 1432 ▶ next if $name =~ /^(BEGIN|END|DESTROY|AUTOLOAD|CHECK|INIT|UNITCHECK)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(BEGIN|END|DESTROY|AUTOLOAD|CHECK|INIT|UNITCHECK)$/ 8 1424 1432
1790 1424 ▶ next if $name =~ /::/; # cross-package sub (e.g. sub DB::DB { })
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /::/ 3 1421 1424
1791  
1792 # Skip private methods unless explicitly included, or they're special
1793 1421 ▶ if ($name =~ /^_/ && $name !~ /^_(new|init|build)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($name =~ /^_/ and not $name =~ /^_(new|init|build)/) 645 776 1421
Condition100%3/3
$name =~ /^_/ and not $name =~ /^_(new|init|build)/
!ll&&!rl&&r
75818645
MC/DC100%2/2
$name =~ /^_/ and not $name =~ /^_(new|init|build)/
$name =~ /^_/ not $name =~ /^_(new|init|build)/
Truth table100%3/3
A and not(B)
A= $name =~ /^_/B= not $name =~ /^_(new|init|build)/
ABresult
0X0
100
111
1794 645 ▶ next unless $self->{include_private};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{"include_private"} 643 2 645
1795 }
1796  
1797 # Get the POD before this sub
1798 778 my $pod = $self->_extract_pod_before($sub);
1799  
1800 778 push @methods, {
1801 name => $name,
1802 node => $sub,
1803 body => $sub->content(),
1804 pod => $pod,
1805 type => 'sub',
1806 };
1807 }
1808  
1809 # Look for class { method } syntax (Perl 5.38+)
1810 300 my $content = $document->content();
1811 300 ▶ if ($content =~ /\bclass\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /\bclass\b/) 101 199 300
1812 101 $self->_log(' Detecting class/method syntax...');
1813 # Strip POD blocks and line comments before the regex scan so that
1814 # patterns like class Name { inside documentation examples or
1815 # the comment # find "class Name {" blocks don't produce
1816 # spurious method names (e.g. the keyword 'if').
1817 101 (my $code_only = $content) =~ s/^=\w[^\n]*.*?^=cut[^\n]*\n//gms;
1818 101 $code_only =~ s/\s*#[^\n]*//g;
1819 101 $self->_extract_class_methods($code_only, \@methods);
1820 }
1821  
1822 # Process method modifiers (Moose)
1823 300 foreach my $decl (@$sub_decls) {
1824 3 my $content = $decl->content;
1825 3 ▶ if ($content =~ /^\s*(before|after|around)\s+['"]?(\w+)['"]?\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /^\s*(before|after|around)\s+['"]?(\w+)['"]?\b/) 0 3 3
1826 0 my ($modifier, $method_name) = ($1, $2);
1827 0 my $full_name = "${modifier}_$method_name";
1828  
1829 # Look for the actual sub definition that follows
1830 0 my $next_sib = $decl->next_sibling;
1831 0 ▶ while ($next_sib && !$next_sib->isa('PPI::Statement::Sub')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_sib and not $next_sib->isa("PPI::Statement::Sub")) 0 0 0
Condition0%0/3
$next_sib and not $next_sib->isa("PPI::Statement::Sub")
!ll&&!rl&&r
000
MC/DC0%0/2
$next_sib and not $next_sib->isa("PPI::Statement::Sub")
$next_sib not $next_sib->isa("PPI::Statement::Sub")
Truth table0%0/3
A and not(B)
A= $next_sibB= not $next_sib->isa("PPI::Statement::Sub")
ABresult
0X0
100
111
1832 0 $next_sib = $next_sib->next_sibling;
1833 }
1834  
1835 0 ▶ if ($next_sib && $next_sib->isa('PPI::Statement::Sub')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_sib and $next_sib->isa("PPI::Statement::Sub")) 0 0 0
Condition0%0/3
$next_sib and $next_sib->isa("PPI::Statement::Sub")
!ll&&!rl&&r
000
MC/DC0%0/2
$next_sib and $next_sib->isa("PPI::Statement::Sub")
$next_sib $next_sib->isa("PPI::Statement::Sub")
Truth table0%0/3
A and B
A= $next_sibB= $next_sib->isa("PPI::Statement::Sub")
ABresult
0X0
100
111
1836 0 my $pod = $self->_extract_pod_before($decl); # POD might be before modifier
1837 0 push @methods, {
1838 name => $full_name,
1839 node => $next_sib,
1840 body => $next_sib->content,
1841 pod => $pod,
1842 type => 'modifier',
1843 original_method => $method_name,
1844 modifier => $modifier,
1845 };
1846 0 $self->_log(" Found method modifier: $full_name");
1847 }
1848 }
1849 }
1850  
1851 # Prevent silent duplicate method overwrites
1852 300 my %seen;
1853 @methods = grep {
1854 300 my $n = $_->{name};
1855 778 ▶ if ($seen{$n}++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($seen{$n}++) { } 1 777 778
1856 1 $self->_log(" WARNING: duplicate method '$n' ignored");
1857 1 0;
1858 } else {
1859 777 1;
1860 }
1861 } @methods;
1862  
1863 300 return \@methods;
1864 }
1865  
1866 # --------------------------------------------------
1867 # _extract_class_methods
1868 #
1869 # Purpose: Extract method declarations from
1870 # Perl 5.38 class { method {} } syntax
1871 # by regex-based scanning of the class
1872 # body content.
1873 #
1874 # Entry: $content - full document source string.
1875 # $methods - arrayref to push discovered
1876 # method hashrefs onto
1877 # (modified in place).
1878 #
1879 # Exit: Returns nothing. Appends to $methods.
1880 #
1881 # Side effects: Logs class and method discoveries
1882 # to stdout when verbose is set.
1883 #
1884 # Notes: This is experimental — regex-based
1885 # class body parsing may misbehave on
1886 # complex or nested class declarations.
1887 # Class body boundaries are tracked by
1888 # simple brace counting, which will
1889 # fail on unbalanced braces in strings
1890 # or heredocs.
1891 # --------------------------------------------------
1892 101 ▶sub _extract_class_methods {
Subroutine _extract_class_methods: called CC=8 SCAR=40.4
1893 101 my ($self, $content, $methods) = @_;
1894  
1895 # EXPERIMENTAL: regex-based parsing, may misbehave on complex code
1896  
1897 # Simple pattern: find "class Name {" blocks
1898 # This won't handle all edge cases but will work for simple classes
1899 101 ▶ while ($content =~ /class\s+(\w+)\s*\{/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /class\s+(\w+)\s*\{/g) 0 101 101
1900 0 my $class_name = $1;
1901 0 my $start_pos = pos($content);
1902  
1903 # Find the matching closing brace. $start_pos is just after the
1904 # opening '{' consumed by the regex above, so back up one
1905 # character to hand the brace itself to extract_bracketed.
1906 0 require Text::Balanced;
1907 0 my $extracted = Text::Balanced::extract_bracketed(substr($content, $start_pos - 1), '{}');
1908  
1909 0 ▶ next unless defined $extracted; # unbalanced braces, skip class
Branch: 1 branch
BranchTrueFalseTotal
unless defined $extracted 0 0 0
1910  
1911 0 my $class_body = substr($extracted, 1, length($extracted) - 2);
1912  
1913 0 $self->_log(" Found class $class_name");
1914  
1915 # Extract field declarations from class
1916 0 my $fields = $self->_extract_field_declarations($class_body);
1917  
1918 # Find methods in the class body
1919 0 ▶ while ($class_body =~ /method\s+(\w+)\s*(\([^)]*\))?\s*\{/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($class_body =~ /method\s+(\w+)\s*(\([^)]*\))?\s*\{/g) 0 0 0
1920 0 ▶ my ($method_name, $sig_with_parens) = ($1, $2 || '()');
Condition0%0/2
$2 || '()'
l!l
00
MC/DC0%0/1
$2 || '()'
$2
Truth table0%0/2
A
A= $2
Aresult
11
00
1921  
1922 # Skip private unless configured
1923 0 ▶ if ($method_name =~ /^_/ && $method_name !~ /^_(new|init|build)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name =~ /^_/ and not $method_name =~ /^_(new|init|build)/) 0 0 0
Condition0%0/3
$method_name =~ /^_/ and not $method_name =~ /^_(new|init|build)/
!ll&&!rl&&r
000
MC/DC0%0/2
$method_name =~ /^_/ and not $method_name =~ /^_(new|init|build)/
$method_name =~ /^_/ not $method_name =~ /^_(new|init|build)/
Truth table0%0/3
A and not(B)
A= $method_name =~ /^_/B= not $method_name =~ /^_(new|init|build)/
ABresult
0X0
100
111
1924 0 ▶ next unless $self->{include_private};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{"include_private"} 0 0 0
1925 }
1926  
1927 # Reconstruct as sub for analysis
1928 0 my $signature = $sig_with_parens;
1929 0 $signature =~ s/^\(//;
1930 0 $signature =~ s/\)$//;
1931  
1932 # Build a fake sub declaration
1933 0 my $fake_sub = "sub $method_name($signature) { }";
1934  
1935 0 push @$methods, {
1936 name => $method_name,
1937 node => undef,
1938 body => $fake_sub, # Just the signature for now
1939 is_stub => 1,
1940 pod => '',
1941 type => 'method',
1942 class => $class_name,
1943 fields => $fields,
1944 };
1945  
1946 0 $self->_log(" Found method $method_name in class $class_name");
1947 }
1948 }
1949 }
1950  
1951 # --------------------------------------------------
1952 # _extract_pod_before
1953 #
1954 # Purpose: Collect the POD documentation that
1955 # appears immediately before a
1956 # subroutine in the PPI document, by
1957 # walking backwards through siblings.
1958 #
1959 # Entry: $sub - a PPI node (typically a
1960 # PPI::Statement::Sub).
1961 #
1962 # Exit: Returns a string containing all POD
1963 # content found before the sub, with
1964 # inline parameter comments converted
1965 # to =item format. Returns an empty
1966 # string if no POD is found.
1967 #
1968 # Side effects: None.
1969 #
1970 # Notes: Stops walking backwards on the first
1971 # non-POD, non-whitespace, non-separator,
1972 # non-include node encountered.
1973 # Walking is capped at $POD_WALK_LIMIT
1974 # steps to prevent runaway processing
1975 # on pathological documents.
1976 # --------------------------------------------------
1977 778 ▶sub _extract_pod_before {
Subroutine _extract_pod_before: called CC=30 SCAR=35.2
1978 778 my ($self, $sub) = @_;
1979  
1980 778 ▶ my $name = eval { $sub->can('name') ? $sub->name : undef };
Branch: 1 branch
BranchTrueFalseTotal
$sub->can('name') ? : 778 0 778
1981 778 my $pod = '';
1982 778 my $current = $sub->previous_sibling();
1983 778 my $skipped_declaration = 0;
1984 778 my $steps = 0;
1985  
1986 # Walk backwards collecting POD.
1987 # Stop after the first pod token so that a =cut before =head1 METHODS
1988 # prevents class-level POD from being mistaken for method-specific POD.
1989 778 ▶ while($current && $steps++ < $POD_WALK_LIMIT) {
Branch: 1 branch
BranchTrueFalseTotal
if ($current and $steps++ < $POD_WALK_LIMIT) 2244 5 2249
Condition66%2/3
$current and $steps++ < $POD_WALK_LIMIT
!ll&&!rl&&r
502244
MC/DC50%1/2
$current and $steps++ < $POD_WALK_LIMIT
$current $steps++ < $POD_WALK_LIMIT
Truth table66%2/3
A and B
A= $currentB= $steps++ < $POD_WALK_LIMIT
ABresult
0X0
100
111
1990 2244 ▶ if ($current->isa('PPI::Token::Pod')) {
Branch: 5 branches
BranchTrueFalseTotal
if ($current->isa('PPI::Token::Pod')) { } 519 1725 2244
elsif ($current->isa('PPI::Token::Comment')) { } 437 1288 1725
elsif ($current->isa('PPI::Token::Whitespace') or $current->isa('PPI::Token::Separator')) { } 974 314 1288
elsif ($current->isa('PPI::Statement::Include')) { } 57 257 314
elsif ($current->isa('PPI::Statement::Variable') and $current->content =~ /\A\s*(?:my|our)\b/ and not $current->content =~ /\bsub\b/) { } 3 254 257
1991 519 my $content = $current->content();
1992 # A file-scoped declaration may sit between a routine's POD and
1993 # its sub (Mutation::Feedback declares a regex constant there).
1994 # Accept such a POD block only when it documents this routine.
1995 519 ▶ if(!$skipped_declaration
Branch: 1 branch
BranchTrueFalseTotal
if (not $skipped_declaration or defined $name and $content =~ /^=head[1-6]\s+\Q$name\E\b/m) 519 0 519
Condition50%3/6
not $skipped_declaration or defined $name and $content =~ /^=head[1-6]\s+\Q$name\E\b/m
l!l&&r!l&&!r
51630
defined $name and $content =~ /^=head[1-6]\s+\Q$name\E\b/m
!ll&&!rl&&r
003
MC/DC0%0/3
not $skipped_declaration or defined $name and $content =~ /^=head[1-6]\s+\Q$name\E\b/m
not $skipped_declaration defined $name $content =~ /^=head[1-6]\s+\Q$name\E\b/m
Truth table50%2/4
not(A) or B and C
A= not $skipped_declarationB= defined $nameC= $content =~ /^=head[1-6]\s+\Q$name\E\b/m
ABCresult
1XX1
0111
00X0
0100
1996 || (defined($name) && $content =~ /^=head[1-6]\s+\Q$name\E\b/m)) {
1997 519 $pod = $content . $pod;
1998 }
1999 519 last; # Only take the immediately adjacent pod block
2000 } elsif ($current->isa('PPI::Token::Comment')) {
2001 # Include comments that might contain parameter info
2002 437 my $comment = $current->content();
2003 437 ▶ if ($comment =~ /#\s*(?:param|arg|input)\s+\$(\w+)\s*:\s*(.+)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($comment =~ /#\s*(?:param|arg|input)\s+\$(\w+)\s*:\s*(.+)/i) 0 437 437
2004 0 $pod .= "=item \$$1\n$2\n\n";
2005 }
2006 ▶ } elsif ($current->isa('PPI::Token::Whitespace') ||
Condition66%2/3
$current->isa("PPI::Token::Whitespace") or $current->isa("PPI::Token::Separator")
l!l&&r!l&&!r
9740314
MC/DC50%1/2
$current->isa("PPI::Token::Whitespace") or $current->isa("PPI::Token::Separator")
$current->isa("PPI::Token::Whitespace") $current->isa("PPI::Token::Separator")
Truth table66%2/3
A or B
A= $current->isa("PPI::Token::Whitespace")B= $current->isa("PPI::Token::Separator")
ABresult
1X1
011
000
2007 $current->isa('PPI::Token::Separator')) {
2008 # Skip whitespace and separators
2009 } elsif ($current->isa('PPI::Statement::Include')) {
2010 # allow 'use strict', 'use warnings' between POD and sub
2011 ▶ } elsif ($current->isa('PPI::Statement::Variable')
Condition66%4/6
$current->isa("PPI::Statement::Variable") and $current->content =~ /\A\s*(?:my|our)\b/ and not $current->content =~ /\bsub\b/
!ll&&!rl&&r
25403
$current->isa("PPI::Statement::Variable") and $current->content =~ /\A\s*(?:my|our)\b/
!ll&&!rl&&r
25403
MC/DC33%1/3
$current->isa("PPI::Statement::Variable") and $current->content =~ /\A\s*(?:my|our)\b/ and not $current->content =~ /\bsub\b/
$current->isa("PPI::Statement::Variable") $current->content =~ /\A\s*(?:my|our)\b/ not $current->content =~ /\bsub\b/
Truth table50%2/4
A and B and not(C)
A= $current->isa("PPI::Statement::Variable")B= $current->content =~ /\A\s*(?:my|our)\b/C= not $current->content =~ /\bsub\b/
ABCresult
0XX0
10X0
1100
1111
2012 && $current->content() =~ /\A\s*(?:my|our)\b/
2013 && $current->content() !~ /\bsub\b/) {
2014 # A simple file-scoped declaration: the POD is still this
2015 # routine's documentation.
2016 3 $skipped_declaration = 1;
2017 } else {
2018 # Hit non-POD, non-whitespace - stop
2019 254 last;
2020 }
2021 1471 $current = $current->previous_sibling();
2022 }
2023  
2024 # A POD token can span several routines (and the module-level sections
2025 # before the first one). Keep the section that documents this routine,
2026 # stopping at the next heading that belongs to another method. Headings
2027 # such as SYNOPSIS or NOTES belong to the routine and must be kept.
2028 778 ▶ if($pod && defined($name) && $pod =~ /^=head([1-6])\s+\Q$name\E\b/m) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod and defined $name and $pod =~ /^=head([1-6])\s+\Q$name\E\b/m) 519 259 778
Condition66%4/6
$pod and defined $name and $pod =~ /^=head([1-6])\s+\Q$name\E\b/m
!ll&&!rl&&r
2590519
$pod and defined $name
!ll&&!rl&&r
2590519
MC/DC33%1/3
$pod and defined $name and $pod =~ /^=head([1-6])\s+\Q$name\E\b/m
$pod defined $name $pod =~ /^=head([1-6])\s+\Q$name\E\b/m
Truth table50%2/4
A and B and C
A= $podB= defined $nameC= $pod =~ /^=head([1-6])\s+\Q$name\E\b/m
ABCresult
0XX0
10X0
1100
1111
2029 519 my ($level, $start) = ($1, $-[0]);
2030 519 my $section = substr($pod, $start);
2031  
2032 519 my $method_names = {};
2033 519 ▶ if(my $doc = eval { $sub->document }) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $doc = eval { do { $sub->document } }) 519 0 519
2034 519 ▶ $method_names = $self->{_pod_method_names}{refaddr($doc)} ||= do {
Condition66%2/3
$self->{"_pod_method_names"}{builtin::refaddr($doc)} ||= do { my %names; my $subs = $doc->find("PPI::Statement::Sub"); foreach my $method (@{$subs or [];}) { my $method_name = eval { do { $method->name } }; $names{$method_name} = 1 if defined $method_name; } ; \%names }
l!l&&r!l&&!r
2902290
MC/DC0%0/2
$self->{"_pod_method_names"}{builtin::refaddr($doc)} ||= do { my %names; my $subs = $doc->find("PPI::Statement::Sub"); foreach my $method (@{$subs or [];}) { my $method_name = eval { do { $method->name } }; $names{$method_name} = 1 if defined $method_name; } ; \%names }
$self->{"_pod_method_names"}{builtin::refaddr($doc)} do { my %names; my $subs = $doc->find("PPI::Statement::Sub"); foreach my $method (@{$subs or [];}) { my $method_name = eval { do { $method->name } }; $names{$method_name} = 1 if defined $method_name; } ; \%names }
Truth table66%2/3
A ||= B
A= $self->{"_pod_method_names"}{builtin::refaddr($doc)}B= do { my %names; my $subs = $doc->find("PPI::Statement::Sub"); foreach my $method (@{$subs or [];}) { my $method_name = eval { do { $method->name } }; $names{$method_name} = 1 if defined $method_name; } ; \%names }
ABresult
1X1
011
000
2035 229 my %names;
2036 229 my $subs = $doc->find('PPI::Statement::Sub');
2037 229 ▶ for my $method (@{ $subs || [] }) {
Condition50%1/2
$subs || []
l!l
2290
MC/DC0%0/1
$subs || []
$subs
Truth table50%1/2
A
A= $subs
Aresult
11
00
2038 1214 my $method_name = eval { $method->name };
2039 1214 ▶ $names{$method_name} = 1 if defined($method_name);
Branch: 1 branch
BranchTrueFalseTotal
if defined $method_name 1214 0 1214
2040 }
2041 229 \%names;
2042 };
2043 }
2044  
2045 519 my $cut;
2046 519 ▶ while($section =~ /^=head([1-6])\s+(.+?)\s*$/mg) {
Branch: 1 branch
BranchTrueFalseTotal
if ($section =~ /^=head([1-6])\s+(.+?)\s*$/gm) 2375 513 2888
2047 2375 my ($heading_level, $title) = ($1, $2);
2048 2375 ▶ next if($-[0] == 0); # the routine's own heading
Branch: 1 branch
BranchTrueFalseTotal
if $-[0] == 0 519 1856 2375
2049 1856 ▶ if($heading_level < $level
Branch: 1 branch
BranchTrueFalseTotal
if ($heading_level < $level or $heading_level == $level and $method_names->{$title}) 6 1850 1856
Condition83%5/6
$heading_level < $level or $heading_level == $level and $method_names->{$title}
l!l&&r!l&&!r
061850
$heading_level == $level and $method_names->{$title}
!ll&&!rl&&r
184736
MC/DC66%2/3
$heading_level < $level or $heading_level == $level and $method_names->{$title}
$heading_level < $level $heading_level == $level $method_names->{$title}
Truth table75%3/4
A or B and C
A= $heading_level < $levelB= $heading_level == $levelC= $method_names->{$title}
ABCresult
1XX1
0111
00X0
0100
2050 || ($heading_level == $level && $method_names->{$title})) {
2051 6 $cut = $-[0];
2052 6 last;
2053 }
2054 }
2055 519 ▶ if(defined($cut)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $cut) 6 513 519
2056 6 $section = substr($section, 0, $cut);
2057 6 $section =~ s/\s+\z//;
2058 }
2059 519 $pod = $section;
2060 }
2061  
2062 778 return $pod;
2063 }
2064  
2065 # --------------------------------------------------
2066 # _pod_documents_file_write
2067 #
2068 # Purpose: Decide whether a routine's POD documents
2069 # creating or writing a file as part of
2070 # its contract, so the generated schema can
2071 # turn off the harness's leftover-file
2072 # check for it.
2073 # Entry: $pod - the routine's raw POD text, or
2074 # undef when it has none.
2075 # Exit: Returns 1 if the SIDE EFFECTS section
2076 # says a file is created, written,
2077 # overwritten or updated; 0 otherwise.
2078 # Side effects: None.
2079 # Notes: Only the SIDE EFFECTS section is examined.
2080 # A file mentioned while describing an
2081 # argument or an example is not a
2082 # documented side effect.
2083 # --------------------------------------------------
2084 767 ▶sub _pod_documents_file_write {
Subroutine _pod_documents_file_write: called CC=7 SCAR=19.5
2085 767 my ($self, $pod) = @_;
2086  
2087 767 ▶ return 0 unless defined($pod) && length($pod);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $pod and length $pod 253 514 767
Condition100%3/3
defined $pod and length $pod
!ll&&!rl&&r
1252514
MC/DC100%2/2
defined $pod and length $pod
defined $pod length $pod
Truth table100%3/3
A and B
A= defined $podB= length $pod
ABresult
0X0
100
111
2088  
2089 514 my ($section) = $pod =~ /^=head[1-4]\s+SIDE\s+EFFECTS\b(.*?)(?=^=head[1-4]\b|\z)/mis;
2090 514 ▶ return 0 unless defined($section) && length($section);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $section and length $section 446 68 514
Condition66%2/3
defined $section and length $section
!ll&&!rl&&r
446068
MC/DC50%1/2
defined $section and length $section
defined $section length $section
Truth table66%2/3
A and B
A= defined $sectionB= length $section
ABresult
0X0
100
111
2091  
2092 68 ▶ return 1 if $section =~ /\b(?:creates?|writes?|rewrites?|overwrites?|updates?)\b[^.\n]*\bfiles?\b/i;
Branch: 1 branch
BranchTrueFalseTotal
if $section =~ /\b(?:creates?|writes?|rewrites?|overwrites?|updates?)\b[^.\n]*\bfiles?\b/i 10 58 68
2093 58 ▶ return 1 if $section =~ /\bfiles?\b[^.\n]*\b(?:is|are)\s+(?:created|written|rewritten|overwritten|updated)\b/i;
Branch: 1 branch
BranchTrueFalseTotal
if $section =~ /\bfiles?\b[^.\n]*\b(?:is|are)\s+(?:created|written|rewritten|overwritten|updated)\b/i 0 58 58
2094  
2095 58 return 0;
2096 }
2097  
2098 # --------------------------------------------------
2099 # _analyze_method
2100 #
2101 # Purpose: Perform full multi-source analysis of
2102 # a single method and produce a complete
2103 # schema hashref, combining POD analysis,
2104 # code pattern detection, signature
2105 # analysis, validator schema extraction,
2106 # confidence scoring, relationship
2107 # detection, and modern Perl feature
2108 # extraction.
2109 #
2110 # Entry: $method - a method hashref as produced
2111 # by _find_methods, containing
2112 # at minimum: name, body, pod.
2113 #
2114 # Exit: Returns a schema hashref containing:
2115 # function, input, output, _confidence,
2116 # _analysis, _notes, and optionally:
2117 # new, accessor, relationships,
2118 # _yamltest_hints, _attributes,
2119 # _modern_features, _fields, _model,
2120 # _low_confidence.
2121 #
2122 # Side effects: Logs progress to stdout when verbose
2123 # is set. May carp or croak if
2124 # strict_pod is enabled and POD/code
2125 # disagreements are found.
2126 #
2127 # Notes: This is the central analysis entry
2128 # point — it orchestrates all other
2129 # analysis helpers and merges their
2130 # results. The non-invasive reasoning
2131 # layer (Model::Method, Analyzer::*)
2132 # runs after the main schema is built
2133 # and attaches metadata only.
2134 # --------------------------------------------------
2135 768 ▶sub _analyze_method {
Subroutine _analyze_method: called CC=58 SCAR=42.4
2136 768 my ($self, $method) = @_;
2137 768 my $code = $method->{body};
2138 768 my $pod = $method->{pod};
2139  
2140 # Extract modern features
2141 768 my $attributes = $self->_extract_subroutine_attributes($code);
2142 768 my $postfix_derefs = $self->_analyze_postfix_dereferencing($code);
2143 768 my $fields = $self->_extract_field_declarations($code);
2144  
2145 # If this method came from a class, use those field declarations
2146 0 ▶ if ($method->{fields} && keys %{$method->{fields}}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method->{"fields"} and keys %{$$method{"fields"};}) 0 768 768
Condition33%1/3
$method->{"fields"} and keys %{$$method{"fields"};}
!ll&&!rl&&r
76800
MC/DC0%0/2
$method->{"fields"} and keys %{$$method{"fields"};}
$method->{"fields"} keys %{$$method{"fields"};}
Truth table33%1/3
A and B
A= $method->{"fields"}B= keys %{$$method{"fields"};}
ABresult
0X0
100
111
2147 0 $fields = $method->{fields};
2148 }
2149  
2150 my $schema = {
2151 function => $method->{name},
2152 768 _confidence => {
2153 'input' => {},
2154 'output' => {}
2155 },
2156 input => {},
2157 output => {},
2158 setup => undef,
2159 transforms => {},
2160 };
2161  
2162 # Analyze different sources
2163 768 my $pod_params = $self->_analyze_pod($pod);
2164 768 my $code_params = $self->_analyze_code($code, $method);
2165  
2166 # Neither analysis may hand a reference string to the schema as a parameter.
2167 768 $self->_sanitize_parameter_names($pod_params, 'POD analysis');
2168 768 $self->_sanitize_parameter_names($code_params, 'code analysis');
2169  
2170 # Validate POD/code agreement if strict mode is enabled.
2171 # Skip when there is no POD at all — strict_pod checks accuracy of
2172 # existing documentation, not whether every method is documented.
2173 768 ▶ if ($self->{strict_pod} && $pod) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"strict_pod"} and $pod) 375 393 768
Condition100%3/3
$self->{"strict_pod"} and $pod
!ll&&!rl&&r
33459375
MC/DC100%2/2
$self->{"strict_pod"} and $pod
$self->{"strict_pod"} $pod
Truth table100%3/3
A and B
A= $self->{"strict_pod"}B= $pod
ABresult
0X0
100
111
2174 my @validation_errors = $self->_validate_pod_code_agreement(
2175 $pod_params,
2176 $code_params,
2177 $method->{name},
2178 {
2179 375 ignore_self => 1,
2180 allow_renames => 1,
2181 }
2182 );
2183  
2184 375 ▶ if (@validation_errors) {
Branch: 1 branch
BranchTrueFalseTotal
if (@validation_errors) 30 345 375
2185 30 my $error_msg = "POD/Code disagreement in method '$method->{name}':\n " .
2186 join("\n ", @validation_errors);
2187  
2188 # Add to schema for reference even if we croak
2189 30 $schema->{_pod_validation_errors} = \@validation_errors;
2190  
2191 # Either croak immediately or log based on configuration
2192 30 ▶ if($self->{strict_pod} == $STRICT_POD_FATAL) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{'strict_pod'} == $STRICT_POD_FATAL) { } 4 26 30
2193 4 croak("[POD STRICT] $error_msg");
2194 } else { # 1 = warnings
2195 26 carp("[POD STRICT] $error_msg");
2196 # Continue with analysis, but mark as problematic
2197 26 $schema->{_pod_disagreement} = 1;
2198 }
2199 }
2200 371 $schema->{_strict_pod_level} = $self->{strict_pod};
2201 }
2202  
2203 764 my $validator_params = $self->_extract_validator_schema($code);
2204  
2205 764 ▶ if ($validator_params) {
Branch: 1 branch
BranchTrueFalseTotal
if ($validator_params) { } 14 750 764
2206 14 $schema->{input} = $validator_params->{input};
2207 14 $schema->{input_style} = 'hash';
2208 14 $schema->{_confidence}{input} = { 'factors' => [ 'Determined from validator' ], 'level' => 'high' };
2209 $schema->{_analysis}{confidence_factors}{input} = [
2210 14 'Input schema extracted from validator'
2211 ];
2212 # =head4 Input spec overrides take highest priority — apply them on top of
2213 # the validator schema so authors can tune test constraints (optional,
2214 # memberof, matches) without altering the runtime validation call.
2215 14 for my $name (keys %$pod_params) {
2216 21 ▶ next unless ($pod_params->{$name}{_source} // '') eq SOURCE_INPUT_SPEC;
Branch: 1 branch
BranchTrueFalseTotal
unless ($pod_params->{$name}{"_source"} // "") eq "input_spec" 0 21 21
Condition50%1/2
$pod_params->{$name}{"_source"} // ""
l!l
210
MC/DC0%0/1
$pod_params->{$name}{"_source"} // ""
$pod_params->{$name}{"_source"}
Truth table50%1/2
A
A= $pod_params->{$name}{"_source"}
Aresult
11
00
2217 21 my $pod_p = $pod_params->{$name};
2218 21 ▶ $schema->{input}{$name} //= {};
Condition50%1/2
$schema->{"input"}{$name} //= {}
l!l
210
MC/DC0%0/1
$schema->{"input"}{$name} //= {}
$schema->{"input"}{$name}
Truth table50%1/2
A
A= $schema->{"input"}{$name}
Aresult
11
00
2219 21 ▶ $schema->{input}{$name}{optional} = $pod_p->{optional} if defined $pod_p->{optional};
Branch: 1 branch
BranchTrueFalseTotal
if defined $pod_p->{"optional"} 15 6 21
2220 21 ▶ $schema->{input}{$name}{memberof} = $pod_p->{memberof} if defined $pod_p->{memberof};
Branch: 1 branch
BranchTrueFalseTotal
if defined $pod_p->{"memberof"} 0 21 21
2221 21 ▶ $schema->{input}{$name}{matches} = $pod_p->{matches} if defined $pod_p->{matches};
Branch: 1 branch
BranchTrueFalseTotal
if defined $pod_p->{"matches"} 0 21 21
2222 21 ▶ $schema->{input}{$name}{type} = $pod_p->{type} if defined $pod_p->{type};
Branch: 1 branch
BranchTrueFalseTotal
if defined $pod_p->{"type"} 21 0 21
2223 21 ▶ $schema->{input}{$name}{min} = $pod_p->{min} if defined $pod_p->{min};
Branch: 1 branch
BranchTrueFalseTotal
if defined $pod_p->{"min"} 3 18 21
2224 21 ▶ $schema->{input}{$name}{max} = $pod_p->{max} if defined $pod_p->{max};
Branch: 1 branch
BranchTrueFalseTotal
if defined $pod_p->{"max"} 3 18 21
2225  
2226 # These constraints are documented, even though the field's
2227 # _source stays the type-checking marker (SOURCE_VALIDATOR).
2228 21 for my $key (qw(min max memberof matches nomatch notmemberof)) {
2229 126 ▶ next unless defined $pod_p->{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $pod_p->{$key} 120 6 126
2230 6 $schema->{input}{$name}{_constraint_source}{$key} = SOURCE_INPUT_SPEC;
2231 }
2232 }
2233  
2234 # Not every validator extractor fills in per-parameter provenance, so
2235 # stamp the one source value here too. The harness treats a
2236 # 'validator' source as proof that the routine checks types; POD and
2237 # code-derived sources describe intent only.
2238 14 ▶ $schema->{input}{$_}{_source} //= SOURCE_VALIDATOR for keys %{$schema->{input}};
Condition50%1/2
$schema->{"input"}{$_}{"_source"} //= "validator"
l!l
043
MC/DC0%0/1
$schema->{"input"}{$_}{"_source"} //= "validator"
$schema->{"input"}{$_}{"_source"}
Truth table50%1/2
A
A= $schema->{"input"}{$_}{"_source"}
Aresult
11
00
2239 } else {
2240 # Merge field declarations into code_params before merging analyses
2241 750 ▶ if (keys %$fields) {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %$fields) 0 750 750
2242 0 $self->_merge_field_declarations($code_params, $fields);
2243 }
2244  
2245 # A lone documented input parameter may be the whole argument list
2246 # under another name; the helper decides from the body and folds the
2247 # code's facts about that argument onto the documented name.
2248 750 $self->_positional_pod_input($pod_params, $code_params, $code);
2249  
2250 # Merge analyses
2251 750 $schema->{input} = $self->_merge_parameter_analyses(
2252 $pod_params,
2253 $code_params,
2254 );
2255 }
2256  
2257 # ----------------------------------------
2258 # Legacy Output Analysis (unchanged)
2259 # ----------------------------------------
2260  
2261 $schema->{output} = $self->_analyze_output(
2262 $method->{pod},
2263 $method->{body},
2264 $method->{name}
2265 764 );
2266  
2267  
2268 # Detect accessor methods
2269 764 $self->_detect_accessor_methods($method, $schema);
2270  
2271 # Detect if this is an instance method that needs object instantiation
2272 # Constructors never require object instantiation
2273 764 my $needs_object = $self->_needs_object_instantiation($method->{name}, $method->{body}, $method);
2274 764 ▶ if($method->{name} ne 'new' && $needs_object) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method->{"name"} ne "new" and $needs_object) 378 386 764
Condition100%3/3
$method->{"name"} ne "new" and $needs_object
!ll&&!rl&&r
93293378
MC/DC100%2/2
$method->{"name"} ne "new" and $needs_object
$method->{"name"} ne "new" $needs_object
Truth table100%3/3
A and B
A= $method->{"name"} ne "new"B= $needs_object
ABresult
0X0
100
111
2275 378 $schema->{new} = $needs_object;
2276 378 $self->_log(" NEW: Method requires object instantiation: $needs_object");
2277 }
2278  
2279 # Calculate confidences
2280 764 my $input_confidence = $schema->{_confidence}{'input'};
2281 764 ▶ if(!ref($input_confidence)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (ref $input_confidence) 0 764 764
2282 0 $input_confidence = $schema->{_confidence}{'input'} = $self->_calculate_input_confidence($schema->{input});
2283 }
2284 764 my $output_confidence = $schema->{_confidence}{'output'} = $self->_calculate_output_confidence($schema->{output});
2285  
2286 # Add metadata
2287 764 $schema->{_notes} = $self->_generate_notes($schema->{input});
2288  
2289 # Add analytics
2290 764 ▶ $schema->{_analysis} ||= {};
Condition100%2/2
$schema->{"_analysis"} ||= {}
l!l
14750
MC/DC100%1/1
$schema->{"_analysis"} ||= {}
$schema->{"_analysis"}
Truth table100%2/2
A
A= $schema->{"_analysis"}
Aresult
11
00
2291 764 $schema->{_analysis}{input_confidence} = $input_confidence->{level};
2292 764 $schema->{_analysis}{output_confidence} = $output_confidence->{level};
2293 764 ▶ $schema->{_analysis}{confidence_factors} ||= {};
Condition100%2/2
$schema->{"_analysis"}{"confidence_factors"} ||= {}
l!l
14750
MC/DC100%1/1
$schema->{"_analysis"}{"confidence_factors"} ||= {}
$schema->{"_analysis"}{"confidence_factors"}
Truth table100%2/2
A
A= $schema->{"_analysis"}{"confidence_factors"}
Aresult
11
00
2294 764 ▶ $schema->{_analysis}{confidence_factors}{input} ||= $input_confidence->{factors};
Condition100%3/3
$schema->{"_analysis"}{"confidence_factors"}{"input"} ||= $input_confidence->{"factors"}
l!l&&r!l&&!r
146744
MC/DC100%2/2
$schema->{"_analysis"}{"confidence_factors"}{"input"} ||= $input_confidence->{"factors"}
$schema->{"_analysis"}{"confidence_factors"}{"input"} $input_confidence->{"factors"}
Truth table100%3/3
A ||= B
A= $schema->{"_analysis"}{"confidence_factors"}{"input"}B= $input_confidence->{"factors"}
ABresult
1X1
011
000
2295 764 ▶ $schema->{_analysis}{confidence_factors}{output} ||= $output_confidence->{factors};
Condition33%1/3
$schema->{"_analysis"}{"confidence_factors"}{"output"} ||= $output_confidence->{"factors"}
l!l&&r!l&&!r
07640
MC/DC0%0/2
$schema->{"_analysis"}{"confidence_factors"}{"output"} ||= $output_confidence->{"factors"}
$schema->{"_analysis"}{"confidence_factors"}{"output"} $output_confidence->{"factors"}
Truth table33%1/3
A ||= B
A= $schema->{"_analysis"}{"confidence_factors"}{"output"}B= $output_confidence->{"factors"}
ABresult
1X1
011
000
2296  
2297 764 foreach my $mode('input', 'output') {
2298 1528 $self->_set_defaults($schema, $mode);
2299 }
2300  
2301 # Optionally store detailed per-parameter analysis
2302 764 ▶ if ($input_confidence->{per_parameter}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($input_confidence->{"per_parameter"}) 0 764 764
2303 0 $schema->{_analysis}{per_parameter_scores} = $input_confidence->{per_parameter};
2304 }
2305  
2306 # Calculate overall confidence (for backward compatibility)
2307 764 my $input_level = $input_confidence->{level};
2308 764 my $output_level = $output_confidence->{level};
2309  
2310 764 my %level_rank = (
2311 none => 0,
2312 very_low => 1,
2313 low => 2,
2314 medium => 3,
2315 high => 4
2316 );
2317  
2318 # Overall is the lower of input and output
2319 764 ▶ $input_level //= 'none';
Condition100%2/2
$input_level //= "none"
l!l
88676
MC/DC100%1/1
$input_level //= "none"
$input_level
Truth table100%2/2
A
A= $input_level
Aresult
11
00
2320 764 ▶ $output_level //= 'none';
Condition50%1/2
$output_level //= "none"
l!l
7640
MC/DC0%0/1
$output_level //= "none"
$output_level
Truth table50%1/2
A
A= $output_level
Aresult
11
00
2321 764 ▶ my $overall = $level_rank{$input_level} < $level_rank{$output_level} ? $input_level : $output_level;
Branch: 1 branch
BranchTrueFalseTotal
$level_rank{$input_level} < $level_rank{$output_level} ? : 663 101 764
2322  
2323 764 $schema->{_analysis}{overall_confidence} = $overall;
2324  
2325 # Analyze parameter relationships
2326 764 my $relationships = $self->_analyze_relationships($method);
2327 764 ▶ if ($relationships && @{$relationships}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($relationships and @{$relationships;}) 7 757 764
Condition66%2/3
$relationships and @{$relationships;}
!ll&&!rl&&r
07577
MC/DC50%1/2
$relationships and @{$relationships;}
$relationships @{$relationships;}
Truth table66%2/3
A and B
A= $relationshipsB= @{$relationships;}
ABresult
0X0
100
111
2328 7 $schema->{relationships} = $relationships;
2329 7 $self->_log(" Found " . scalar(@$relationships) . " parameter relationships");
2330 }
2331  
2332 # Store modern feature info in schema
2333 764 ▶ $schema->{_attributes} = $attributes if keys %$attributes;
Branch: 1 branch
BranchTrueFalseTotal
if keys %$attributes 0 764 764
2334 764 ▶ $schema->{_modern_features}{postfix_dereferencing} = $postfix_derefs if keys %$postfix_derefs;
Branch: 1 branch
BranchTrueFalseTotal
if keys %$postfix_derefs 0 764 764
2335 764 ▶ $schema->{_fields} = $fields if keys %$fields;
Branch: 1 branch
BranchTrueFalseTotal
if keys %$fields 0 764 764
2336  
2337 # Store class info if this is a class method
2338 764 ▶ if ($method->{class}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method->{"class"}) 0 764 764
2339 0 $schema->{_class} = $method->{class};
2340 }
2341  
2342 764 my $hints = $self->_extract_test_hints($method, $schema);
2343 764 $self->_extract_pod_examples($pod, $hints);
2344  
2345 764 for my $k (qw(boundary_values invalid_inputs valid_inputs equivalence_classes)) {
2346 3056 my %seen;
2347 $hints->{$k} = [
2348 189 ▶ grep { !$seen{ defined $_ ? $_ : '__undef__' }++ }
Branch: 1 branch
BranchTrueFalseTotal
defined $_ ? : 189 0 189
2349 3056 @{ $hints->{$k} }
2350 ];
2351 }
2352  
2353 # --------------------------------------------------
2354 # YAML test hints: numeric boundaries
2355 # --------------------------------------------------
2356 764 ▶ if ($self->_method_has_numeric_intent($schema)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_method_has_numeric_intent($schema)) 186 578 764
2357 186 ▶ $schema->{_yamltest_hints} ||= {};
Condition50%1/2
$schema->{"_yamltest_hints"} ||= {}
l!l
0186
MC/DC0%0/1
$schema->{"_yamltest_hints"} ||= {}
$schema->{"_yamltest_hints"}
Truth table50%1/2
A
A= $schema->{"_yamltest_hints"}
Aresult
11
00
2358  
2359 # Do not override existing hints
2360 186 ▶ $schema->{_yamltest_hints}{boundary_values} ||= [];
Condition50%1/2
$schema->{"_yamltest_hints"}{"boundary_values"} ||= []
l!l
0186
MC/DC0%0/1
$schema->{"_yamltest_hints"}{"boundary_values"} ||= []
$schema->{"_yamltest_hints"}{"boundary_values"}
Truth table50%1/2
A
A= $schema->{"_yamltest_hints"}{"boundary_values"}
Aresult
11
00
2361  
2362 0 ▶ my %seen = map { (defined $_ ? $_ : '__undef__') => 1 }
Branch: 1 branch
BranchTrueFalseTotal
defined $_ ? : 0 0 0
2363 186 @{ $schema->{_yamltest_hints}{boundary_values} };
2364  
2365 186 foreach my $v (@{ $self->_numeric_boundary_values }) {
2366 929 ▶ my $key = defined $v ? $v : '__undef__';
Branch: 1 branch
BranchTrueFalseTotal
defined $v ? : 928 1 929
2367 929 ▶ push @{ $schema->{_yamltest_hints}{boundary_values} }, $v unless $seen{$key}++;
Branch: 1 branch
BranchTrueFalseTotal
unless $seen{$key}++ 929 0 929
2368 }
2369  
2370 186 $self->_log(' HINTS: Added numeric boundary values');
2371 }
2372  
2373 764 ▶ if (keys %$hints) {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %$hints) 764 0 764
2374 764 ▶ $schema->{_yamltest_hints} ||= {};
Condition100%2/2
$schema->{"_yamltest_hints"} ||= {}
l!l
186578
MC/DC100%1/1
$schema->{"_yamltest_hints"} ||= {}
$schema->{"_yamltest_hints"}
Truth table100%2/2
A
A= $schema->{"_yamltest_hints"}
Aresult
11
00
2375 764 foreach my $k (keys %$hints) {
2376 $schema->{_yamltest_hints}{$k} = $hints->{$k}
2377 3056 ▶ unless exists $schema->{_yamltest_hints}{$k};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $schema->{"_yamltest_hints"}{$k} 2870 186 3056
2378 }
2379 }
2380  
2381 764 ▶ if(($level_rank{$overall} < $level_rank{$LEVEL_MEDIUM}) &&
Branch: 1 branch
BranchTrueFalseTotal
if ($level_rank{$overall} < $level_rank{$LEVEL_MEDIUM} and $level_rank{$overall} < $self->{"confidence_threshold"} * 4) 677 87 764
Condition100%3/3
$level_rank{$overall} < $level_rank{$LEVEL_MEDIUM} and $level_rank{$overall} < $self->{"confidence_threshold"} * 4
!ll&&!rl&&r
978677
MC/DC100%2/2
$level_rank{$overall} < $level_rank{$LEVEL_MEDIUM} and $level_rank{$overall} < $self->{"confidence_threshold"} * 4
$level_rank{$overall} < $level_rank{$LEVEL_MEDIUM} $level_rank{$overall} < $self->{"confidence_threshold"} * 4
Truth table100%3/3
A and B
A= $level_rank{$overall} < $level_rank{$LEVEL_MEDIUM}B= $level_rank{$overall} < $self->{"confidence_threshold"} * 4
ABresult
0X0
100
111
2382 ($level_rank{$overall} < ($self->{confidence_threshold} * 4))) {
2383 677 $schema->{_low_confidence} = 1
2384 }
2385  
2386 # ----------------------------------------
2387 # Non-invasive reasoning layer
2388 # ----------------------------------------
2389  
2390 my $method_model = App::Test::Generator::Model::Method->new(
2391 name => $method->{name},
2392 source => $method->{body},
2393 764 );
2394  
2395 764 my $return_analyzer = App::Test::Generator::Analyzer::Return->new();
2396 764 $return_analyzer->analyze($method_model);
2397  
2398 # Let model learn from finalized schema
2399 764 ▶ if ($schema->{output}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"output"}) 764 0 764
2400 764 $method_model->absorb_legacy_output($schema->{output});
2401 }
2402  
2403 764 $method_model->resolve_return_type();
2404 764 $method_model->resolve_classification();
2405 764 $method_model->resolve_confidence();
2406  
2407 # Attach only metadata
2408 $schema->{_model} = {
2409 764 classification => $method_model->classification,
2410 confidence => $method_model->confidence,
2411 };
2412  
2413 # ----------------------------------------
2414 # Return Meta Analysis (Non-invasive)
2415 # ----------------------------------------
2416  
2417 764 my $meta = App::Test::Generator::Analyzer::ReturnMeta->new();
2418 764 my $analysis = $meta->analyze($schema);
2419  
2420 764 $schema->{_analysis}{stability_score} = $analysis->{stability_score};
2421 764 $schema->{_analysis}{consistency_score} = $analysis->{consistency_score};
2422 764 $schema->{_analysis}{risk_flags} = $analysis->{risk_flags};
2423  
2424 # ----------------------------------------
2425 # Side Effect Analysis (Non-invasive)
2426 # ----------------------------------------
2427  
2428 764 my $se = App::Test::Generator::Analyzer::SideEffect->new();
2429  
2430 764 my $effects = $se->analyze($method);
2431  
2432 764 $schema->{_analysis}{side_effects} = $effects;
2433  
2434 # A routine whose documented side effects include creating or writing a
2435 # file is doing its job when it leaves that file behind, so the harness's
2436 # leftover-file check must not report it. Record the contract here for
2437 # _write_schema to emit as check_files: 0.
2438 764 ▶ if($self->_pod_documents_file_write($pod)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_pod_documents_file_write($pod)) 9 755 764
2439 9 $schema->{_analysis}{side_effects}{writes_file} = 1;
2440 }
2441  
2442 # ----------------------------------------
2443 # Complexity Analysis (Non-invasive)
2444 # ----------------------------------------
2445  
2446 764 my $cx = App::Test::Generator::Analyzer::Complexity->new();
2447 764 my $complexity = $cx->analyze($method);
2448  
2449 764 $schema->{_analysis}{complexity} = $complexity;
2450  
2451 764 return $schema;
2452 }
2453  
2454 # --------------------------------------------------
2455 # _method_has_numeric_intent
2456 #
2457 # Purpose: Determine whether a method schema
2458 # has numeric intent — either a numeric
2459 # output type or at least one required
2460 # numeric input parameter — to decide
2461 # whether to add standard numeric
2462 # boundary hint values.
2463 #
2464 # Entry: $schema - schema hashref as built by
2465 # _analyze_method.
2466 #
2467 # Exit: Returns 1 if numeric intent is
2468 # detected, 0 otherwise.
2469 #
2470 # Side effects: None.
2471 # --------------------------------------------------
2472 764 ▶sub _method_has_numeric_intent {
Subroutine _method_has_numeric_intent: called CC=9 SCAR=22.0
2473 764 my ($self, $schema) = @_;
2474  
2475 # Numeric output
2476 764 ▶ return 1 if ($schema->{output} && $schema->{output}{type} && $schema->{output}{type} =~ /^(number|integer)$/);
Branch: 1 branch
BranchTrueFalseTotal
if $schema->{"output"} and $schema->{"output"}{"type"} and $schema->{"output"}{"type"} =~ /^(number|integer)$/ 158 606 764
Condition83%5/6
$schema->{"output"} and $schema->{"output"}{"type"} and $schema->{"output"}{"type"} =~ /^(number|integer)$/
!ll&&!rl&&r
30576158
$schema->{"output"} and $schema->{"output"}{"type"}
!ll&&!rl&&r
030734
MC/DC66%2/3
$schema->{"output"} and $schema->{"output"}{"type"} and $schema->{"output"}{"type"} =~ /^(number|integer)$/
$schema->{"output"} $schema->{"output"}{"type"} $schema->{"output"}{"type"} =~ /^(number|integer)$/
Truth table75%3/4
A and B and C
A= $schema->{"output"}B= $schema->{"output"}{"type"}C= $schema->{"output"}{"type"} =~ /^(number|integer)$/
ABCresult
0XX0
10X0
1100
1111
2477  
2478 # Numeric inputs
2479 606 ▶ foreach my $p (values %{ $schema->{input} || {} }) {
Condition100%2/2
$schema->{'input'} || {}
l!l
57135
MC/DC100%1/1
$schema->{'input'} || {}
$schema->{'input'}
Truth table100%2/2
A
A= $schema->{'input'}
Aresult
11
00
2480 589 ▶ next if $p->{optional};
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"optional"} 285 304 589
2481 304 ▶ return 1 if ($p->{type} && $p->{type} =~ /^(number|integer)$/);
Branch: 1 branch
BranchTrueFalseTotal
if $p->{"type"} and $p->{"type"} =~ /^(number|integer)$/ 28 276 304
Condition66%2/3
$p->{"type"} and $p->{"type"} =~ /^(number|integer)$/
!ll&&!rl&&r
027628
MC/DC50%1/2
$p->{"type"} and $p->{"type"} =~ /^(number|integer)$/
$p->{"type"} $p->{"type"} =~ /^(number|integer)$/
Truth table66%2/3
A and B
A= $p->{"type"}B= $p->{"type"} =~ /^(number|integer)$/
ABresult
0X0
100
111
2482 }
2483  
2484 578 return 0;
2485 }
2486  
2487 # --------------------------------------------------
2488 # _numeric_boundary_values
2489 #
2490 # Purpose: Return the standard set of numeric
2491 # boundary values used as test hints
2492 # for methods with numeric intent.
2493 #
2494 # Entry: None.
2495 #
2496 # Exit: Returns an arrayref of boundary
2497 # values: [-1, 0, 1, 2, 100].
2498 #
2499 # Side effects: None.
2500 # --------------------------------------------------
2501 185 ▶sub _numeric_boundary_values {
Subroutine _numeric_boundary_values: called CC=1 SCAR=0.0
2502 185 return [ -1, 0, 1, 2, 100 ];
2503 }
2504  
2505 # --------------------------------------------------
2506 # _detect_accessor_methods
2507 #
2508 # Purpose: Detect whether a method is a getter,
2509 # setter, or combined getter/setter
2510 # accessor by analysing assignment and
2511 # return patterns involving $self->{...}.
2512 #
2513 # Entry: $method - method hashref containing
2514 # at minimum 'body' and
2515 # optionally 'pod'.
2516 # $schema - schema hashref (modified
2517 # in place).
2518 #
2519 # Exit: Returns nothing. Modifies $schema in
2520 # place, setting accessor, input,
2521 # input_style, output, and _confidence
2522 # keys as appropriate.
2523 #
2524 # Side effects: Croaks if a getter/setter has more
2525 # than one argument, or if a setter
2526 # returns non-self data.
2527 # Logs detections to stdout when
2528 # verbose is set.
2529 #
2530 # Notes: Four accessor patterns are detected
2531 # in order: (1) combined getter/setter
2532 # with shift, (2) combined getter/setter
2533 # with validated input, (3) getter only,
2534 # (4) setter that returns $self. Methods
2535 # accessing multiple $self fields are
2536 # skipped immediately.
2537 # --------------------------------------------------
2538 764 ▶sub _detect_accessor_methods {
Subroutine _detect_accessor_methods: called CC=62 SCAR=50.4
2539 764 my ($self, $method, $schema) = @_;
2540  
2541 764 my $body = $method->{body};
2542  
2543 # Normalize whitespace for regex sanity
2544 764 my $code = $body;
2545 764 $code =~ s/\s+/ /g;
2546  
2547 # If a method touches more than one $self->{...}, it’s not an accessor.
2548 764 my %fields_seen;
2549 764 ▶ while ($code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}/g) 398 764 1162
2550 398 $fields_seen{$1}++;
2551 }
2552 764 ▶ if (keys(%fields_seen) > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %fields_seen > 1) 45 719 764
2553 45 $self->_log(" Skipping accessor detection: multiple fields accessed");
2554 45 return;
2555 }
2556  
2557 # A store guarded by the presence of an argument is the same get/set
2558 # idiom as `if (@_)`, just written against a named lexical:
2559 #
2560 # my $status = shift;
2561 # return $self->{status} = $status if(defined($status));
2562 # ...
2563 # return $self->{status} || 200;
2564 #
2565 # CGI::Info::status is this shape, and it was being typed as a plain
2566 # function because every branch below only looked for `if (@_)`.
2567 719 my $conditional_arg = 0;
2568 719 ▶ while($code =~ /\bmy\s+\$(\w+)\s*=\s*shift\b/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\bmy\s+\$(\w+)\s*=\s*shift\b/g) 80 698 778
2569 80 my $arg = $1;
2570 # The invocant is shifted too, but a test on $self says nothing
2571 # about whether an argument was supplied.
2572 80 ▶ next if($arg eq 'self');
Branch: 1 branch
BranchTrueFalseTotal
if $arg eq "self" 24 56 80
2573 56 ▶ if($code =~ /(?:if|unless)\s*\(?\s*(?:defined\s*\(?\s*)?\$\Q$arg\E\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:if|unless)\s*\(?\s*(?:defined\s*\(?\s*)?\$\Q$arg\E\b/) 21 35 56
2574 21 $conditional_arg = 1;
2575 21 last;
2576 }
2577 }
2578 # `if (@_)` stays the strongest signal; a named-argument guard is
2579 # weaker evidence and must not turn a heuristic miss into a croak.
2580 # The guard must test the argument itself: CGI::Info::protocol reads
2581 # if($ENV{'SCRIPT_URI'}) and stores a value it computed, which says
2582 # nothing about how the method is called. Reading any `if($x)` as an
2583 # argument guard typed it as a getset accessor, and the harness then
2584 # set a value the routine never looks at.
2585 719 ▶ my $arg_guard = ($code =~ /\bif\s*\(\s*(?:\@_|scalar\s*\(\s*\@_\s*\))/) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$code =~ /\bif\s*\(\s*(?:\@_|scalar\s*\(\s*\@_\s*\))/ ? : 7 712 719
2586  
2587 # -------------------------------
2588 # Getter/Setter combo
2589 # -------------------------------
2590 719 ▶ if (
Branch: 4 branches
BranchTrueFalseTotal
if ($code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/ and $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$1\E['"]?\s*\}\s*;/ and $code =~ /if\s*\(\s*\@_/) { } 0 719 719
elsif ($arg_guard || $conditional_arg and $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*(?:shift|\@_|\$_\[\d+\]|\$\w+)\b/x and $code =~ /return\b/) { } 6 713 719
elsif ($code =~ /return\s+\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*;/) { } 38 675 713
elsif ($code =~ /return\s+\$self\b/ and $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*\$(\w+)\s*;/) { } 6 1322 1328
Condition66%4/6
$code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/ and $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$1\E['"]?\s*\}\s*;/ and $code =~ /if\s*\(\s*\@_/
!ll&&!rl&&r
71810
$code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/ and $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$1\E['"]?\s*\}\s*;/
!ll&&!rl&&r
71801
MC/DC0%0/3
$code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/ and $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$1\E['"]?\s*\}\s*;/ and $code =~ /if\s*\(\s*\@_/
$code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/ $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$1\E['"]?\s*\}\s*;/ $code =~ /if\s*\(\s*\@_/
Truth table50%2/4
A and B and C
A= $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/B= $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$1\E['"]?\s*\}\s*;/C= $code =~ /if\s*\(\s*\@_/
ABCresult
0XX0
10X0
1100
1111
2591 # Require get/set of the same property
2592 $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/ &&
2593 $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$1\E['"]?\s*\}\s*;/ &&
2594 $code =~ /if\s*\(\s*\@_/
2595 ) {
2596 0 my $property = $1;
2597  
2598 0 ▶ if(!defined($property)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $property) 0 0 0
2599 0 ▶ if($code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*shift\s*;/) 0 0 0
2600 0 $property = $1;
2601 }
2602 }
2603  
2604 $schema->{accessor} = {
2605 0 type => 'getset',
2606 property => $property,
2607 };
2608  
2609 0 $self->_log(" Detected getter/setter accessor for property: $property");
2610  
2611 0 ▶ $schema->{input} ||= { value => { type => 'string', optional => 1 } };
Condition0%0/2
$schema->{"input"} ||= {"value", {"type", "string", "optional", 1}}
l!l
00
MC/DC0%0/1
$schema->{"input"} ||= {"value", {"type", "string", "optional", 1}}
$schema->{"input"}
Truth table0%0/2
A
A= $schema->{"input"}
Aresult
11
00
2612  
2613 0 $schema->{input_style} = 'hash';
2614  
2615 $schema->{_confidence}{input} = {
2616 0 level => 'high',
2617 factors => ['Detected combined getter/setter accessor'],
2618 };
2619 0 ▶ if (my $pod = $method->{pod}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $pod = $method->{"pod"}) 0 0 0
2620 0 ▶ if ($pod =~ /\b(LWP::UserAgent(?:::\w+)*)\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /\b(LWP::UserAgent(?:::\w+)*)\b/) 0 0 0
2621 0 my $class = $1;
2622 $schema->{output} = {
2623 0 type => 'object',
2624 isa => $class,
2625 };
2626 0 $schema->{input}{$property} = {
2627 type => 'object',
2628 isa => $class,
2629 optional => 1,
2630 };
2631  
2632 $schema->{_confidence}{output} = {
2633 0 level => 'high',
2634 factors => ['POD specifies UserAgent object'],
2635 };
2636 }
2637 }
2638 ▶ } elsif(($arg_guard || $conditional_arg) &&
Condition88%8/9
$arg_guard || $conditional_arg and $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*(?:shift|\@_|\$_\[\d+\]|\$\w+)\b/x and $code =~ /return\b/
!ll&&!rl&&r
71306
$arg_guard || $conditional_arg and $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*(?:shift|\@_|\$_\[\d+\]|\$\w+)\b/x
!ll&&!rl&&r
691226
$arg_guard or $conditional_arg
l!l&&r!l&&!r
721691
MC/DC75%3/4
$arg_guard || $conditional_arg and $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*(?:shift|\@_|\$_\[\d+\]|\$\w+)\b/x and $code =~ /return\b/
$arg_guard $conditional_arg $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*(?:shift|\@_|\$_\[\d+\]|\$\w+)\b/x $code =~ /return\b/
Truth table71%5/7
A or B and C and D
A= $arg_guardB= $conditional_argC= $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*(?:shift|\@_|\$_\[\d+\]|\$\w+)\b/xD= $code =~ /return\b/
ABCDresult
00XX0
1X0X0
010X0
1X100
01100
1X111
01111
2639 $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*(?:shift|\@_|\$_\[\d+\]|\$\w+)\b/x &&
2640 $code =~ /return\b/
2641 ) {
2642 # -------------------------------
2643 # Getter/Setter (validated input)
2644 # -------------------------------
2645 6 my $property = $1;
2646  
2647 # A named-argument guard is weaker evidence than `if (@_)`, so when
2648 # the method declares more than one parameter assume this is not an
2649 # accessor rather than croaking further down on an ambiguous match.
2650 6 ▶ if($conditional_arg && !$arg_guard &&
Branch: 1 branch
BranchTrueFalseTotal
if ($conditional_arg and not $arg_guard and ref $schema->{"input"} eq "HASH" and scalar keys %{$$schema{"input"};} > 1) 0 6 6
Condition66%6/9
$conditional_arg and not $arg_guard and ref $schema->{"input"} eq "HASH" and scalar keys %{$$schema{"input"};} > 1
!ll&&!rl&&r
420
$conditional_arg and not $arg_guard and ref $schema->{"input"} eq "HASH"
!ll&&!rl&&r
402
$conditional_arg and not $arg_guard
!ll&&!rl&&r
402
MC/DC0%0/4
$conditional_arg and not $arg_guard and ref $schema->{"input"} eq "HASH" and scalar keys %{$$schema{"input"};} > 1
$conditional_arg not $arg_guard ref $schema->{"input"} eq "HASH" scalar keys %{$$schema{"input"};} > 1
Truth table40%2/5
A and not(B) and C and D
A= $conditional_argB= not $arg_guardC= ref $schema->{"input"} eq "HASH"D= scalar keys %{$$schema{"input"};} > 1
ABCDresult
0XXX0
10XX0
110X0
11100
11111
2651 2 (ref($schema->{input}) eq 'HASH') && (scalar(keys %{$schema->{input}}) > 1)) {
2652 0 $self->_log(" Skipping conditional accessor: more than one argument");
2653 0 return;
2654 }
2655  
2656 6 ▶ if(!defined($property)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $property) 6 0 6
2657 6 ▶ if($code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=/) 6 0 6
2658 6 $property = $1;
2659 }
2660 }
2661 6 ▶ if ($code =~ /validate_strict/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /validate_strict/) { } 2 4 6
2662 2 push @{ $schema->{_confidence}{input}{factors} }, 'Setter uses Params::Validate::Strict';
2663 } else {
2664 # ---------------------------------------
2665 # Detect object input via blessed($arg)
2666 # ---------------------------------------
2667 4 ▶ if ($code =~ /blessed\s*\(\s*\$(\w+)\s*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /blessed\s*\(\s*\$(\w+)\s*\)/) { } 0 4 4
2668 0 my $param = $1;
2669  
2670 0 $self->_log(" Detected object input via blessed(\$$param)");
2671  
2672 $schema->{input} = {
2673 0 $param => {
2674 type => 'object',
2675 optional => 1,
2676 }
2677 };
2678  
2679 $schema->{_confidence}{input} = {
2680 0 level => 'high',
2681 factors => ['Input validated by Scalar::Util::blessed'],
2682 };
2683 } else {
2684 # fallback ONLY if nothing known
2685 $schema->{input} ||= {
2686 4 ▶ value => { type => 'string', optional => 1 },
Condition50%1/2
$schema->{"input"} ||= {"value", {"type", "string", "optional", 1}}
l!l
40
MC/DC0%0/1
$schema->{"input"} ||= {"value", {"type", "string", "optional", 1}}
$schema->{"input"}
Truth table50%1/2
A
A= $schema->{"input"}
Aresult
11
00
2687 };
2688 }
2689 };
2690 $schema->{accessor} = {
2691 6 type => 'getset',
2692 property => $property,
2693 };
2694  
2695 6 $self->_log(" Detected getter/setter accessor for property: $property");
2696 6 ▶ if (my $pod = $method->{pod}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $pod = $method->{"pod"}) 2 4 6
2697 2 ▶ if ($pod =~ /\b(LWP::UserAgent(?:::\w+)*)\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /\b(LWP::UserAgent(?:::\w+)*)\b/) 0 2 2
2698 0 my $class = $1;
2699 $schema->{output} = {
2700 0 type => 'object',
2701 isa => $class,
2702 };
2703 0 $schema->{input}{$property} = {
2704 type => 'object',
2705 isa => $class,
2706 optional => 1,
2707 };
2708  
2709 $schema->{_confidence}{output} = {
2710 0 level => 'high',
2711 factors => ['POD specifies UserAgent object'],
2712 };
2713 }
2714 }
2715 # Set position 0 on whichever single input parameter already exists.
2716 # The parameter may be named differently from the stored property
2717 # (e.g. $dir for the logdir property), so find the existing key
2718 # rather than creating a new entry keyed by $property — doing the
2719 # latter produces a duplicate-position collision between the real
2720 # param and the spurious $property key.
2721 6 ▶ if(ref($schema->{input}) eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $schema->{"input"} eq "HASH") 6 0 6
2722 6 my @input_keys = keys %{$schema->{input}};
2723 6 ▶ if(scalar @input_keys > 1) {
Branch: 2 branches
BranchTrueFalseTotal
if (scalar @input_keys > 1) { } 0 6 6
elsif (@input_keys == 1) { } 6 0 6
2724 0 croak(__PACKAGE__, ': A getset accessor function can have at most one argument');
2725 } elsif(@input_keys == 1) {
2726 6 $schema->{input}{$input_keys[0]}{position} = 0;
2727 } else {
2728 0 $schema->{input}{$property}{position} = 0;
2729 }
2730 }
2731 } elsif ($code =~ /return\s+\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*;/) {
2732 # -------------------------------
2733 # Getter
2734 # -------------------------------
2735 38 my $property = $1;
2736  
2737 # Don't flag mutators like
2738 # sub foo {
2739 # my $self = shift;
2740 # $self->{bar} = shift;
2741 # return $self->{bar};
2742 # }
2743 # Only exclude if the property is being set FROM EXTERNAL INPUT
2744 38 ▶ if($code !~ /\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*=\s*(?:shift|\$\w+\s*=\s*shift|\@_|\$_\[\d+\])/) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($code =~ /\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*=\s*(?:shift|\$\w+\s*=\s*shift|\@_|\$_\[\d+\])/) 37 1 38
2745 37 my @returns = $code =~ /return\b/g;
2746 37 my @self_returns = $code =~ /return\s+\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}/g;
2747 # it's a getter
2748 37 ▶ if (scalar(@returns) == scalar(@self_returns)) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @returns == scalar @self_returns) 35 2 37
2749 # all returns are returning $self->{$property}, so it's a getter
2750 $schema->{accessor} = {
2751 35 type => 'getter',
2752 property => $property,
2753 };
2754  
2755 35 $self->_log(" Detected getter accessor for property: $property");
2756  
2757 # A memoised property's initializer is the only evidence of
2758 # what the getter returns:
2759 # $self->{proposals} //= [ map { ... } @{ $self->survivors } ];
2760 # Without it the expression looks like a scalar, and the
2761 # harness validates the returned arrayref as a string.
2762 35 ▶ $schema->{output} ||= {};
Condition50%1/2
$schema->{"output"} ||= {}
l!l
350
MC/DC0%0/1
$schema->{"output"} ||= {}
$schema->{"output"}
Truth table50%1/2
A
A= $schema->{"output"}
Aresult
11
00
2763 35 ▶ if($code =~ /\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*\/\/=\s*\[/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($code =~ m(\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*//=\s*\[)) { } 3 32 35
elsif ($code =~ m[\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*//=\s*\{]) { } 0 32 32
2764 3 $schema->{output}{type} = 'arrayref';
2765 } elsif($code =~ /\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*\/\/=\s*\{/) {
2766 0 $schema->{output}{type} = 'hashref';
2767 }
2768  
2769 $schema->{_confidence}{output} = {
2770 35 level => 'high',
2771 factors => ['Detected getter method'],
2772 };
2773 35 delete $schema->{input};
2774 }
2775 }
2776 ▶ } elsif (
Condition100%3/3
$code =~ /return\s+\$self\b/ and $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*\$(\w+)\s*;/
!ll&&!rl&&r
653166
MC/DC100%2/2
$code =~ /return\s+\$self\b/ and $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*\$(\w+)\s*;/
$code =~ /return\s+\$self\b/ $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*\$(\w+)\s*;/
Truth table100%3/3
A and B
A= $code =~ /return\s+\$self\b/B= $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*\$(\w+)\s*;/
ABresult
0X0
100
111
2777 $code =~ /return\s+\$self\b/ &&
2778 $code =~ /\$self\s*->\s*\{\s*['"]?([^}'"]+)['"]?\s*\}\s*=\s*\$(\w+)\s*;/
2779 ) {
2780 # -------------------------------
2781 # Setter
2782 # -------------------------------
2783 6 my ($property, $param) = ($1, $2);
2784  
2785 $schema->{accessor} = {
2786 6 type => 'setter',
2787 property => $property,
2788 param => $param,
2789 };
2790  
2791 6 $self->_log(" Detected setter accessor for property: $property");
2792  
2793 # A setter that hands the argument to something else before storing
2794 # it, such as CGI::Info::set_logger's
2795 #
2796 # $self->{'logger'} = Log::Abstraction->new($logger);
2797 #
2798 # does not constrain what the argument may be, so the 'string' default
2799 # would invent cases like "a hash ref must die" that the routine
2800 # rightly accepts. Claim 'string' only when every assignment stores the
2801 # argument itself.
2802 6 my $param_type = 'string';
2803 6 ▶ while($code =~ /\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*=\s*([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$self\s*->\s*\{\s*['"]?\Q$property\E['"]?\s*\}\s*=\s*([^;]+);/g) 7 5 12
2804 7 ▶ if($1 =~ /(?:->|::)\w+\s*\([^)]*\$\Q$param\E\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($1 =~ /(?:->|::)\w+\s*\([^)]*\$\Q$param\E\b/) 1 6 7
2805 1 $param_type = 'any';
2806 1 last;
2807 }
2808 }
2809  
2810 $schema->{input} = {
2811 6 $param => { type => $param_type }, # safe default
2812 };
2813 6 $schema->{input_style} = 'hash';
2814  
2815 $schema->{_confidence}{input} = {
2816 6 level => 'high',
2817 factors => ['Detected setter/accessor method'],
2818 };
2819 6 ▶ if($schema->{output}{_returns_self}) {
Branch: 2 branches
BranchTrueFalseTotal
if ($schema->{'output'}{'_returns_self'}) { } 6 0 6
elsif (scalar keys %{$$schema{'output'};} != 0) { } 0 0 0
2820 6 ▶ if($schema->{output}{type} ne 'object') {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"output"}{"type"} ne "object") 0 6 6
2821 0 croak 'Setter can not return data other than $self';
2822 }
2823 6 ▶ if($schema->{output}{isa} ne $self->{_package_name}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"output"}{"isa"} ne $self->{"_package_name"}) 0 6 6
2824 0 croak 'Setter can not return data other than $self';
2825 }
2826 0 } elsif(scalar(keys %{$schema->{output}}) != 0) {
2827 $self->_analysis_error(
2828 method => $method->{name},
2829 0 message => "Setter cannot return data",
2830 );
2831 }
2832 }
2833  
2834 719 ▶ if(exists($schema->{accessor})) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $schema->{"accessor"}) 47 672 719
2835 47 ▶ if($schema->{accessor}{type} && $schema->{accessor}{type} =~ /setter|getset/ && $schema->{input}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"accessor"}{"type"} and $schema->{"accessor"}{"type"} =~ /setter|getset/ and $schema->{"input"}) 12 35 47
Condition66%4/6
$schema->{"accessor"}{"type"} and $schema->{"accessor"}{"type"} =~ /setter|getset/ and $schema->{"input"}
!ll&&!rl&&r
35012
$schema->{"accessor"}{"type"} and $schema->{"accessor"}{"type"} =~ /setter|getset/
!ll&&!rl&&r
03512
MC/DC33%1/3
$schema->{"accessor"}{"type"} and $schema->{"accessor"}{"type"} =~ /setter|getset/ and $schema->{"input"}
$schema->{"accessor"}{"type"} $schema->{"accessor"}{"type"} =~ /setter|getset/ $schema->{"input"}
Truth table50%2/4
A and B and C
A= $schema->{"accessor"}{"type"}B= $schema->{"accessor"}{"type"} =~ /setter|getset/C= $schema->{"input"}
ABCresult
0XX0
10X0
1100
1111
2836 12 for my $param (keys %{ $schema->{input} }) {
2837 12 my $in = $schema->{input}{$param};
2838  
2839 12 ▶ if ($in->{type} && ($in->{type} eq 'object')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($in->{"type"} and $in->{"type"} eq "object") 2 10 12
Condition100%3/3
$in->{"type"} and $in->{"type"} eq "object"
!ll&&!rl&&r
282
MC/DC100%2/2
$in->{"type"} and $in->{"type"} eq "object"
$in->{"type"} $in->{"type"} eq "object"
Truth table100%3/3
A and B
A= $in->{"type"}B= $in->{"type"} eq "object"
ABresult
0X0
100
111
2840 $schema->{output} = {
2841 type => 'object',
2842 2 ▶ ($in->{isa} ? (isa => $in->{isa}) : ()),
Branch: 1 branch
BranchTrueFalseTotal
$in->{'isa'} ? : 0 2 2
2843 };
2844  
2845 $schema->{_confidence}{output} = {
2846 2 level => 'high',
2847 factors => ['Output type propagated from setter input'],
2848 };
2849 }
2850 }
2851 }
2852  
2853 47 ▶ if($schema->{accessor}{type} && $schema->{accessor}{property} && ($schema->{accessor}{type} =~ /getter|getset/) &&
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"accessor"}{"type"} and $schema->{"accessor"}{"property"} and $schema->{"accessor"}{"type"} =~ /getter|getset/ and !defined($schema->{"output"}{"type"}) || $schema->{"output"}{"type"} eq "string") 28 19 47
Condition66%8/12
$schema->{"accessor"}{"type"} and $schema->{"accessor"}{"property"} and $schema->{"accessor"}{"type"} =~ /getter|getset/ and !defined($schema->{"output"}{"type"}) || $schema->{"output"}{"type"} eq "string"
!ll&&!rl&&r
61328
$schema->{"accessor"}{"type"} and $schema->{"accessor"}{"property"} and $schema->{"accessor"}{"type"} =~ /getter|getset/
!ll&&!rl&&r
0641
$schema->{"accessor"}{"type"} and $schema->{"accessor"}{"property"}
!ll&&!rl&&r
0047
not defined $schema->{"output"}{"type"} or $schema->{"output"}{"type"} eq "string"
l!l&&r!l&&!r
02813
MC/DC40%2/5
$schema->{"accessor"}{"type"} and $schema->{"accessor"}{"property"} and $schema->{"accessor"}{"type"} =~ /getter|getset/ and !defined($schema->{"output"}{"type"}) || $schema->{"output"}{"type"} eq "string"
$schema->{"accessor"}{"type"} $schema->{"accessor"}{"property"} $schema->{"accessor"}{"type"} =~ /getter|getset/ not defined $schema->{"output"}{"type"} $schema->{"output"}{"type"} eq "string"
Truth table50%3/6
A and B and C and not(D) or E
A= $schema->{"accessor"}{"type"}B= $schema->{"accessor"}{"property"}C= $schema->{"accessor"}{"type"} =~ /getter|getset/D= not defined $schema->{"output"}{"type"}E= $schema->{"output"}{"type"} eq "string"
ABCDEresult
0XXXX0
10XXX0
110XX0
111000
1111X1
111011
2854 ((!defined($schema->{output}{type})) || ($schema->{output}{type} eq 'string'))) {
2855 28 ▶ if (my $pod = $method->{pod}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $pod = $method->{"pod"}) 17 11 28
2856 # POD says "UserAgent object"
2857 17 ▶ if ($pod =~ /\bUser[- ]?Agent\b.*\bobject\b/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /\bUser[- ]?Agent\b.*\bobject\b/i) 1 16 17
2858 1 $schema->{output}{type} = 'object';
2859 1 $schema->{output}{isa} = 'LWP::UserAgent';
2860  
2861 1 push @{ $schema->{_confidence}{output}{factors} }, 'POD indicates UserAgent object';
2862  
2863 1 $schema->{_confidence}{output}{level} = 'high';
2864 }
2865 }
2866 }
2867 }
2868 }
2869  
2870 # --------------------------------------------------
2871 # _analysis_error
2872 #
2873 # Purpose: Report a fatal analysis error with
2874 # module, method, and file context,
2875 # then croak.
2876 #
2877 # Entry: Named args:
2878 # method - method name string.
2879 # message - error description string.
2880 #
2881 # Exit: Does not return — always croaks.
2882 #
2883 # Side effects: None beyond the croak.
2884 # --------------------------------------------------
2885 2 ▶sub _analysis_error {
Subroutine _analysis_error: called CC=5 SCAR=16.1
2886 2 my ($self, %args) = @_;
2887  
2888 2 ▶ my $method = $args{method} // 'UNKNOWN';
Condition100%2/2
$args{"method"} // "UNKNOWN"
l!l
11
MC/DC100%1/1
$args{"method"} // "UNKNOWN"
$args{"method"}
Truth table100%2/2
A
A= $args{"method"}
Aresult
11
00
2889 2 ▶ my $msg = $args{message} // 'Analysis error';
Condition100%2/2
$args{"message"} // "Analysis error"
l!l
11
MC/DC100%1/1
$args{"message"} // "Analysis error"
$args{"message"}
Truth table100%2/2
A
A= $args{"message"}
Aresult
11
00
2890  
2891 2 ▶ my $module = $self->{_package_name} // 'UNKNOWN';
Condition100%2/2
$self->{"_package_name"} // "UNKNOWN"
l!l
11
MC/DC100%1/1
$self->{"_package_name"} // "UNKNOWN"
$self->{"_package_name"}
Truth table100%2/2
A
A= $self->{"_package_name"}
Aresult
11
00
2892 2 ▶ my $file = $self->{input_file} // 'UNKNOWN';
Condition100%2/2
$self->{"input_file"} // "UNKNOWN"
l!l
11
MC/DC100%1/1
$self->{"input_file"} // "UNKNOWN"
$self->{"input_file"}
Truth table100%2/2
A
A= $self->{"input_file"}
Aresult
11
00
2893  
2894 2 croak join "\n",
2895 $msg,
2896 " Module: $module",
2897 " Method: $method",
2898 " File: $file",
2899 '';
2900 }
2901  
2902 # --------------------------------------------------
2903 # _extract_validator_schema
2904 #
2905 # Purpose: Try each supported validator extractor
2906 # in priority order and return the first
2907 # schema that yields a non-empty input
2908 # spec. Used to detect explicit
2909 # parameter validation declarations
2910 # before falling back to heuristic
2911 # code analysis.
2912 #
2913 # Entry: $code - method body source string.
2914 #
2915 # Exit: Returns a schema hashref on success,
2916 # or undef if no supported validator
2917 # call is detected.
2918 #
2919 # Side effects: None.
2920 #
2921 # Notes: Extractors tried in order:
2922 # Params::Validate::Strict,
2923 # Params::Validate,
2924 # MooseX::Params::Validate,
2925 # Type::Params.
2926 # --------------------------------------------------
2927 764 ▶sub _extract_validator_schema {
Subroutine _extract_validator_schema: called CC=6 SCAR=18.3
2928 764 my ($self, $code) = @_;
2929  
2930 764 for my $extractor ('_extract_pvs_schema', '_extract_pv_schema', '_extract_moosex_params_schema', '_extract_type_params_schema') {
2931 3023 my $res = $self->$extractor($code);
2932 3023 ▶ return $res if ($res && ref($res) eq 'HASH' && keys %{ $res->{input} || {} });
Branch: 1 branch
BranchTrueFalseTotal
if $res and ref $res eq "HASH" and keys %{$res->{"input"} or {};} 14 3009 3023
Condition62%5/8
$res and ref $res eq "HASH" and keys %{$res->{"input"} or {};}
!ll&&!rl&&r
3009014
$res and ref $res eq "HASH"
!ll&&!rl&&r
3009014
$res->{'input'} || {}
l!l
140
MC/DC33%1/3
$res and ref $res eq "HASH" and keys %{$res->{"input"} or {};}
$res ref $res eq "HASH" keys %{$res->{"input"} or {};}
MC/DC0%0/1
$res->{'input'} || {}
$res->{'input'}
Truth table50%2/4
A and B and C
A= $resB= ref $res eq "HASH"C= keys %{$res->{"input"} or {};}
ABCresult
0XX0
10X0
1100
1111
Truth table50%1/2
A
A= $res->{'input'}
Aresult
11
00
2933 }
2934  
2935 750 return;
2936 }
2937  
2938 # --------------------------------------------------
2939 # _parse_schema_hash
2940 #
2941 # Purpose: Parse a PPI block node representing
2942 # a validator schema hash literal and
2943 # return a normalised schema structure
2944 # suitable for use as input spec.
2945 #
2946 # Entry: $hash - a PPI node with a children()
2947 # method, typically a
2948 # PPI::Structure::Block from
2949 # a validate_strict call.
2950 #
2951 # Exit: Returns a hashref with keys:
2952 # input - hashref of param specs
2953 # input_style - 'hash'
2954 # _confidence - confidence hashref
2955 # or undef if parsing fails.
2956 #
2957 # Side effects: None.
2958 # --------------------------------------------------
2959 0 ▶sub _parse_schema_hash {
Subroutine _parse_schema_hash: not called CC=27 SCAR=66.3
2960 0 my ($self, $hash) = @_;
2961  
2962 0 my %result;
2963  
2964 0 for my $child ($hash->children) {
2965 # skip whitespace and operators
2966 0 ▶ if ($child->isa('PPI::Statement') || $child->isa('PPI::Statement::Expression')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($child->isa("PPI::Statement") or $child->isa("PPI::Statement::Expression")) 0 0 0
Condition0%0/3
$child->isa("PPI::Statement") or $child->isa("PPI::Statement::Expression")
l!l&&r!l&&!r
000
MC/DC0%0/2
$child->isa("PPI::Statement") or $child->isa("PPI::Statement::Expression")
$child->isa("PPI::Statement") $child->isa("PPI::Statement::Expression")
Truth table0%0/3
A or B
A= $child->isa("PPI::Statement")B= $child->isa("PPI::Statement::Expression")
ABresult
1X1
011
000
2967 0 my ($key, $val);
2968  
2969 my @tokens = grep {
2970 0 ▶ !$_->isa('PPI::Token::Whitespace') &&
Condition0%0/3
$_->isa('PPI::Token::Whitespace') || $_->isa('PPI::Token::Operator')
l!l&&r!l&&!r
000
MC/DC0%0/2
$_->isa('PPI::Token::Whitespace') || $_->isa('PPI::Token::Operator')
$_->isa('PPI::Token::Whitespace') $_->isa('PPI::Token::Operator')
Truth table0%0/3
A || B
A= $_->isa('PPI::Token::Whitespace')B= $_->isa('PPI::Token::Operator')
ABresult
1X1
011
000
2971 !$_->isa('PPI::Token::Operator')
2972 } $child->children;
2973  
2974 0 ▶ for (my $i = 0; $i < @tokens - 1; $i++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @tokens - 1) 0 0 0
2975 0 ▶ if(($tokens[$i]->isa('PPI::Token::Word') || $tokens[$i]->isa('PPI::Token::Quote')) &&
Branch: 1 branch
BranchTrueFalseTotal
if ($tokens[$i]->isa("PPI::Token::Word") || $tokens[$i]->isa("PPI::Token::Quote") and $tokens[$i + 1]->isa("PPI::Structure::Constructor")) 0 0 0
Condition0%0/6
$tokens[$i]->isa("PPI::Token::Word") || $tokens[$i]->isa("PPI::Token::Quote") and $tokens[$i + 1]->isa("PPI::Structure::Constructor")
!ll&&!rl&&r
000
$tokens[$i]->isa("PPI::Token::Word") or $tokens[$i]->isa("PPI::Token::Quote")
l!l&&r!l&&!r
000
MC/DC0%0/3
$tokens[$i]->isa("PPI::Token::Word") || $tokens[$i]->isa("PPI::Token::Quote") and $tokens[$i + 1]->isa("PPI::Structure::Constructor")
$tokens[$i]->isa("PPI::Token::Word") $tokens[$i]->isa("PPI::Token::Quote") $tokens[$i + 1]->isa("PPI::Structure::Constructor")
Truth table0%0/5
A or B and C
A= $tokens[$i]->isa("PPI::Token::Word")B= $tokens[$i]->isa("PPI::Token::Quote")C= $tokens[$i + 1]->isa("PPI::Structure::Constructor")
ABCresult
00X0
1X00
0100
1X11
0111
2976 $tokens[$i+1]->isa('PPI::Structure::Constructor')) {
2977 0 $key = $tokens[$i]->content;
2978 0 $key =~ s/^['"]|['"]$//g;
2979 0 $val = $tokens[$i+1];
2980 0 last;
2981 }
2982 }
2983  
2984 0 ▶ next unless $key && $val;
Branch: 1 branch
BranchTrueFalseTotal
unless $key and $val 0 0 0
Condition0%0/3
$key and $val
!ll&&!rl&&r
000
MC/DC0%0/2
$key and $val
$key $val
Truth table0%0/3
A and B
A= $keyB= $val
ABresult
0X0
100
111
2985  
2986 0 my %param;
2987 0 for my $inner ($val->children) {
2988 0 ▶ next unless $inner->isa('PPI::Statement') || $inner->isa('PPI::Statement::Expression');
Branch: 1 branch
BranchTrueFalseTotal
unless $inner->isa("PPI::Statement") or $inner->isa("PPI::Statement::Expression") 0 0 0
Condition0%0/3
$inner->isa("PPI::Statement") or $inner->isa("PPI::Statement::Expression")
l!l&&r!l&&!r
000
MC/DC0%0/2
$inner->isa("PPI::Statement") or $inner->isa("PPI::Statement::Expression")
$inner->isa("PPI::Statement") $inner->isa("PPI::Statement::Expression")
Truth table0%0/3
A or B
A= $inner->isa("PPI::Statement")B= $inner->isa("PPI::Statement::Expression")
ABresult
1X1
011
000
2989  
2990 my ($k, undef, $v) = grep {
2991 0 ▶ !$_->isa('PPI::Token::Whitespace') &&
Condition0%0/3
$_->isa('PPI::Token::Whitespace') || $_->isa('PPI::Token::Operator')
l!l&&r!l&&!r
000
MC/DC0%0/2
$_->isa('PPI::Token::Whitespace') || $_->isa('PPI::Token::Operator')
$_->isa('PPI::Token::Whitespace') $_->isa('PPI::Token::Operator')
Truth table0%0/3
A || B
A= $_->isa('PPI::Token::Whitespace')B= $_->isa('PPI::Token::Operator')
ABresult
1X1
011
000
2992 !$_->isa('PPI::Token::Operator')
2993 } $inner->children;
2994  
2995 0 ▶ next unless $k && $v;
Branch: 1 branch
BranchTrueFalseTotal
unless $k and $v 0 0 0
Condition0%0/3
$k and $v
!ll&&!rl&&r
000
MC/DC0%0/2
$k and $v
$k $v
Truth table0%0/3
A and B
A= $kB= $v
ABresult
0X0
100
111
2996  
2997 0 my $keyname = $k->content;
2998 0 ▶ my $value = $v->can('content') ? $v->content : undef;
Branch: 1 branch
BranchTrueFalseTotal
$v->can('content') ? : 0 0 0
2999 0 ▶ $value =~ s/^['"]|['"]$//g if defined $value;
Branch: 1 branch
BranchTrueFalseTotal
if defined $value 0 0 0
3000  
3001 0 ▶ if ($keyname eq 'type') {
Branch: 4 branches
BranchTrueFalseTotal
if ($keyname eq 'type') { } 0 0 0
elsif ($keyname eq 'optional') { } 0 0 0
elsif ($keyname =~ /^(min|max)$/ and &looks_like_number($value)) { } 0 0 0
elsif ($keyname eq 'matches') { } 0 0 0
3002 0 $param{type} = lc($value);
3003 } elsif ($keyname eq 'optional') {
3004 0 ▶ $param{optional} = $value ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$value ? : 0 0 0
3005 ▶ } elsif ($keyname =~ /^(min|max)$/ && looks_like_number($value)) {
Condition0%0/3
$keyname =~ /^(min|max)$/ and &looks_like_number($value)
!ll&&!rl&&r
000
MC/DC0%0/2
$keyname =~ /^(min|max)$/ and &looks_like_number($value)
$keyname =~ /^(min|max)$/ &looks_like_number($value)
Truth table0%0/3
A and B
A= $keyname =~ /^(min|max)$/B= &looks_like_number($value)
ABresult
0X0
100
111
3006 0 $param{$keyname} = 0 + $value;
3007 } elsif ($keyname eq 'matches') {
3008 0 $param{matches} = qr/$value/;
3009 }
3010 }
3011  
3012 0 ▶ $param{type} //= 'string';
Condition0%0/2
$param{"type"} //= "string"
l!l
00
MC/DC0%0/1
$param{"type"} //= "string"
$param{"type"}
Truth table0%0/2
A
A= $param{"type"}
Aresult
11
00
3013 0 ▶ $param{optional} //= 0;
Condition0%0/2
$param{"optional"} //= 0
l!l
00
MC/DC0%0/1
$param{"optional"} //= 0
$param{"optional"}
Truth table0%0/2
A
A= $param{"optional"}
Aresult
11
00
3014  
3015 0 $result{$key} = \%param;
3016 }
3017 }
3018  
3019 return {
3020 0 input => \%result,
3021 input_style => 'hash',
3022 _confidence => {
3023 input => {
3024 level => 'high',
3025 factors => ['Input schema extracted from validator'],
3026 },
3027 },
3028 };
3029 }
3030  
3031 # --------------------------------------------------
3032 # _ppi
3033 #
3034 # Purpose: Return a PPI::Document for a code
3035 # string, using a per-instance cache
3036 # to avoid re-parsing the same string
3037 # multiple times during a single
3038 # analysis pass.
3039 #
3040 # Entry: $code - either a string of Perl source
3041 # code, or an object that
3042 # already has a find() method
3043 # (returned as-is).
3044 #
3045 # Exit: Returns a PPI::Document, or the
3046 # original object if it already
3047 # supports find().
3048 #
3049 # Side effects: Populates $self->{_ppi_cache}.
3050 # --------------------------------------------------
3051 16 ▶sub _ppi {
Subroutine _ppi: called CC=5 SCAR=16.2
3052 16 my ($self, $code) = @_;
3053  
3054 16 ▶ return $code if ref($code) && $code->can('find');
Branch: 1 branch
BranchTrueFalseTotal
if ref $code and $code->can("find") 1 15 16
Condition66%2/3
ref $code and $code->can("find")
!ll&&!rl&&r
1501
MC/DC50%1/2
ref $code and $code->can("find")
ref $code $code->can("find")
Truth table66%2/3
A and B
A= ref $codeB= $code->can("find")
ABresult
0X0
100
111
3055  
3056 15 ▶ $self->{_ppi_cache} ||= {};
Condition100%2/2
$self->{"_ppi_cache"} ||= {}
l!l
213
MC/DC100%1/1
$self->{"_ppi_cache"} ||= {}
$self->{"_ppi_cache"}
Truth table100%2/2
A
A= $self->{"_ppi_cache"}
Aresult
11
00
3057 15 ▶ return $self->{_ppi_cache}{$code} //= PPI::Document->new(\$code);
Condition66%2/3
$self->{"_ppi_cache"}{$code} //= "PPI::Document"->new(\$code)
l!l&&r!l&&!r
1140
MC/DC0%0/2
$self->{"_ppi_cache"}{$code} //= "PPI::Document"->new(\$code)
$self->{"_ppi_cache"}{$code} "PPI::Document"->new(\$code)
Truth table66%2/3
A //= B
A= $self->{"_ppi_cache"}{$code}B= "PPI::Document"->new(\$code)
ABresult
1X1
011
000
3058 }
3059  
3060 # --------------------------------------------------
3061 # _extract_pvs_schema
3062 #
3063 # Purpose: Detect and extract a parameter schema
3064 # from a Params::Validate::Strict
3065 # validate_strict() call in the method
3066 # body.
3067 #
3068 # Entry: $code - method body source string.
3069 #
3070 # Exit: Returns a schema hashref with input,
3071 # style, and source keys on success,
3072 # or undef if no validate_strict call
3073 # is found or parsing fails.
3074 #
3075 # Side effects: None.
3076 # --------------------------------------------------
3077 764 ▶sub _extract_pvs_schema {
Subroutine _extract_pvs_schema: called CC=15 SCAR=29.7
3078 764 my ($self, $code) = @_;
3079  
3080 764 ▶ return unless $code =~ /\bvalidate_strict\s*\(/;
Branch: 1 branch
BranchTrueFalseTotal
unless $code =~ /\bvalidate_strict\s*\(/ 753 11 764
3081  
3082 11 ▶ my $doc = $self->_ppi($code) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $doc = $self->_ppi($code) or return 11 0 11
3083  
3084 23846 ▶ my $calls = $doc->find(sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
3085 23846 ▶ $_[1]->isa('PPI::Token::Word') && ($_[1]->content eq 'validate_strict' || $_[1]->content eq 'Params::Validate::Strict::validate_strict')
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Token::Word") and $_[1]->content eq "validate_strict" || $_[1]->content eq "Params::Validate::Strict::validate_strict" 1989 21857 23846
Condition100%6/6
$_[1]->isa('PPI::Token::Word') && ($_[1]->content eq 'validate_strict' || $_[1]->content eq 'Params::Validate::Strict::validate_strict')
!ll&&!rl&&r
21857197811
$_[1]->content eq "validate_strict" or $_[1]->content eq "Params::Validate::Strict::validate_strict"
l!l&&r!l&&!r
291978
MC/DC100%3/3
$_[1]->isa('PPI::Token::Word') && ($_[1]->content eq 'validate_strict' || $_[1]->content eq 'Params::Validate::Strict::validate_strict')
$_[1]->isa('PPI::Token::Word') $_[1]->content eq "validate_strict" $_[1]->content eq "Params::Validate::Strict::validate_strict"
Truth table100%4/4
A && B or C
A= $_[1]->isa('PPI::Token::Word')B= $_[1]->content eq "validate_strict"C= $_[1]->content eq "Params::Validate::Strict::validate_strict"
ABCresult
0XX0
1000
11X1
1011
3086 11 ▶ }) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $calls = $doc->find(sub { $_[1]->isa("PPI::Token::Word") and $_[1]->content eq "validate_strict" || $_[1]->content eq "Params::Validate::Strict::validate_strict"; } ) or return 11 0 11
3087  
3088 11 for my $call (@$calls) {
3089 11 my $list = $call->parent();
3090 11 ▶ while ($list && !$list->isa('PPI::Structure::List')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($list and not $list->isa("PPI::Structure::List")) 58 11 69
Condition66%2/3
$list and not $list->isa("PPI::Structure::List")
!ll&&!rl&&r
11058
MC/DC50%1/2
$list and not $list->isa("PPI::Structure::List")
$list not $list->isa("PPI::Structure::List")
Truth table66%2/3
A and not(B)
A= $listB= not $list->isa("PPI::Structure::List")
ABresult
0X0
100
111
3091 58 $list = $list->parent();
3092 }
3093 11 ▶ if(!defined($list)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $list) 11 0 11
3094 11 my $next = $call->next_sibling();
3095 11 ▶ next unless defined $next;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $next 0 11 11
3096 11 ▶ if($next->content() =~ /schema\s*=>\s*(\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next->content =~ /schema\s*=>\s*(\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})/s) 11 0 11
3097 11 my $schema_text = $1;
3098 11 ▶ next if $schema_text =~ $UNSAFE_KEYWORD_RE;
Branch: 1 branch
BranchTrueFalseTotal
if $schema_text =~ /$UNSAFE_KEYWORD_RE/ 0 11 11
3099 11 my $compartment = Safe->new();
3100 11 $compartment->permit_only(qw(:base_core :base_mem :base_orig));
3101  
3102 11 my $schema_str = "my \$schema = $schema_text";
3103 11 my $schema = $compartment->reval($schema_str);
3104 11 ▶ if($self->_usable_validator_schema($schema)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_usable_validator_schema($schema)) 10 1 11
3105 return {
3106 10 input => $schema,
3107 style => 'hash',
3108 source => SOURCE_VALIDATOR
3109 }
3110 }
3111 }
3112 }
3113 1 ▶ next unless $list;
Branch: 1 branch
BranchTrueFalseTotal
unless $list 1 0 1
3114  
3115 0 my ($schema_block) = grep { $_->isa('PPI::Structure::Block') } $list->children;
3116  
3117 0 ▶ next unless $schema_block;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema_block 0 0 0
3118  
3119 0 my $schema = $self->_extract_schema_hash_from_block($schema_block);
3120 0 ▶ return $self->_normalize_validator_schema($schema) if $schema;
Branch: 1 branch
BranchTrueFalseTotal
if $schema 0 0 0
3121 }
3122  
3123 1 return;
3124 }
3125  
3126 # --------------------------------------------------
3127 # _extract_pv_schema
3128 #
3129 # Purpose: Detect and extract a parameter schema
3130 # from a Params::Validate validate()
3131 # call in the method body.
3132 #
3133 # Entry: $code - method body source string.
3134 #
3135 # Exit: Returns a schema hashref with input,
3136 # style, and source keys on success,
3137 # or undef if no validate() call is
3138 # found or parsing fails.
3139 #
3140 # Side effects: None.
3141 # --------------------------------------------------
3142 754 ▶sub _extract_pv_schema {
Subroutine _extract_pv_schema: called CC=18 SCAR=33.7
3143 754 my ($self, $code) = @_;
3144  
3145 754 ▶ return unless $code =~ /\bvalidate\s*\(/;
Branch: 1 branch
BranchTrueFalseTotal
unless $code =~ /\bvalidate\s*\(/ 753 1 754
3146  
3147 1 ▶ my $doc = $self->_ppi($code) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $doc = $self->_ppi($code) or return 1 0 1
3148  
3149 263 ▶ my $calls = $doc->find(sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
3150 263 ▶ $_[1]->isa('PPI::Token::Word') && ($_[1]->content eq 'validate' || $_[1]->content eq 'Params::Validate::validate')
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Token::Word") and $_[1]->content eq "validate" || $_[1]->content eq "Params::Validate::validate" 28 235 263
Condition83%5/6
$_[1]->isa('PPI::Token::Word') && ($_[1]->content eq 'validate' || $_[1]->content eq 'Params::Validate::validate')
!ll&&!rl&&r
235271
$_[1]->content eq "validate" or $_[1]->content eq "Params::Validate::validate"
l!l&&r!l&&!r
1027
MC/DC66%2/3
$_[1]->isa('PPI::Token::Word') && ($_[1]->content eq 'validate' || $_[1]->content eq 'Params::Validate::validate')
$_[1]->isa('PPI::Token::Word') $_[1]->content eq "validate" $_[1]->content eq "Params::Validate::validate"
Truth table75%3/4
A && B or C
A= $_[1]->isa('PPI::Token::Word')B= $_[1]->content eq "validate"C= $_[1]->content eq "Params::Validate::validate"
ABCresult
0XX0
1000
11X1
1011
3151 1 ▶ }) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $calls = $doc->find(sub { $_[1]->isa("PPI::Token::Word") and $_[1]->content eq "validate" || $_[1]->content eq "Params::Validate::validate"; } ) or return 1 0 1
3152  
3153 1 for my $call (@$calls) {
3154 1 my $list = $call->parent;
3155 1 ▶ while ($list && !$list->isa('PPI::Structure::List')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($list and not $list->isa("PPI::Structure::List")) 4 1 5
Condition66%2/3
$list and not $list->isa("PPI::Structure::List")
!ll&&!rl&&r
104
MC/DC50%1/2
$list and not $list->isa("PPI::Structure::List")
$list not $list->isa("PPI::Structure::List")
Truth table66%2/3
A and not(B)
A= $listB= not $list->isa("PPI::Structure::List")
ABresult
0X0
100
111
3156 4 $list = $list->parent;
3157 }
3158 1 ▶ if(!defined($list)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $list) 1 0 1
3159 1 my $next = $call->next_sibling();
3160 1 my ($arglist, $schema_text) = $self->_parse_pv_call($next);
3161  
3162 1 ▶ if($schema_text && $schema_text !~ $UNSAFE_KEYWORD_RE) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema_text and not $schema_text =~ /$UNSAFE_KEYWORD_RE/) 1 0 1
Condition33%1/3
$schema_text and not $schema_text =~ /$UNSAFE_KEYWORD_RE/
!ll&&!rl&&r
001
MC/DC0%0/2
$schema_text and not $schema_text =~ /$UNSAFE_KEYWORD_RE/
$schema_text not $schema_text =~ /$UNSAFE_KEYWORD_RE/
Truth table33%1/3
A and not(B)
A= $schema_textB= not $schema_text =~ /$UNSAFE_KEYWORD_RE/
ABresult
0X0
100
111
3163 1 my $compartment = Safe->new();
3164 1 $compartment->permit_only(qw(:base_core :base_mem :base_orig));
3165  
3166 1 my $schema_str = "my \$schema = $schema_text";
3167 1 my $schema = $compartment->reval($schema_str);
3168  
3169 1 ▶ if($self->_usable_validator_schema($schema)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_usable_validator_schema($schema)) 1 0 1
3170 1 foreach my $arg(keys %{$schema}) {
3171 3 my $field = $schema->{$arg};
3172 3 ▶ if(my $type = $field->{'type'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $type = $field->{"type"}) 3 0 3
3173 3 ▶ if($type eq 'ARRAYREF') {
Branch: 2 branches
BranchTrueFalseTotal
if ($type eq 'ARRAYREF') { } 1 2 3
elsif ($type eq 'SCALAR') { } 2 0 2
3174 1 $field->{'type'} = 'arrayref';
3175 } elsif($type eq 'SCALAR') {
3176 2 $field->{'type'} = 'string';
3177 }
3178 }
3179 3 delete $field->{'callbacks'};
3180 }
3181  
3182 return {
3183 1 input => $schema,
3184 style => 'hash',
3185 source => SOURCE_VALIDATOR
3186 }
3187 }
3188 }
3189 }
3190 0 ▶ next unless $list;
Branch: 1 branch
BranchTrueFalseTotal
unless $list 0 0 0
3191  
3192 0 my ($schema_block) = grep { $_->isa('PPI::Structure::Block') } $list->children;
3193  
3194 0 ▶ next unless $schema_block;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema_block 0 0 0
3195  
3196 0 my $schema = $self->_extract_schema_hash_from_block($schema_block);
3197 0 ▶ return $self->_normalize_validator_schema($schema) if $schema;
Branch: 1 branch
BranchTrueFalseTotal
if $schema 0 0 0
3198 }
3199  
3200 0 return;
3201 }
3202  
3203 # --------------------------------------------------
3204 # _parse_pv_call
3205 #
3206 # Purpose: Split a Params::Validate call argument
3207 # string into its two components: the
3208 # first argument (typically \@_) and
3209 # the schema hash string.
3210 #
3211 # Entry: $string - the raw argument string
3212 # from the validate() call,
3213 # including outer parentheses.
3214 #
3215 # Exit: Returns a two-element list:
3216 # ($first_arg, $hash_str)
3217 # or an empty list if no comma is found
3218 # at brace depth zero (malformed call).
3219 #
3220 # Side effects: None.
3221 # --------------------------------------------------
3222 2 ▶sub _parse_pv_call {
Subroutine _parse_pv_call: called CC=6 SCAR=19.0
3223 2 my ($self, $string) = @_;
3224  
3225 # Remove outer parentheses and whitespace
3226 2 $string =~ s/^\s*\(\s*//;
3227 2 $string =~ s/\s*\)\s*$//;
3228  
3229 # Find the first comma at brace-depth 0, jumping over each balanced
3230 # {...} block in one step via extract_bracketed rather than
3231 # counting depth character by character
3232 2 require Text::Balanced;
3233 2 my $rest = $string;
3234 2 my $comma_pos = 0;
3235 2 my $found_comma = 0;
3236  
3237 2 ▶ while (length $rest) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $rest) 10 0 10
3238 10 ▶ if (substr($rest, 0, 1) eq '{') {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($rest, 0, 1) eq "{") 0 10 10
3239 # extract_bracketed advances $rest past the extracted block
3240 # in place, so $rest must not be re-truncated afterwards
3241 0 my $extracted = Text::Balanced::extract_bracketed($rest, '{}');
3242 0 ▶ return unless defined $extracted; # Broken source code
Branch: 1 branch
BranchTrueFalseTotal
unless defined $extracted 0 0 0
3243 0 $comma_pos += length $extracted;
3244 0 next;
3245 }
3246 10 ▶ if (substr($rest, 0, 1) eq ',') {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($rest, 0, 1) eq ",") 2 8 10
3247 2 $found_comma = 1;
3248 2 last;
3249 }
3250 8 $comma_pos++;
3251 8 $rest = substr($rest, 1);
3252 }
3253  
3254 2 ▶ return unless $found_comma;
Branch: 1 branch
BranchTrueFalseTotal
unless $found_comma 0 2 2
3255  
3256 2 my $first_arg = substr($string, 0, $comma_pos);
3257 2 my $hash_str = substr($string, $comma_pos + 1);
3258  
3259 # Trim whitespace
3260 2 $first_arg =~ s/^\s+|\s+$//g;
3261 2 $hash_str =~ s/^\s+|\s+$//g;
3262  
3263 2 return ($first_arg, $hash_str);
3264 }
3265  
3266 # --------------------------------------------------
3267 # _extract_moosex_params_schema
3268 #
3269 # Purpose: Detect and extract a parameter schema
3270 # from a MooseX::Params::Validate
3271 # validated_hash() call in the method
3272 # body.
3273 #
3274 # Entry: $code - method body source string.
3275 #
3276 # Exit: Returns a schema hashref with input,
3277 # style, and source keys on success,
3278 # or undef if no validated_hash() call
3279 # is found or parsing fails.
3280 #
3281 # Side effects: None.
3282 # --------------------------------------------------
3283 sub _extract_moosex_params_schema
3284 753 ▶{
Subroutine _extract_moosex_params_schema: called CC=23 SCAR=36.9
3285 753 my ($self, $code) = @_;
3286  
3287 753 ▶ return unless $code =~ /\bvalidated_hash\s*\(/;
Branch: 1 branch
BranchTrueFalseTotal
unless $code =~ /\bvalidated_hash\s*\(/ 752 1 753
3288  
3289 1 ▶ my $doc = $self->_ppi($code) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $doc = $self->_ppi($code) or return 1 0 1
3290  
3291 212 ▶ my $calls = $doc->find(sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
3292 212 ▶ $_[1]->isa('PPI::Token::Word') && ($_[1]->content eq 'validated_hash')
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Token::Word") and $_[1]->content eq "validated_hash" 27 185 212
3293 1 ▶ }) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $calls = $doc->find(sub { $_[1]->isa("PPI::Token::Word") and $_[1]->content eq "validated_hash"; } ) or return 1 0 1
3294  
3295 1 for my $call (@$calls) {
3296 1 my $list = $call->parent();
3297 1 ▶ while ($list && !$list->isa('PPI::Structure::List')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($list and not $list->isa("PPI::Structure::List")) 4 1 5
Condition66%2/3
$list and not $list->isa("PPI::Structure::List")
!ll&&!rl&&r
104
MC/DC50%1/2
$list and not $list->isa("PPI::Structure::List")
$list not $list->isa("PPI::Structure::List")
Truth table66%2/3
A and not(B)
A= $listB= not $list->isa("PPI::Structure::List")
ABresult
0X0
100
111
3298 4 $list = $list->parent;
3299 }
3300 1 ▶ if(!defined($list)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $list) 1 0 1
3301 1 my $next = $call->next_sibling();
3302 1 my ($arglist, $schema_text) = $self->_parse_pv_call($next);
3303  
3304 1 ▶ if($schema_text && $schema_text !~ $UNSAFE_KEYWORD_RE) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema_text and not $schema_text =~ /$UNSAFE_KEYWORD_RE/) 1 0 1
Condition33%1/3
$schema_text and not $schema_text =~ /$UNSAFE_KEYWORD_RE/
!ll&&!rl&&r
001
MC/DC0%0/2
$schema_text and not $schema_text =~ /$UNSAFE_KEYWORD_RE/
$schema_text not $schema_text =~ /$UNSAFE_KEYWORD_RE/
Truth table33%1/3
A and not(B)
A= $schema_textB= not $schema_text =~ /$UNSAFE_KEYWORD_RE/
ABresult
0X0
100
111
3305 1 my $compartment = Safe->new();
3306 1 $compartment->permit_only(qw(:base_core :base_mem :base_orig));
3307  
3308 1 my $schema_str = "my \$schema = { $schema_text }";
3309 1 $schema_str =~ s/ArrayRef\[(.+?)\]/arrayref, element_type => $1/g;
3310 1 my $schema = $compartment->reval($schema_str);
3311  
3312 1 ▶ if($self->_usable_validator_schema($schema)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_usable_validator_schema($schema)) 1 0 1
3313 1 foreach my $arg(keys %{$schema}) {
3314 3 my $field = $schema->{$arg};
3315 3 ▶ if(my $isa = delete $field->{'isa'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $isa = delete $field->{"isa"}) 3 0 3
3316 3 $field->{'type'} = $isa;
3317 }
3318 3 ▶ if(exists($field->{'required'})) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $field->{'required'}) { } 1 2 3
3319 1 my $required = delete $field->{'required'};
3320 1 ▶ $field->{'optional'} = $required ? 0 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$required ? : 1 0 1
3321 } else {
3322 2 $field->{'optional'} = 1;
3323 }
3324 3 ▶ if(ref($field->{'default'}) eq 'CODE') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $field->{"default"} eq "CODE") 1 2 3
3325 1 delete $field->{'default'}; # TODO
3326 }
3327 }
3328  
3329 1 foreach my $arg(keys %{$schema}) {
3330 3 my $field = $schema->{$arg};
3331 3 ▶ if(my $type = $field->{'type'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $type = $field->{"type"}) 3 0 3
3332 3 ▶ if($type eq 'ARRAYREF') {
Branch: 2 branches
BranchTrueFalseTotal
if ($type eq 'ARRAYREF') { } 0 3 3
elsif ($type eq 'SCALAR') { } 0 3 3
3333 0 $field->{'type'} = 'arrayref';
3334 } elsif($type eq 'SCALAR') {
3335 0 $field->{'type'} = 'string';
3336 }
3337 }
3338 3 delete $field->{'callbacks'};
3339 }
3340  
3341 return {
3342 1 input => $schema,
3343 style => 'hash',
3344 source => SOURCE_VALIDATOR
3345 }
3346 }
3347 }
3348 }
3349 0 ▶ next unless $list;
Branch: 1 branch
BranchTrueFalseTotal
unless $list 0 0 0
3350  
3351 0 my ($schema_block) = grep { $_->isa('PPI::Structure::Block') } $list->children;
3352  
3353 0 ▶ next unless $schema_block;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema_block 0 0 0
3354  
3355 0 my $schema = $self->_extract_schema_hash_from_block($schema_block);
3356 0 ▶ return $self->_normalize_validator_schema($schema) if $schema;
Branch: 1 branch
BranchTrueFalseTotal
if $schema 0 0 0
3357 }
3358  
3359 0 return;
3360 }
3361  
3362 # --------------------------------------------------
3363 # _extract_schema_hash_from_block
3364 #
3365 # Purpose: Extract a parameter schema hashref from
3366 # a PPI::Structure::Block node representing
3367 # the schema argument to a validator call
3368 # such as validate_strict({ ... }).
3369 #
3370 # Entry: $block - a PPI::Structure::Block node.
3371 #
3372 # Exit: Returns a hashref of parameter name to
3373 # spec hashref, or undef if parsing fails.
3374 #
3375 # Side effects: None.
3376 #
3377 # Notes: Delegates to _parse_schema_hash which
3378 # expects a PPI node with a children()
3379 # method. This method exists to provide
3380 # a clear semantic name at the call site.
3381 # --------------------------------------------------
3382 0 ▶sub _extract_schema_hash_from_block {
Subroutine _extract_schema_hash_from_block: not called CC=6 SCAR=37.4
3383 0 my ($self, $block) = @_;
3384  
3385 0 ▶ return unless $block && $block->can('children');
Branch: 1 branch
BranchTrueFalseTotal
unless $block and $block->can("children") 0 0 0
Condition0%0/3
$block and $block->can("children")
!ll&&!rl&&r
000
MC/DC0%0/2
$block and $block->can("children")
$block $block->can("children")
Truth table0%0/3
A and B
A= $blockB= $block->can("children")
ABresult
0X0
100
111
3386  
3387 0 my $result = $self->_parse_schema_hash($block);
3388  
3389 0 ▶ return unless $result && ref($result) eq 'HASH' && $result->{input};
Branch: 1 branch
BranchTrueFalseTotal
unless $result and ref $result eq "HASH" and $result->{"input"} 0 0 0
Condition0%0/6
$result and ref $result eq "HASH" and $result->{"input"}
!ll&&!rl&&r
000
$result and ref $result eq "HASH"
!ll&&!rl&&r
000
MC/DC0%0/3
$result and ref $result eq "HASH" and $result->{"input"}
$result ref $result eq "HASH" $result->{"input"}
Truth table0%0/4
A and B and C
A= $resultB= ref $result eq "HASH"C= $result->{"input"}
ABCresult
0XX0
10X0
1100
1111
3390  
3391 0 return $result->{input};
3392 }
3393  
3394 # --------------------------------------------------
3395 # _usable_validator_schema
3396 #
3397 # Purpose: Decide whether a schema hash evaluated
3398 # from source code is a real parameter
3399 # schema, or the remains of a runtime
3400 # expression that was never meant to be
3401 # evaluated at all.
3402 #
3403 # Entry: $schema - value returned by
3404 # Safe->reval() on the schema
3405 # text found in the call.
3406 #
3407 # Exit: Returns true when the schema is a
3408 # non-empty hash of named parameters to
3409 # spec hashes, false otherwise.
3410 #
3411 # Side effects: None.
3412 #
3413 # Notes: CGI::Info::params validates each
3414 # parameter inside a loop with
3415 #
3416 # validate_strict({
3417 # schema => { $key => $schema },
3418 # args => { $key => $value },
3419 # });
3420 #
3421 # Evaluating { $key => $schema } with
3422 # both lexicals undefined yields
3423 # { '' => undef }. Accepting that as the
3424 # method's input gave the schema an empty
3425 # parameter name, which the harness
3426 # generator rightly refuses to turn into
3427 # a Perl variable, so no harness could be
3428 # generated for the routine at all.
3429 # --------------------------------------------------
3430 13 ▶sub _usable_validator_schema {
Subroutine _usable_validator_schema: called CC=6 SCAR=18.3
3431 13 my ($self, $schema) = @_;
3432  
3433 13 ▶ return 0 unless ref($schema) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $schema eq "HASH" 0 13 13
3434  
3435 13 my @names = keys %$schema;
3436 13 ▶ return 0 unless @names;
Branch: 1 branch
BranchTrueFalseTotal
unless @names 0 13 13
3437  
3438 13 for my $name (@names) {
3439 40 ▶ return 0 unless length($name);
Branch: 1 branch
BranchTrueFalseTotal
unless length $name 1 39 40
3440 39 ▶ return 0 unless ref($schema->{$name}) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $schema->{$name} eq "HASH" 0 39 39
3441 }
3442  
3443 12 return 1;
3444 }
3445  
3446 # --------------------------------------------------
3447 # _normalize_validator_schema
3448 #
3449 # Purpose: Normalise a raw validator schema
3450 # hashref (as extracted from PPI) into
3451 # the standard input spec format used
3452 # throughout the extractor.
3453 #
3454 # Entry: $schema - hashref of parameter name
3455 # to raw spec hashref, as
3456 # produced by
3457 # _extract_schema_hash_from_block.
3458 #
3459 # Exit: Returns a hashref with keys:
3460 # input_style - 'hash'
3461 # input - normalised param specs
3462 # Each param spec gains an explicit
3463 # optional key and _source / _type_confidence
3464 # metadata.
3465 #
3466 # Side effects: None.
3467 # --------------------------------------------------
3468 0 ▶sub _normalize_validator_schema {
Subroutine _normalize_validator_schema: not called CC=3 SCAR=24.8
3469 0 my ($self, $schema) = @_;
3470  
3471 0 my %input;
3472  
3473 0 for my $name (keys %$schema) {
3474 0 my $spec = $schema->{$name};
3475  
3476 $input{$name} = {
3477 %$spec,
3478 0 ▶ optional => exists $spec->{optional} ? $spec->{optional} : 0,
Branch: 1 branch
BranchTrueFalseTotal
exists $spec->{'optional'} ? : 0 0 0
3479 _source => SOURCE_VALIDATOR,
3480 _type_confidence => 'high',
3481 };
3482 }
3483  
3484 return {
3485 0 input_style => 'hash',
3486 input => \%input,
3487 };
3488 }
3489  
3490 # --------------------------------------------------
3491 # _extract_type_params_schema
3492 #
3493 # Purpose: Detect and extract a parameter schema
3494 # from a Type::Params signature_for()
3495 # declaration for the current method,
3496 # located in the module-level document.
3497 #
3498 # Entry: $code - method body source string
3499 # (used to extract the function
3500 # name for lookup).
3501 #
3502 # Exit: Returns a schema hashref on success,
3503 # or undef if no signature_for
3504 # declaration is found or compilation
3505 # fails.
3506 #
3507 # Side effects: May fork a child process to compile
3508 # the signature in isolation.
3509 # --------------------------------------------------
3510 755 ▶sub _extract_type_params_schema {
Subroutine _extract_type_params_schema: called CC=6 SCAR=18.0
3511 755 my ($self, $code) = @_;
3512  
3513 755 ▶ my $function = $self->_extract_function_name($code) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $function = $self->_extract_function_name($code) or return 755 0 755
3514  
3515 755 ▶ my $doc = $self->{_document} or return;
Branch: 1 branch
BranchTrueFalseTotal
my $doc = $self->{"_document"} or return 754 1 755
3516 754 ▶ my $stmt = $self->_find_signature_statement($doc, $function) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $stmt = $self->_find_signature_statement($doc, $function) or return 4 750 754
3517  
3518 4 ▶ my $signature_expr = $self->_extract_signature_expression($stmt, $function) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $signature_expr = $self->_extract_signature_expression($stmt, $function) or return 4 0 4
3519  
3520 4 ▶ my $meta = $self->_compile_signature_isolated($function, $signature_expr) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $meta = $self->_compile_signature_isolated($function, $signature_expr) or return 3 1 4
3521  
3522 3 return $self->_build_schema_from_meta($meta);
3523 }
3524  
3525 # --------------------------------------------------
3526 # _extract_function_name
3527 #
3528 # Purpose: Extract the subroutine name from the
3529 # start of a method body string, used
3530 # to look up its Type::Params signature.
3531 #
3532 # Entry: $code - method body source string.
3533 #
3534 # Exit: Returns the subroutine name string,
3535 # or undef if no 'sub name' declaration
3536 # is found.
3537 #
3538 # Side effects: None.
3539 # --------------------------------------------------
3540 756 ▶sub _extract_function_name {
Subroutine _extract_function_name: called CC=2 SCAR=6.9
3541 756 my ($self, $code) = @_;
3542 756 ▶ return $1 if $code =~ /^\s*sub\s+([a-zA-Z0-9_]+)/;
Branch: 1 branch
BranchTrueFalseTotal
if $code =~ /^\s*sub\s+([a-zA-Z0-9_]+)/ 754 2 756
3543 2 return;
3544 }
3545  
3546 # --------------------------------------------------
3547 # _find_signature_statement
3548 #
3549 # Purpose: Search a PPI document for a
3550 # signature_for statement that
3551 # corresponds to a named function.
3552 #
3553 # Entry: $doc - PPI::Document to search.
3554 # $function - function name string.
3555 #
3556 # Exit: Returns the matching PPI::Statement
3557 # node, or undef if none is found.
3558 #
3559 # Side effects: None.
3560 # --------------------------------------------------
3561 752 ▶sub _find_signature_statement {
Subroutine _find_signature_statement: called CC=4 SCAR=14.0
3562 752 my ($self, $doc, $function) = @_;
3563  
3564 my $statements = $doc->find(
3565 2082125 ▶ sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
3566 2082125 ▶ $_[1]->isa('PPI::Statement') && $_[1]->content =~ /^\s*signature_for\b/
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Statement") and $_[1]->content =~ /^\s*signature_for\b/ 213930 1868195 2082125
3567 }
3568 752 ▶ ) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $statements = $doc->find(sub { $_[1]->isa("PPI::Statement") and $_[1]->content =~ /^\s*signature_for\b/; } ) or return 3 749 752
3569  
3570 3 foreach my $stmt (@$statements) {
3571 3 my $content = $stmt->content;
3572 3 ▶ if ($content =~ /^\s*signature_for\s+\Q$function\E\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /^\s*signature_for\s+\Q$function\E\b/) 3 0 3
3573 3 return $stmt;
3574 }
3575 }
3576  
3577 0 return;
3578 }
3579  
3580 # --------------------------------------------------
3581 # _extract_signature_expression
3582 #
3583 # Purpose: Extract the Type::Params signature
3584 # expression (everything after =>) from
3585 # a signature_for statement node.
3586 #
3587 # Entry: $stmt - PPI::Statement node.
3588 # $function - function name string,
3589 # used in the match pattern.
3590 #
3591 # Exit: Returns the signature expression
3592 # string, or undef if the pattern
3593 # does not match.
3594 #
3595 # Side effects: None.
3596 # --------------------------------------------------
3597 3 ▶sub _extract_signature_expression {
Subroutine _extract_signature_expression: called CC=2 SCAR=7.4
3598 3 my ($self, $stmt, $function) = @_;
3599  
3600 3 my $content = $stmt->content;
3601  
3602 3 ▶ if ($content =~ /^\s*signature_for\s+\Q$function\E\s*=>\s*(.+?);?\s*$/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /^\s*signature_for\s+\Q$function\E\s*=>\s*(.+?);?\s*$/s) 3 0 3
3603 3 return $1;
3604 }
3605  
3606 0 return;
3607 }
3608  
3609 # --------------------------------------------------
3610 # _compile_signature_isolated
3611 #
3612 # Purpose: Compile and evaluate a Type::Params
3613 # signature expression in an isolated
3614 # process to extract parameter metadata
3615 # without polluting the current process.
3616 #
3617 # Only runs when the caller passed
3618 # allow_signature_exec => 1 to new().
3619 # Extracting parameter types from a
3620 # Type::Params signature_for() declaration
3621 # requires actually building the type
3622 # objects at runtime -- there is no purely
3623 # static way to do it -- so this is real
3624 # execution of an excerpt of the target
3625 # module's own source. Every other code
3626 # path in this module is static (PPI-only)
3627 # analysis that never runs the target's
3628 # code, so this one feature must be opted
3629 # into explicitly rather than triggered
3630 # implicitly by extract_all().
3631 #
3632 # A Safe compartment was previously tried
3633 # first as a "fast path" before falling
3634 # back to this subprocess unconditionally.
3635 # It was removed: Type::Params and
3636 # Types::Common pull in XS modules (e.g.
3637 # B.pm via Type::Params), and Safe cannot
3638 # host XS/dynamic loading at all, so the
3639 # compartment never succeeded for any real
3640 # signature_for() declaration -- it was
3641 # dead code that gave a false impression of
3642 # sandboxing while every real call fell
3643 # through to the unconditional subprocess
3644 # below.
3645 #
3646 # Entry: $function - function name string.
3647 # $signature_expr - Type::Params
3648 # signature expression
3649 # string.
3650 #
3651 # Exit: Returns a decoded JSON hashref
3652 # containing parameters and returns
3653 # metadata on success.
3654 # Returns undef without running anything if
3655 # allow_signature_exec was not enabled.
3656 # Croaks on unsafe expressions, timeout,
3657 # or compile errors.
3658 #
3659 # Side effects: May fork a child process with a
3660 # memory limit applied via
3661 # BSD::Resource if available.
3662 # Memory limiting is best-effort and
3663 # silently skipped on platforms where
3664 # BSD::Resource is unavailable.
3665 # --------------------------------------------------
3666 12 ▶sub _compile_signature_isolated {
Subroutine _compile_signature_isolated: called CC=13 SCAR=26.2
3667 12 my ($self, $function, $signature_expr) = @_;
3668  
3669 12 ▶ unless ($self->{allow_signature_exec}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->{"allow_signature_exec"}) 2 10 12
3670 carp "Skipping Type::Params signature_for($function) extraction: ",
3671 'allow_signature_exec => 1 was not passed to new() ',
3672 '(this would execute code from the target module)'
3673 2 ▶ if $self->{verbose};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"verbose"} 0 2 2
3674 2 return;
3675 }
3676  
3677 # Remove comments
3678 10 $signature_expr =~ s/#.*$//mg;
3679  
3680 # Reject obviously dangerous constructs. This is defense in depth
3681 # only, not a real security boundary -- it is a denylist of literal
3682 # tokens and cannot catch e.g. a symbolic-ref call built by string
3683 # concatenation. The actual control here is the allow_signature_exec
3684 # opt-in above: this code must never run against a module the caller
3685 # has not already decided to trust enough to execute.
3686 # Both checks unified into one croak so the message and class are consistent
3687 10 ▶ if ($signature_expr =~ $UNSAFE_KEYWORD_RE || $signature_expr =~ $UNSAFE_CHAR_RE) {
Branch: 1 branch
BranchTrueFalseTotal
if ($signature_expr =~ /$UNSAFE_KEYWORD_RE/ or $signature_expr =~ /$UNSAFE_CHAR_RE/) 0 10 10
Condition33%1/3
$signature_expr =~ /$UNSAFE_KEYWORD_RE/ or $signature_expr =~ /$UNSAFE_CHAR_RE/
l!l&&r!l&&!r
0010
MC/DC0%0/2
$signature_expr =~ /$UNSAFE_KEYWORD_RE/ or $signature_expr =~ /$UNSAFE_CHAR_RE/
$signature_expr =~ /$UNSAFE_KEYWORD_RE/ $signature_expr =~ /$UNSAFE_CHAR_RE/
Truth table33%1/3
A or B
A= $signature_expr =~ /$UNSAFE_KEYWORD_RE/B= $signature_expr =~ /$UNSAFE_CHAR_RE/
ABresult
1X1
011
000
3688 0 croak 'Unsafe signature expression -- rejected to prevent code execution';
3689 }
3690  
3691 10 my $payload = <<'PERL';
3692 use strict;
3693 use warnings;
3694 use Type::Params -sigs;
3695 use Types::Common -types;
3696 use JSON::MaybeXS;
3697  
3698 # Apply address-space limit passed from parent via env. Done here (in the
3699 # child) rather than in the parent so the parent's memory is never capped.
3700 if (my $limit = $ENV{_ATG_RLIMIT_AS}) {
3701 eval {
3702 require BSD::Resource;
3703 BSD::Resource::setrlimit(BSD::Resource::RLIMIT_AS(), $limit, $limit);
3704 };
3705 }
3706  
3707 # Stub sub so Perl can parse it
3708 sub FUNCTION_NAME {}
3709  
3710 # Create the Type::Params signature object
3711 my $sig = signature_for FUNCTION_NAME => SIGNATURE_EXPR;
3712  
3713 # Extract parameters — guard against older Type::Params (< 2.x) where
3714 # signature_for() installs the constraint but returns undef rather than
3715 # the signature object, so ->parameters() would die.
3716 my @sig_params = (defined $sig && ref $sig && $sig->can('parameters'))
3717 ? @{ $sig->parameters || [] }
3718 : ();
3719 my $pos = 0;
3720 my @params;
3721  
3722 # if ($sig->method) {
3723 # The $self value
3724 # push @params, {
3725 # name => 'arg0',
3726 # optional => 0,
3727 # position => $pos++,
3728 # };
3729 # }
3730  
3731 for my $p (@sig_params) {
3732 my $name = ($p->can('name') && defined($p->name) && length($p->name))
3733 ? $p->name
3734 : "arg$pos";
3735 push @params, {
3736 name => $name,
3737 optional => $p->optional ? 1 : 0,
3738 position => $pos,
3739 type => $p->type->name
3740 };
3741 $pos++;
3742 }
3743  
3744 # Extract return type
3745 my $returns;
3746 if (my $r = $sig->returns_scalar) {
3747 $returns = {
3748 context => 'scalar',
3749 type => $r ? $r->name : 'unknown',
3750 };
3751 } elsif ($r = $sig->returns_list) {
3752 $returns = {
3753 context => 'list',
3754 type => $r ? $r->name : 'unknown',
3755 };
3756 }
3757  
3758 print encode_json({
3759 parameters => \@params,
3760 returns => $returns,
3761 });
3762 PERL
3763  
3764 # Substitute function name and signature expression
3765 10 $payload =~ s/FUNCTION_NAME/$function/g;
3766 10 $payload =~ s/SIGNATURE_EXPR/$signature_expr/;
3767  
3768 # Run in an isolated Perl process
3769 10 my ($wtr, $rdr, $err) = (undef, undef, gensym);
3770 10 local %ENV;
3771  
3772 # Pass the memory limit to the child via env so the child can apply
3773 # setrlimit on itself after exec. Must NOT call setrlimit here in the
3774 # parent: setrlimit(RLIMIT_AS) constrains the parent's own address
3775 # space, and when the parent later tries to allocate memory for test
3776 # framework teardown it would OOM and crash inside the Test::Builder
3777 # subtest context, producing a "context destroyed" error.
3778 10 $ENV{_ATG_RLIMIT_AS} = $MEMORY_LIMIT_BYTES;
3779  
3780 10 my $pid = open3($wtr, $rdr, $err, $^X, '-T');
3781  
3782 10 print $wtr $payload;
3783 10 close $wtr;
3784  
3785 0 ▶ local $SIG{ALRM} = sub { croak 'Signature compile timeout' };
Subroutine __ANON__: not called CC=1 SCAR=1.2
3786 10 eval { alarm($SIGNATURE_TIMEOUT_SECS) }; # no-op on Windows
3787  
3788 10 my $stdout = do { local $/; <$rdr> };
3789 10 my $stderr = do { local $/; <$err> };
3790  
3791 10 eval { alarm 0 };
3792  
3793 10 waitpid($pid, 0);
3794  
3795 10 ▶ if ($stderr && length $stderr) {
Branch: 1 branch
BranchTrueFalseTotal
if ($stderr and length $stderr) 1 9 10
Condition66%2/3
$stderr and length $stderr
!ll&&!rl&&r
901
MC/DC50%1/2
$stderr and length $stderr
$stderr length $stderr
Truth table66%2/3
A and B
A= $stderrB= length $stderr
ABresult
0X0
100
111
3796 1 ▶ carp "Error compiling signature:\n$stderr" if $self->{verbose};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"verbose"} 0 1 1
3797 1 return;
3798 }
3799  
3800 # Child may be killed by the kernel OOM killer (SIGKILL) before it can
3801 # write anything to stdout or stderr. Guard both cases so we degrade
3802 # gracefully rather than croaking with "malformed JSON".
3803 9 ▶ if (!defined($stdout) || !length($stdout)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $stdout and length $stdout) 4 5 9
Condition66%2/3
defined $stdout and length $stdout
!ll&&!rl&&r
045
MC/DC50%1/2
defined $stdout and length $stdout
defined $stdout length $stdout
Truth table66%2/3
A and B
A= defined $stdoutB= length $stdout
ABresult
0X0
100
111
3804 4 ▶ carp 'Signature subprocess produced no output' if $self->{verbose};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"verbose"} 0 4 4
3805 4 return;
3806 }
3807  
3808 5 my $result = eval { decode_json($stdout) };
3809 5 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 3 2 5
3810 3 ▶ carp "Error decoding signature output: $@" if $self->{verbose};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"verbose"} 0 3 3
3811 3 return;
3812 }
3813 2 return $result;
3814 }
3815  
3816 # --------------------------------------------------
3817 # _build_schema_from_meta
3818 #
3819 # Purpose: Convert the parameter and return type
3820 # metadata produced by
3821 # _compile_signature_isolated into a
3822 # standard schema hashref.
3823 #
3824 # Entry: $meta - hashref with 'parameters'
3825 # arrayref and optional
3826 # 'returns' hashref, as decoded
3827 # from the isolated compile
3828 # JSON output.
3829 #
3830 # Exit: Returns a schema hashref with input,
3831 # output, style, source, _notes, and
3832 # _confidence keys.
3833 #
3834 # Side effects: None.
3835 #
3836 # Notes: Unknown Type::Params type names are
3837 # mapped to 'string' with a note added
3838 # and confidence downgraded to 'medium'.
3839 # --------------------------------------------------
3840 2 ▶sub _build_schema_from_meta {
Subroutine _build_schema_from_meta: called CC=9 SCAR=24.3
3841 2 my ($self, $meta) = @_;
3842  
3843 2 my %type_map = (
3844 Num => 'number',
3845 Int => 'integer',
3846 Str => 'string',
3847 Bool => 'boolean',
3848 Object => 'object',
3849 ArrayRef => 'array',
3850 HashRef => 'object',
3851 );
3852  
3853 2 my $input;
3854 2 my $position = 0;
3855 2 my $confidence = 'high';
3856 2 my @notes = ('Type::Params detected');
3857  
3858 2 ▶ foreach my $p (@{ $meta->{parameters} || [] }) {
Condition50%1/2
$meta->{'parameters'} || []
l!l
20
MC/DC0%0/1
$meta->{'parameters'} || []
$meta->{'parameters'}
Truth table50%1/2
A
A= $meta->{'parameters'}
Aresult
11
00
3859 4 ▶ my $type = $type_map{ $p->{type} } // 'string';
Condition50%1/2
$type_map{$p->{"type"}} // "string"
l!l
40
MC/DC0%0/1
$type_map{$p->{"type"}} // "string"
$type_map{$p->{"type"}}
Truth table50%1/2
A
A= $type_map{$p->{"type"}}
Aresult
11
00
3860  
3861 4 ▶ if (!exists $type_map{$p->{type}}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $type_map{$p->{"type"}}) 0 4 4
3862 0 push @notes, "Unknown type $p->{type}, defaulting to string";
3863 0 $confidence = 'medium';
3864 }
3865  
3866 $input->{"arg$position"} = {
3867 type => $type,
3868 position => $position,
3869 4 ▶ optional => $p->{optional} ? 1 : 0,
Branch: 1 branch
BranchTrueFalseTotal
$p->{'optional'} ? : 0 4 4
3870 };
3871  
3872 4 $position++;
3873 }
3874  
3875 2 my $output;
3876  
3877 2 ▶ if (my $ret = $meta->{returns}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $ret = $meta->{"returns"}) 2 0 2
3878 2 ▶ my $type = $type_map{ $ret->{type} } // 'string';
Condition50%1/2
$type_map{$ret->{"type"}} // "string"
l!l
20
MC/DC0%0/1
$type_map{$ret->{"type"}} // "string"
$type_map{$ret->{"type"}}
Truth table50%1/2
A
A= $type_map{$ret->{"type"}}
Aresult
11
00
3879  
3880 2 ▶ if (!exists $type_map{$ret->{type}}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $type_map{$ret->{"type"}}) 0 2 2
3881 0 push @notes, "Unknown return type $ret->{type}, defaulting to string";
3882 0 $confidence = 'medium';
3883 }
3884  
3885 $output = {
3886 2 type => $type,
3887 "_$ret->{context}_context" => { type => $type },
3888 };
3889 }
3890  
3891 return {
3892 2 input => $input,
3893 output => $output,
3894 style => 'hash',
3895 source => SOURCE_VALIDATOR,
3896 _notes => \@notes,
3897 _confidence => {
3898 input => $confidence,
3899 },
3900 };
3901 }
3902  
3903 # --------------------------------------------------
3904 # _analyze_pod
3905 #
3906 # Purpose: Parse POD documentation for a method
3907 # and extract parameter names, types,
3908 # constraints, and optionality from
3909 # multiple POD patterns.
3910 #
3911 # Entry: $pod - string of POD content as
3912 # returned by _extract_pod_before.
3913 # May be undef or empty.
3914 #
3915 # Exit: Returns a hashref of parameter name
3916 # to parameter spec hashref. Returns an
3917 # empty hashref if no POD is provided
3918 # or no parameters are found.
3919 #
3920 # Side effects: Carps when a semantic type is
3921 # detected, advising the caller to
3922 # set config->properties.
3923 # Logs progress to stdout when
3924 # verbose is set.
3925 #
3926 # Notes: Three pattern strategies are tried
3927 # in order: (1) named Parameters section,
3928 # (2) inline $name - type format,
3929 # (3) =over/=item list. Parameters found
3930 # earlier take precedence over later
3931 # discoveries. Default values from POD
3932 # are merged in last.
3933 # --------------------------------------------------
3934 768 ▶sub _analyze_pod {
Subroutine _analyze_pod: called CC=109 SCAR=59.2
3935 768 my ($self, $pod) = @_;
3936  
3937 768 ▶ return {} unless $pod;
Branch: 1 branch
BranchTrueFalseTotal
unless $pod 252 516 768
3938  
3939 516 my %params;
3940 516 my $position_counter = 0;
3941  
3942 # Check for positional arguments in method signature
3943 # Pattern: =head2 method_name($arg1, $arg2, $arg3)
3944 516 ▶ if ($pod =~ /=head2\s+\w+\s*\(([^)]+)\)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /=head2\s+\w+\s*\(([^)]+)\)/s) 34 482 516
3945 34 my $sig = $1;
3946 # Extract parameter names in order
3947 34 my @sig_params = $sig =~ /\$(\w+)/g;
3948  
3949 # Skip $self or $class
3950 34 ▶ shift @sig_params if @sig_params && $sig_params[0] =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if @sig_params and $sig_params[0] =~ /^(self|class|pkg|proto|klass)$/i 0 34 34
Condition33%1/3
@sig_params and $sig_params[0] =~ /^(self|class|pkg|proto|klass)$/i
!ll&&!rl&&r
0340
MC/DC0%0/2
@sig_params and $sig_params[0] =~ /^(self|class|pkg|proto|klass)$/i
@sig_params $sig_params[0] =~ /^(self|class|pkg|proto|klass)$/i
Truth table33%1/3
A and B
A= @sig_paramsB= $sig_params[0] =~ /^(self|class|pkg|proto|klass)$/i
ABresult
0X0
100
111
3951  
3952 # Assign positions
3953 34 foreach my $param (@sig_params) {
3954 46 ▶ $params{$param}{position} //= $position_counter;
Condition33%1/3
$params{$param}{"position"} //= $position_counter
l!l&&r!l&&!r
0460
MC/DC0%0/2
$params{$param}{"position"} //= $position_counter
$params{$param}{"position"} $position_counter
Truth table33%1/3
A //= B
A= $params{$param}{"position"}B= $position_counter
ABresult
1X1
011
000
3955 46 $self->_log(" POD: $param has position $params{$param}{position}");
3956 46 $position_counter++;
3957 }
3958 }
3959  
3960 516 $self->_log(" POD: Found $position_counter unnamed parameters to add to the position list");
3961  
3962 # Pattern 1: Parse line-by-line in Parameters section
3963 # First, extract the Parameters section
3964 516 my $param_section;
3965 516 ▶ if($pod =~ /(?:Parameters?|Arguments?|Inputs?):?\s*\n((?:\s*\$.*\n)+)/si) {
Branch: 2 branches
BranchTrueFalseTotal
if ($pod =~ /(?:Parameters?|Arguments?|Inputs?):?\s*\n((?:\s*\$.*\n)+)/is) { } 48 468 516
elsif ($pod =~ /^=head\d+\s+(?:Parameters?|Arguments?|Inputs?)\b.*?\n(.*?)(?=^=head|\Z)/ism) { } 397 71 468
3966 48 $param_section = $1;
3967 } elsif ($pod =~ /^=head\d+\s+(?:Parameters?|Arguments?|Inputs?)\b.*?\n(.*?)(?=^=head|\Z)/msi) {
3968 397 $param_section = $1;
3969 }
3970 516 ▶ if($param_section) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param_section) 445 71 516
3971 445 my $param_order = 0;
3972  
3973 445 $self->_log(" POD: Scan for named parameters in '$param_section'");
3974 # Now parse each line that starts with $varname
3975 445 foreach my $line (split /\n/, $param_section) {
3976 3324 ▶ if ($line =~ /C<\$(\w+)>\s*\((Required|Mandatory)\)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($line =~ /C<\$(\w+)>\s*\((Required|Mandatory)\)/i) 0 3324 3324
3977 0 $params{$1}{optional} = 0;
3978 0 $self->_log(" POD: $1 marked required from item header");
3979 }
3980  
3981 # Match: $name - type (constraints), description
3982 # or: $name - type, description
3983 # or: $name - type
3984 3324 ▶ if(($line =~ /^\s*\$(\w+)\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i) ||
Branch: 1 branch
BranchTrueFalseTotal
if ($line =~ /^\s*\$(\w+)\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i or $line =~ /^\s*C<\$(\w+)>\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i) 80 3244 3324
Condition100%3/3
$line =~ /^\s*\$(\w+)\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i or $line =~ /^\s*C<\$(\w+)>\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i
l!l&&r!l&&!r
7283244
MC/DC100%2/2
$line =~ /^\s*\$(\w+)\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i or $line =~ /^\s*C<\$(\w+)>\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i
$line =~ /^\s*\$(\w+)\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i $line =~ /^\s*C<\$(\w+)>\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i
Truth table100%3/3
A or B
A= $line =~ /^\s*\$(\w+)\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/iB= $line =~ /^\s*C<\$(\w+)>\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i
ABresult
1X1
011
000
3985 ($line =~ /^\s*C<\$(\w+)>\s*-\s*(\w+)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/i)) {
3986 80 my ($name, $type, $constraint, $desc) = ($1, lc($2), $3, $4);
3987  
3988 # Clean up
3989 80 ▶ $desc =~ s/^\s+|\s+$//g if $desc;
Branch: 1 branch
BranchTrueFalseTotal
if $desc 72 8 80
3990  
3991 # Skip common non-parameters
3992 80 ▶ next if $name =~ /^(self|class|pkg|proto|klass|return|returns?)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass|return|returns?)$/i 0 80 80
3993  
3994 80 ▶ $params{$name} ||= { _source => SOURCE_POD };
Condition100%2/2
$params{$name} ||= {"_source", "pod"}
l!l
2555
MC/DC100%1/1
$params{$name} ||= {"_source", "pod"}
$params{$name}
Truth table100%2/2
A
A= $params{$name}
Aresult
11
00
3995  
3996 # If we haven't already assigned a position from the signature, use order in Parameters section
3997 80 ▶ unless (exists $params{$name}{position}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $params{$name}{"position"}) 55 25 80
3998 55 $params{$name}{position} = $param_order++;
3999 55 $self->_log(" POD: $name has position $params{$name}{position} (from Parameters order)");
4000 }
4001  
4002 # Normalize type names
4003 80 ▶ $type = 'integer' if $type eq 'int';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "int" 0 80 80
4004 80 ▶ $type = 'number' if $type eq 'num' || $type eq 'float';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "num" or $type eq "float" 0 80 80
Condition33%1/3
$type eq "num" or $type eq "float"
l!l&&r!l&&!r
0080
MC/DC0%0/2
$type eq "num" or $type eq "float"
$type eq "num" $type eq "float"
Truth table33%1/3
A or B
A= $type eq "num"B= $type eq "float"
ABresult
1X1
011
000
4005 80 ▶ $type = 'boolean' if $type eq 'bool';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "bool" 0 80 80
4006 80 ▶ $type = 'arrayref' if $type eq 'array';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "array" 1 79 80
4007 80 ▶ $type = 'hashref' if $type eq 'hash';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "hash" 0 80 80
4008  
4009 80 $params{$name}{type} = $type;
4010  
4011 # Parse constraints
4012 80 ▶ if($constraint) {
Branch: 1 branch
BranchTrueFalseTotal
if ($constraint) 9 71 80
4013 9 $self->_parse_constraints($params{$name}, $constraint);
4014 }
4015  
4016 # Check for optional/required in description OR constraint.
4017 # Use word boundaries to avoid matching "optionally" as "optional".
4018 80 ▶ my $full_text = ($constraint || '') . ' ' . ($desc || '');
Condition100%4/4
$constraint || ''
l!l
971
$desc || ''
l!l
728
MC/DC100%1/1
$constraint || ''
$constraint
MC/DC100%1/1
$desc || ''
$desc
Truth table100%2/2
A
A= $constraint
Aresult
11
00
Truth table100%2/2
A
A= $desc
Aresult
11
00
4019 80 ▶ if ($full_text =~ /\boptional\b/i) {
Branch: 2 branches
BranchTrueFalseTotal
if ($full_text =~ /\boptional\b/i) { } 10 70 80
elsif ($full_text =~ /required|mandatory/i) { } 4 66 70
4020 10 $params{$name}{optional} = 1;
4021 10 $self->_log(" POD: $name marked as optional");
4022 } elsif ($full_text =~ /required|mandatory/i) {
4023 4 $params{$name}{optional} = 0;
4024 4 $self->_log(" POD: $name marked as required");
4025 }
4026  
4027 # Detect semantic types:
4028 80 ▶ if ($desc =~ /\b(email|url|uri|path|filename)\b/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($desc =~ /\b(email|url|uri|path|filename)\b/i) 4 76 80
4029 # TODO: ensure properties is set to 1 in $config
4030 4 carp('Manually set config->properties to 1 in ', $self->{'input_file'});
4031 4 $params{$name}{semantic} = lc($1);
4032 }
4033  
4034 # Look for regex patterns
4035 80 ▶ if ($desc && $desc =~ m{matches?\s+(/[^/]+/|qr/.+?/)}i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($desc and $desc =~ m[matches?\s+(/[^/]+/|qr/.+?/)]i) 6 74 80
Condition100%3/3
$desc and $desc =~ m[matches?\s+(/[^/]+/|qr/.+?/)]i
!ll&&!rl&&r
8666
MC/DC100%2/2
$desc and $desc =~ m[matches?\s+(/[^/]+/|qr/.+?/)]i
$desc $desc =~ m[matches?\s+(/[^/]+/|qr/.+?/)]i
Truth table100%3/3
A and B
A= $descB= $desc =~ m[matches?\s+(/[^/]+/|qr/.+?/)]i
ABresult
0X0
100
111
4036 6 $params{$name}{matches} = $1;
4037 6 $params{$name}{_source} = SOURCE_POD; # documentation, not a check
4038 }
4039  
4040 80 ▶ if(my $values = $self->_prose_memberof($desc)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $values = $self->_prose_memberof($desc)) 0 80 80
4041 0 $params{$name}{memberof} = $values;
4042 0 $params{$name}{_source} = SOURCE_POD; # documentation, not a check
4043 0 $self->_log(" POD: $name memberof from prose: " . join(', ', @{$values}));
4044 }
4045  
4046 80 ▶ $self->_log(" POD: Found parameter '$name' in parameters section, type=$type" .
Branch: 2 branches
BranchTrueFalseTotal
$constraint ? : 9 71 80
$desc ? : 72 8 80
4047 ($constraint ? " ($constraint)" : '') .
4048 ($desc ? " - $desc" : ''));
4049 }
4050 }
4051 }
4052  
4053 # Pattern 2: Also try the inline format in case Parameters: section wasn't found
4054 516 ▶ while ($pod =~ /\$(\w+)\s*-\s*(string|integer|int|number|num|float|boolean|bool|arrayref|array|hashref|hash|object|any)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/gim) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /\$(\w+)\s*-\s*(string|integer|int|number|num|float|boolean|bool|arrayref|array|hashref|hash|object|any)(?:\s*\(([^)]+)\))?\s*,?\s*(.*)$/mig) 58 516 574
4055 58 my ($name, $type, $constraint, $desc) = ($1, lc($2), $3, $4);
4056  
4057 # Only process if we haven't already found this param in the Parameters section
4058 58 ▶ next if exists $params{$name};
Branch: 1 branch
BranchTrueFalseTotal
if exists $params{$name} 58 0 58
4059  
4060 # Clean up description - remove leading/trailing whitespace
4061 0 ▶ $desc =~ s/^\s+|\s+$//g if $desc;
Branch: 1 branch
BranchTrueFalseTotal
if $desc 0 0 0
4062  
4063 # Skip common words that aren't parameters
4064 0 ▶ next if $name =~ /^(self|class|pkg|proto|klass|return|returns?)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass|return|returns?)$/i 0 0 0
4065  
4066 0 ▶ $params{$name} ||= { _source => SOURCE_POD };
Condition0%0/2
$params{$name} ||= {"_source", "pod"}
l!l
00
MC/DC0%0/1
$params{$name} ||= {"_source", "pod"}
$params{$name}
Truth table0%0/2
A
A= $params{$name}
Aresult
11
00
4067  
4068 # Normalize type names
4069 0 ▶ $type = 'integer' if $type eq 'int';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "int" 0 0 0
4070 0 ▶ $type = 'number' if $type eq 'num' || $type eq 'float';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "num" or $type eq "float" 0 0 0
Condition0%0/3
$type eq "num" or $type eq "float"
l!l&&r!l&&!r
000
MC/DC0%0/2
$type eq "num" or $type eq "float"
$type eq "num" $type eq "float"
Truth table0%0/3
A or B
A= $type eq "num"B= $type eq "float"
ABresult
1X1
011
000
4071 0 ▶ $type = 'boolean' if $type eq 'bool';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "bool" 0 0 0
4072 0 ▶ $type = 'arrayref' if $type eq 'array';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "array" 0 0 0
4073 0 ▶ $type = 'hashref' if $type eq 'hash';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "hash" 0 0 0
4074  
4075 0 $params{$name}{type} = $type;
4076  
4077 # Parse constraints
4078 0 ▶ if ($constraint) {
Branch: 1 branch
BranchTrueFalseTotal
if ($constraint) 0 0 0
4079 0 $self->_parse_constraints($params{$name}, $constraint);
4080 }
4081  
4082 # Check for optional/required in description.
4083 # Use word boundaries to avoid matching "optionally" as "optional".
4084 0 ▶ if ($desc) {
Branch: 1 branch
BranchTrueFalseTotal
if ($desc) 0 0 0
4085 0 ▶ if ($desc =~ /\boptional\b/i) {
Branch: 2 branches
BranchTrueFalseTotal
if ($desc =~ /\boptional\b/i) { } 0 0 0
elsif ($desc =~ /required|mandatory/i) { } 0 0 0
4086 0 $params{$name}{optional} = 1;
4087 } elsif ($desc =~ /required|mandatory/i) {
4088 0 $params{$name}{optional} = 0;
4089 }
4090  
4091 # Look for regex patterns in description
4092 0 ▶ if ($desc =~ m{matches?\s+(/[^/]+/|qr/.+?/)}i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($desc =~ m[matches?\s+(/[^/]+/|qr/.+?/)]i) 0 0 0
4093 0 $params{$name}{matches} = $1;
4094 }
4095 }
4096  
4097 0 ▶ if(my $values = $self->_prose_memberof($desc)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $values = $self->_prose_memberof($desc)) 0 0 0
4098 0 $params{$name}{memberof} = $values;
4099 0 $params{$name}{_source} = SOURCE_POD; # documentation, not a check
4100 0 $self->_log(" POD: $name memberof from prose: " . join(', ', @{$values}));
4101 }
4102  
4103 0 ▶ $self->_log(" POD: Found parameter '$name' in the inline documentation, type=$type" .
Branch: 1 branch
BranchTrueFalseTotal
$constraint ? : 0 0 0
4104 ($constraint ? " ($constraint)" : ''));
4105 }
4106  
4107 # Pattern 3: Parse =over /=item list of arguments, e.g. `=item * C<$name>`.
4108 # The sigil is required here: `=item * C<field>` without one usually
4109 # documents a returned key or an internal field, not an argument.
4110 #
4111 # Inside an Arguments section the sigil is optional: some modules write
4112 # `=item * C<mutation_results>` for a real argument. Add the sigil for
4113 # those items only, so a Returns list elsewhere still cannot name an
4114 # argument.
4115 516 my $item_pod = $pod;
4116 516 $item_pod =~ s{
4117 (?:^=head[2-6]\s+arguments?\b)
4118 (.*?)
4119 (?=^=head[1-6]\b|\z)
4120 }{
4121 287 my $section = $&;
4122 287 $section =~ s{^=item(\s+\*\s*)C<\s*([A-Za-z_]\w*)\s*>}{
4123 146 '=item' . $1 . 'C<$' . $2 . '>'
4124 }gme;
4125 287 $section;
4126 }msgeix;
4127  
4128 516 ▶ while ($item_pod =~ /=item\s+(?:\*\s*)?(?:C<)?\$(\w+)\b(?:>)?\s*(?:-.*)?\n?(.*?)(?==item|\=back|\=head)/sig) {
Branch: 1 branch
BranchTrueFalseTotal
if ($item_pod =~ /=item\s+(?:\*\s*)?(?:C<)?\$(\w+)\b(?:>)?\s*(?:-.*)?\n?(.*?)(?==item|\=back|\=head)/sig) 341 516 857
4129 341 my $name = $1;
4130 341 my $desc = $2;
4131  
4132 # Never allow empty or undefined parameter names
4133 341 ▶ next unless defined $name && length $name;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $name and length $name 0 341 341
Condition33%1/3
defined $name and length $name
!ll&&!rl&&r
00341
MC/DC0%0/2
defined $name and length $name
defined $name length $name
Truth table33%1/3
A and B
A= defined $nameB= length $name
ABresult
0X0
100
111
4134  
4135 341 $desc =~ s/^\s+|\s+$//g;
4136  
4137 # Skip common non-parameters
4138 341 ▶ next if $name =~ /^(self|class|pkg|proto|klass|return|returns?)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass|return|returns?)$/i 12 329 341
4139  
4140 329 ▶ $params{$name} ||= { _source => SOURCE_POD };
Condition100%2/2
$params{$name} ||= {"_source", "pod"}
l!l
2327
MC/DC100%1/1
$params{$name} ||= {"_source", "pod"}
$params{$name}
Truth table100%2/2
A
A= $params{$name}
Aresult
11
00
4141  
4142 # Explicit typed form only:
4143 # $param - type (constraints)
4144 329 ▶ if ($desc =~ /^\s*(string|integer|int|number|num|float|boolean|bool|array|arrayref|hash|hashref|any)\b(?:\s*\(([^)]+)\))?/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($desc =~ /^\s*(string|integer|int|number|num|float|boolean|bool|array|arrayref|hash|hashref|any)\b(?:\s*\(([^)]+)\))?/i) { } 44 285 329
4145 44 my $type = lc($1);
4146 44 my $constraint = $2;
4147  
4148 # Normalize type names
4149 44 ▶ $type = 'integer' if $type eq 'int';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "int" 0 44 44
4150 44 ▶ $type = 'number' if $type eq 'num' || $type eq 'float';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "num" or $type eq "float" 0 44 44
Condition33%1/3
$type eq "num" or $type eq "float"
l!l&&r!l&&!r
0044
MC/DC0%0/2
$type eq "num" or $type eq "float"
$type eq "num" $type eq "float"
Truth table33%1/3
A or B
A= $type eq "num"B= $type eq "float"
ABresult
1X1
011
000
4151 44 ▶ $type = 'boolean' if $type eq 'bool';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "bool" 0 44 44
4152 44 ▶ $type = 'arrayref' if $type eq 'array';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "array" 0 44 44
4153 44 ▶ $type = 'hashref' if $type eq 'hash';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "hash" 0 44 44
4154  
4155 44 $params{$name}{type} = $type;
4156  
4157 44 ▶ if ($constraint) {
Branch: 1 branch
BranchTrueFalseTotal
if ($constraint) 12 32 44
4158 12 $self->_parse_constraints($params{$name}, $constraint);
4159 }
4160  
4161 44 $self->_log(" POD: Explicit type '$type' for $name");
4162 } else {
4163 # Heuristic inference from description text
4164 285 ▶ if ($desc =~ /\bstring\b/i) {
Branch: 5 branches
BranchTrueFalseTotal
if ($desc =~ /\bstring\b/i) { } 24 261 285
elsif ($desc =~ /\b(int|integer)\b/i) { } 1 260 261
elsif ($desc =~ /\b(num|number|float)\b/i) { } 6 254 260
elsif ($desc =~ /\b(bool|boolean)\b/i) { } 0 254 254
elsif ($desc =~ /\bhashref\b/i) { } 66 188 254
4165 24 $params{$name}{type} = 'string';
4166 } elsif ($desc =~ /\b(int|integer)\b/i) {
4167 1 $params{$name}{type} = 'integer';
4168 } elsif ($desc =~ /\b(num|number|float)\b/i) {
4169 6 $params{$name}{type} = 'number';
4170 } elsif ($desc =~ /\b(bool|boolean)\b/i) {
4171 0 $params{$name}{type} = 'boolean';
4172 } elsif ($desc =~ /\bhashref\b/i) {
4173 # "either a path or an already decoded hashref": the harness
4174 # can build a hashref, so prefer it over the default string.
4175 66 $params{$name}{type} = 'hashref';
4176 }
4177 }
4178  
4179 # Check for optional/required in description.
4180 # Use word boundaries to avoid matching "optionally" as "optional".
4181 # Ignore code spans: a description that mentions the parameter name
4182 # C<optional> (CoverageGuidedFuzzer's schema) is not saying the
4183 # parameter itself is optional, and can still say "Required."
4184 329 my $optionality_text = $desc;
4185 329 $optionality_text =~ s/\b[CBIL]<[^>]*>//g;
4186 329 ▶ if ($optionality_text =~ /\boptional\b/i) {
Branch: 2 branches
BranchTrueFalseTotal
if ($optionality_text =~ /\boptional\b/i) { } 91 238 329
elsif ($optionality_text =~ /\b(?:required|mandatory)\b/i) { } 104 134 238
4187 91 $params{$name}{optional} = 1;
4188 } elsif ($optionality_text =~ /\b(?:required|mandatory)\b/i) {
4189 104 $params{$name}{optional} = 0;
4190 }
4191  
4192 # Look for regex patterns
4193 329 ▶ if ($desc =~ m{matches?\s+(/[^/]+/|qr/.+?/)}i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($desc =~ m[matches?\s+(/[^/]+/|qr/.+?/)]i) 0 329 329
4194 0 $params{$name}{matches} = $1;
4195 0 $params{$name}{_source} = SOURCE_POD; # documentation, not a check
4196 }
4197  
4198 329 ▶ if(my $values = $self->_prose_memberof($desc)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $values = $self->_prose_memberof($desc)) 8 321 329
4199 8 $params{$name}{memberof} = $values;
4200 8 $params{$name}{_source} = SOURCE_POD; # documentation, not a check
4201 8 $self->_log(" POD: $name memberof from prose: " . join(', ', @{$values}));
4202 }
4203  
4204 329 $self->_log(" POD: Found parameter '$name' from =item list");
4205 }
4206  
4207 # Extract default values from POD
4208 516 my $pod_defaults = $self->_extract_defaults_from_pod($pod);
4209 516 foreach my $param (keys %$pod_defaults) {
4210 21 ▶ if (exists $params{$param}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $params{$param}) 15 6 21
4211 15 $params{$param}{_default} = $pod_defaults->{$param};
4212 15 ▶ $params{$param}{optional} = 1 unless defined $params{$param}{optional};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $params{$param}{"optional"} 7 8 15
4213 $self->_log(sprintf(" POD: %s has default value: %s",
4214 $param,
4215 15 ▶ defined($pod_defaults->{$param}) ? $pod_defaults->{$param} : 'undef'
Branch: 1 branch
BranchTrueFalseTotal
defined $pod_defaults->{$param} ? : 14 1 15
4216 ));
4217 }
4218 }
4219  
4220 # Default undocumented optionality: documented params are REQUIRED unless stated otherwise
4221 516 for my $name (keys %params) {
4222 428 ▶ next if $name =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass)$/i 0 428 428
4223  
4224 # TODO: if optionality was never explicitly set, assume required.
4225 # Currently disabled as it breaks some schemas — revisit in a future pass.
4226 # if (!exists $params{$name}{optional}) {
4227 # $params{$name}{optional} = 0;
4228 # $self->_log(" POD: $name assumed required (no optional/default specified)");
4229 # }
4230 }
4231  
4232 # Pattern 0: =head3|4 Input formal spec — highest-priority type source.
4233 # Runs last so positional matching can use positions set by earlier patterns.
4234 # Accepts positional array format: [ {type=>'...'}, ... ]
4235 # and named hash format: { name => {type=>'...'}, ... }
4236 516 ▶ if ($pod =~ /=head[34]\s+Input\b(.*?)(?==head|\z)/si) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /=head[34]\s+Input\b(.*?)(?==head|\z)/is) 366 150 516
4237 366 my $block = $1;
4238 366 $block =~ s/\A\s+//;
4239 # The spec may follow introductory prose and comment lines: start at
4240 # the first line that opens the structure.
4241 366 ▶ $block =~ s/\A.*?^[ \t]+(?=[\[\{])//ms unless($block =~ /\A[\[\{]/);
Branch: 1 branch
BranchTrueFalseTotal
unless $block =~ /\A[\[\{]/ 15 351 366
4242  
4243 366 ▶ if ($block =~ /\A\[/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($block =~ /\A\[/) { } 4 362 366
elsif ($block =~ /\A\{/) { } 348 14 362
4244 # Positional format: each {…} maps to the param at that array index.
4245 4 my $idx = 0;
4246 4 ▶ while ($block =~ /\{([^}]*)\}/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($block =~ /\{([^}]*)\}/g) 6 4 10
4247 6 my $spec = $1;
4248 0 ▶ my ($name) = grep { ($params{$_}{position} // -1) == $idx }
Condition0%0/2
$params{$_}{"position"} // -1
l!l
00
MC/DC0%0/1
$params{$_}{"position"} // -1
$params{$_}{"position"}
Truth table0%0/2
A
A= $params{$_}{"position"}
Aresult
11
00
4249 keys %params;
4250 6 ▶ if (defined $name) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $name) 0 6 6
4251 0 $params{$name}{_source} = SOURCE_INPUT_SPEC;
4252 0 ▶ if (my $t = $self->_map_formal_input_type($spec)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $t = $self->_map_formal_input_type($spec)) 0 0 0
4253 0 $params{$name}{type} = $t;
4254 0 $self->_log(" POD: $name type '$t' from =head Input (positional $idx)");
4255 }
4256 0 ▶ if ($spec =~ /\boptional\s*=>\s*(0|1)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($spec =~ /\boptional\s*=>\s*(0|1)/i) 0 0 0
4257 0 $params{$name}{optional} = $1 + 0;
4258 }
4259 }
4260 6 $idx++;
4261 }
4262 } elsif ($block =~ /\A\{/) {
4263 # Named format: each 'name => {…}' entry maps directly by name.
4264 348 ▶ while ($block =~ /\b(\w+)\s*=>\s*\{([^}]*)\}/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($block =~ /\b(\w+)\s*=>\s*\{([^}]*)\}/g) 578 348 926
4265 578 my ($name, $spec) = ($1, $2);
4266 578 ▶ next if $name =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass)$/i 210 368 578
4267 368 ▶ $params{$name} //= { _source => SOURCE_INPUT_SPEC };
Condition100%2/2
$params{$name} //= {"_source", "input_spec"}
l!l
29078
MC/DC100%1/1
$params{$name} //= {"_source", "input_spec"}
$params{$name}
Truth table100%2/2
A
A= $params{$name}
Aresult
11
00
4268 368 $params{$name}{_source} = SOURCE_INPUT_SPEC;
4269 368 ▶ if (my $t = $self->_map_formal_input_type($spec)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $t = $self->_map_formal_input_type($spec)) 368 0 368
4270 368 $params{$name}{type} = $t;
4271 368 $self->_log(" POD: $name type '$t' from =head Input (named)");
4272 }
4273 368 ▶ if ($spec =~ /\boptional\s*=>\s*(0|1)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($spec =~ /\boptional\s*=>\s*(0|1)/i) 192 176 368
4274 192 $params{$name}{optional} = $1 + 0;
4275 }
4276 368 ▶ if ($spec =~ /\bmemberof\s*=>\s*\[([^\]]*)\]/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($spec =~ /\bmemberof\s*=>\s*\[([^\]]*)\]/i) 4 364 368
4277 4 my $list_str = $1;
4278 4 my @vals;
4279 4 ▶ while ($list_str =~ /['"]([^'"]*)['"]/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($list_str =~ /['"]([^'"]*)['"]/g) 8 4 12
4280 8 push @vals, $1;
4281 }
4282 4 ▶ if(@vals) {
Branch: 1 branch
BranchTrueFalseTotal
if (@vals) 4 0 4
4283 4 $params{$name}{memberof} = \@vals;
4284 # The list is documentation: the code may accept more.
4285 4 $params{$name}{_source} = SOURCE_INPUT_SPEC;
4286 }
4287 }
4288 368 ▶ if ($spec =~ /\bmin\s*=>\s*(\d+)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($spec =~ /\bmin\s*=>\s*(\d+)/i) 46 322 368
4289 46 $params{$name}{min} = $1 + 0;
4290 }
4291 368 ▶ if ($spec =~ /\bmax\s*=>\s*(\d+)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($spec =~ /\bmax\s*=>\s*(\d+)/i) 29 339 368
4292 29 $params{$name}{max} = $1 + 0;
4293 }
4294 # A documented size is a claim about valid input, not a check
4295 # the routine has been seen to make: NameCase's spec says
4296 # min => 1 while its code accepts []. The harness still uses
4297 # the bound to build valid data, but generates no outside case.
4298 368 ▶ if(exists($params{$name}{min}) || exists($params{$name}{max})) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $params{$name}{"min"} or exists $params{$name}{"max"}) 59 309 368
Condition100%3/3
exists $params{$name}{"min"} or exists $params{$name}{"max"}
l!l&&r!l&&!r
4613309
MC/DC100%2/2
exists $params{$name}{"min"} or exists $params{$name}{"max"}
exists $params{$name}{"min"} exists $params{$name}{"max"}
Truth table100%3/3
A or B
A= exists $params{$name}{"min"}B= exists $params{$name}{"max"}
ABresult
1X1
011
000
4299 59 $params{$name}{_source} = SOURCE_INPUT_SPEC;
4300 }
4301 368 ▶ if ($spec =~ /\bisa\s*=>\s*['"]([^'"]+)['"]/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($spec =~ /\bisa\s*=>\s*['"]([^'"]+)['"]/i) 36 332 368
4302 36 $params{$name}{isa} = $1;
4303 }
4304 }
4305 # Two or more documented names signal a hash/named API, and
4306 # positional info from signature analysis is then not meaningful:
4307 # it causes "param X missing position" errors when params are
4308 # mixed. A lone name may instead label the first positional
4309 # argument, which _positional_pod_input decides once the body is
4310 # known.
4311 348 delete $params{$_}{position} for keys %params;
4312 }
4313 }
4314  
4315 # Documented value lists in =item prose, e.g.
4316 # =item * C<$colour> - one of red, green or blue
4317 # Run after the formal =head Input spec, which can be the only place a
4318 # parameter is named (strict_pod is such a parameter): the prose list
4319 # then still reaches it. Only parameters already found are updated:
4320 # a Returns section also uses =item, and its entries are outputs.
4321 516 ▶ while ($pod =~ /=item\s+(?:\*\s*)?(?:C<\$?(\w+)>|\$(\w+))\s*-?\s*((?:[^\n]*\n)*?)(?==item|\=back|\=head)/gi) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /=item\s+(?:\*\s*)?(?:C<\$?(\w+)>|\$(\w+))\s*-?\s*((?:[^\n]*\n)*?)(?==item|\=back|\=head)/gi) 442 516 958
4322 442 ▶ my ($name, $text) = ($1 // $2, $3);
Condition66%2/3
$1 // $2
l!l&&r!l&&!r
44110
MC/DC0%0/2
$1 // $2
$1 $2
Truth table66%2/3
A // B
A= $1B= $2
ABresult
1X1
011
000
4323 442 ▶ next unless $params{$name};
Branch: 1 branch
BranchTrueFalseTotal
unless $params{$name} 109 333 442
4324 333 ▶ next if defined($params{$name}{memberof});
Branch: 1 branch
BranchTrueFalseTotal
if defined $params{$name}{"memberof"} 8 325 333
4325  
4326 325 ▶ if(my $values = $self->_prose_memberof($text)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $values = $self->_prose_memberof($text)) 0 325 325
4327 0 $params{$name}{memberof} = $values;
4328 0 $params{$name}{_source} = SOURCE_POD; # documentation, not a check
4329 0 $self->_log(" POD: $name memberof from prose: " . join(', ', @{$values}));
4330 }
4331 }
4332  
4333 516 $self->_sanitize_parameter_names(\%params, 'POD analysis');
4334 516 return \%params;
4335 }
4336  
4337 # --------------------------------------------------
4338 # _map_formal_input_type
4339 #
4340 # Purpose: Extract and normalise the type string
4341 # from a parameter spec fragment such as
4342 # "type => 'scalar | scalarref'".
4343 # Handles union types by returning the
4344 # canonical ATG type for the first
4345 # recognised alternative.
4346 #
4347 # Entry: $spec - text content of a { } block
4348 # from a =head3|4 Input spec.
4349 #
4350 # Exit: Canonical type string, or undef when
4351 # no 'type' key is present or the value
4352 # is not a recognised type name.
4353 # --------------------------------------------------
4354 373 ▶sub _map_formal_input_type {
Subroutine _map_formal_input_type: called CC=5 SCAR=16.1
4355 373 my ($self, $spec) = @_;
4356 # Accept both quoted type => 'scalar' and unquoted Params::Validate
4357 # constants type => OBJECT (no quotes around the constant name).
4358 373 ▶ return undef unless $spec =~ /\btype\s*=>\s*(?:['"]([^'"]+)['"]|([A-Z_]+))/i;
Branch: 1 branch
BranchTrueFalseTotal
unless $spec =~ /\btype\s*=>\s*(?:['"]([^'"]+)['"]|([A-Z_]+))/i 1 372 373
4359 372 ▶ my $raw = lc(defined($1) ? $1 : $2);
Branch: 1 branch
BranchTrueFalseTotal
defined $1 ? : 132 240 372
4360 372 $raw =~ s/\s+//g;
4361  
4362 372 my %map = (
4363 scalar => 'string',
4364 scalarref => 'string',
4365 str => 'string',
4366 string => 'string',
4367 int => 'integer',
4368 integer => 'integer',
4369 num => 'number',
4370 number => 'number',
4371 float => 'number',
4372 bool => 'boolean',
4373 boolean => 'boolean',
4374 array => 'arrayref',
4375 arrayref => 'arrayref',
4376 hash => 'hashref',
4377 hashref => 'hashref',
4378 object => 'object',
4379 any => 'any',
4380 undef => 'undef',
4381 coderef => 'coderef',
4382 );
4383  
4384 372 for my $t (split /\|/, $raw) {
4385 372 ▶ return $map{$t} if exists $map{$t};
Branch: 1 branch
BranchTrueFalseTotal
if exists $map{$t} 371 1 372
4386 }
4387 1 return undef;
4388 }
4389  
4390 # --------------------------------------------------
4391 # _analyze_output
4392 #
4393 # Purpose: Orchestrate analysis of a method's
4394 # return value by combining POD return
4395 # section parsing, code return statement
4396 # analysis, boolean detection, context
4397 # detection, void detection, chaining
4398 # detection, and error convention
4399 # detection.
4400 #
4401 # Entry: $pod - POD string for the method.
4402 # $code - method body source string.
4403 # $method_name - name of the method being
4404 # analysed, used for
4405 # boolean heuristics.
4406 #
4407 # Exit: Returns a hashref describing the
4408 # output type and behaviour, or an empty
4409 # hashref if nothing could be determined.
4410 # Keys include: type, value, isa, and
4411 # various _* metadata keys.
4412 #
4413 # Side effects: Logs progress to stdout when
4414 # verbose is set.
4415 # --------------------------------------------------
4416 766 ▶sub _analyze_output {
Subroutine _analyze_output: called CC=3 SCAR=11.0
4417 766 my ($self, $pod, $code, $method_name) = @_;
4418  
4419 766 my %output;
4420  
4421 766 $self->_analyze_output_from_pod(\%output, $pod);
4422 766 $self->_analyze_output_from_code(\%output, $code, $method_name);
4423 766 $self->_enhance_boolean_detection(\%output, $pod, $code, $method_name);
4424 766 $self->_detect_list_context(\%output, $code);
4425 766 $self->_detect_void_context(\%output, $code, $method_name);
4426 766 $self->_detect_chaining_pattern(\%output, $code);
4427 766 $self->_detect_error_conventions(\%output, $code);
4428  
4429 766 ▶ $self->_validate_output(\%output) if keys %output;
Branch: 1 branch
BranchTrueFalseTotal
if keys %output 740 26 766
4430  
4431 # Don't return empty output
4432 766 ▶ return (keys %output) ? \%output : {};
Branch: 1 branch
BranchTrueFalseTotal
keys %output ? : 740 26 766
4433 }
4434  
4435 # --------------------------------------------------
4436 # _analyze_output_from_pod
4437 #
4438 # Purpose: Parse the POD documentation for a
4439 # method's return value and populate
4440 # an output hashref with type, value,
4441 # and behaviour information.
4442 #
4443 # Entry: $output - hashref to populate
4444 # (modified in place).
4445 # $pod - POD string for the method.
4446 #
4447 # Exit: Returns nothing. Modifies $output
4448 # in place.
4449 #
4450 # Side effects: Logs detections to stdout when
4451 # verbose is set.
4452 #
4453 # Notes: Two patterns are tried: (1) a
4454 # 'Returns:' section of up to 3 lines,
4455 # and (2) an inline 'returns X' phrase.
4456 # The section pattern takes precedence.
4457 # --------------------------------------------------
4458 764 ▶sub _analyze_output_from_pod {
Subroutine _analyze_output_from_pod: called CC=61 SCAR=54.0
4459 764 my ($self, $output, $pod) = @_;
4460 764 my %VALID_OUTPUT_TYPES = map { $_ => 1 }
4461 qw(string integer number float boolean arrayref hashref object coderef void undef);
4462  
4463 764 ▶ if ($pod) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod) 512 252 764
4464 # Pattern 0: =head4 Output formal spec (highest priority — explicit over heuristic)
4465 # The outer container shape determines the return type:
4466 # (...) — list/array of items
4467 # [...] — arrayref (bare [] = empty/void, skip)
4468 # {...} — hashref spec; look for type => inside, or isa => for object
4469 512 ▶ if($pod =~ /=head4\s+Output\b(.*?)(?==head|\z)/si) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /=head4\s+Output\b(.*?)(?==head|\z)/is) 359 153 512
4470 359 my $block = $1;
4471 359 $block =~ s/^\s+//;
4472 359 ▶ if($block =~ /^\(/) {
Branch: 3 branches
BranchTrueFalseTotal
if ($block =~ /^\(/) { } 2 357 359
elsif ($block =~ /^\[/) { } 0 357 357
elsif ($block =~ /^\{/) { } 357 0 357
4473 2 $output->{type} = 'array';
4474 2 $self->_log(" OUTPUT: type 'array' from =head4 Output list notation");
4475 } elsif($block =~ /^\[/) {
4476 0 ▶ unless($block =~ /^\[\s*\]/) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($block =~ /^\[\s*\]/) 0 0 0
4477 0 $output->{type} = 'arrayref';
4478 0 $self->_log(" OUTPUT: type 'arrayref' from =head4 Output arrayref notation");
4479 }
4480 } elsif($block =~ /^\{/) {
4481 357 ▶ if($block =~ /type\s*=>\s*['"]?(\w[\w:]*?)['"]?\s*[,}]/i) {
Branch: 2 branches
BranchTrueFalseTotal
if ($block =~ /type\s*=>\s*['"]?(\w[\w:]*?)['"]?\s*[,}]/i) { } 354 3 357
elsif ($block =~ /\bisa\s*=>/) { } 0 3 3
4482 354 my $type = lc($1);
4483 354 ▶ $type = 'string' if $type eq 'scalar' || $type eq 'scalarref' || $type eq 'str';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "scalar" or $type eq "scalarref" or $type eq "str" 97 257 354
Condition83%5/6
$type eq "scalar" or $type eq "scalarref" or $type eq "str"
l!l&&r!l&&!r
970257
$type eq "scalar" or $type eq "scalarref"
l!l&&r!l&&!r
943257
MC/DC66%2/3
$type eq "scalar" or $type eq "scalarref" or $type eq "str"
$type eq "scalar" $type eq "scalarref" $type eq "str"
Truth table75%3/4
A or B or C
A= $type eq "scalar"B= $type eq "scalarref"C= $type eq "str"
ABCresult
1XX1
01X1
0011
0000
4484 354 ▶ $type = 'integer' if $type eq 'int';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "int" 0 354 354
4485 354 ▶ $type = 'number' if $type eq 'float' || $type eq 'num';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "float" or $type eq "num" 0 354 354
Condition33%1/3
$type eq "float" or $type eq "num"
l!l&&r!l&&!r
00354
MC/DC0%0/2
$type eq "float" or $type eq "num"
$type eq "float" $type eq "num"
Truth table33%1/3
A or B
A= $type eq "float"B= $type eq "num"
ABresult
1X1
011
000
4486 354 ▶ $type = 'boolean' if $type eq 'bool';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "bool" 0 354 354
4487 354 ▶ $type = 'hashref' if $type eq 'hash';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "hash" 0 354 354
4488 354 ▶ $type = 'arrayref' if $type eq 'array';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "array" 0 354 354
4489 354 ▶ if($VALID_OUTPUT_TYPES{$type}) {
Branch: 2 branches
BranchTrueFalseTotal
if ($VALID_OUTPUT_TYPES{$type}) { } 354 0 354
elsif ($block =~ /\bisa\s*=>/) { } 0 0 0
4490 354 $output->{type} = $type;
4491 354 $self->_log(" OUTPUT: type '$type' from =head4 Output formal spec");
4492 } elsif($block =~ /\bisa\s*=>/) {
4493 0 $output->{type} = 'object';
4494 0 $self->_log(" OUTPUT: type 'object' from =head4 Output isa spec");
4495 }
4496 } elsif($block =~ /\bisa\s*=>/) {
4497 0 $output->{type} = 'object';
4498 0 $self->_log(" OUTPUT: type 'object' from =head4 Output isa spec");
4499 }
4500 }
4501 }
4502  
4503 # Pattern 1: Returns: section
4504 # Up to 3 lines
4505 512 ▶ if ($pod =~ /Returns?:\s+([^\n]+(?:\n[^\n]+){0,2})/si) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /Returns?:\s+([^\n]+(?:\n[^\n]+){0,2})/is) 30 482 512
4506 30 my $returns_desc = $1;
4507 30 $returns_desc =~ s/^\s+|\s+$//g;
4508  
4509 30 $self->_log(" OUTPUT: Found Returns section: $returns_desc");
4510  
4511 # Try to infer type from description (skip if Pattern 0 already set type)
4512 30 ▶ if (!$output->{type} && $returns_desc =~ /\b(string|text)\b/i) {
Branch: 8 branches
BranchTrueFalseTotal
if (not $output->{'type'} and $returns_desc =~ /\b(string|text)\b/i) { } 3 27 30
elsif (not $output->{'type'} and $returns_desc =~ /\b(integer|int|count)\b/i) { } 6 21 27
elsif (not $output->{'type'} and $returns_desc =~ /\b(float|decimal|number)\b/i) { } 2 19 21
elsif (not $output->{'type'} and $returns_desc =~ /\b(boolean|true|false)\b/i) { } 7 12 19
elsif (not $output->{'type'} and $returns_desc =~ /\b(array|list)\b/i) { } 0 12 12
elsif (not $output->{'type'} and $returns_desc =~ /\b(hash|hashref|dictionary)\b/i) { } 1 11 12
elsif (not $output->{'type'} and $returns_desc =~ /\b(object|instance)\b/i) { } 2 9 11
elsif (not $output->{'type'} and $returns_desc =~ /\bundef\b/i) { } 0 15 15
Condition100%3/3
not $output->{"type"} and $returns_desc =~ /\b(string|text)\b/i
!ll&&!rl&&r
6213
MC/DC100%2/2
not $output->{"type"} and $returns_desc =~ /\b(string|text)\b/i
not $output->{"type"} $returns_desc =~ /\b(string|text)\b/i
Truth table100%3/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\b(string|text)\b/i
ABresult
0X0
100
111
4513 3 $output->{type} = 'string';
4514 ▶ } elsif (!$output->{type} && $returns_desc =~ /\b(integer|int|count)\b/i) {
Condition100%3/3
not $output->{"type"} and $returns_desc =~ /\b(integer|int|count)\b/i
!ll&&!rl&&r
6156
MC/DC100%2/2
not $output->{"type"} and $returns_desc =~ /\b(integer|int|count)\b/i
not $output->{"type"} $returns_desc =~ /\b(integer|int|count)\b/i
Truth table100%3/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\b(integer|int|count)\b/i
ABresult
0X0
100
111
4515 6 $output->{type} = 'integer';
4516 ▶ } elsif (!$output->{type} && $returns_desc =~ /\b(float|decimal|number)\b/i) {
Condition100%3/3
not $output->{"type"} and $returns_desc =~ /\b(float|decimal|number)\b/i
!ll&&!rl&&r
6132
MC/DC100%2/2
not $output->{"type"} and $returns_desc =~ /\b(float|decimal|number)\b/i
not $output->{"type"} $returns_desc =~ /\b(float|decimal|number)\b/i
Truth table100%3/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\b(float|decimal|number)\b/i
ABresult
0X0
100
111
4517 2 $output->{type} = 'number';
4518 ▶ } elsif (!$output->{type} && $returns_desc =~ /\b(boolean|true|false)\b/i) {
Condition100%3/3
not $output->{"type"} and $returns_desc =~ /\b(boolean|true|false)\b/i
!ll&&!rl&&r
667
MC/DC100%2/2
not $output->{"type"} and $returns_desc =~ /\b(boolean|true|false)\b/i
not $output->{"type"} $returns_desc =~ /\b(boolean|true|false)\b/i
Truth table100%3/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\b(boolean|true|false)\b/i
ABresult
0X0
100
111
4519 7 $output->{type} = 'boolean';
4520 ▶ } elsif (!$output->{type} && $returns_desc =~ /\b(array|list)\b/i) {
Condition66%2/3
not $output->{"type"} and $returns_desc =~ /\b(array|list)\b/i
!ll&&!rl&&r
660
MC/DC0%0/2
not $output->{"type"} and $returns_desc =~ /\b(array|list)\b/i
not $output->{"type"} $returns_desc =~ /\b(array|list)\b/i
Truth table66%2/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\b(array|list)\b/i
ABresult
0X0
100
111
4521 0 $output->{type} = 'arrayref';
4522 ▶ } elsif (!$output->{type} && $returns_desc =~ /\b(hash|hashref|dictionary)\b/i) {
Condition100%3/3
not $output->{"type"} and $returns_desc =~ /\b(hash|hashref|dictionary)\b/i
!ll&&!rl&&r
651
MC/DC100%2/2
not $output->{"type"} and $returns_desc =~ /\b(hash|hashref|dictionary)\b/i
not $output->{"type"} $returns_desc =~ /\b(hash|hashref|dictionary)\b/i
Truth table100%3/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\b(hash|hashref|dictionary)\b/i
ABresult
0X0
100
111
4523 1 $output->{type} = 'hashref';
4524 ▶ } elsif (!$output->{type} && $returns_desc =~ /\b(object|instance)\b/i) {
Condition100%3/3
not $output->{"type"} and $returns_desc =~ /\b(object|instance)\b/i
!ll&&!rl&&r
632
MC/DC100%2/2
not $output->{"type"} and $returns_desc =~ /\b(object|instance)\b/i
not $output->{"type"} $returns_desc =~ /\b(object|instance)\b/i
Truth table100%3/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\b(object|instance)\b/i
ABresult
0X0
100
111
4525 2 $output->{type} = 'object';
4526 ▶ } elsif (!$output->{type} && $returns_desc =~ /\bundef\b/i) {
Condition66%2/3
not $output->{"type"} and $returns_desc =~ /\bundef\b/i
!ll&&!rl&&r
630
MC/DC0%0/2
not $output->{"type"} and $returns_desc =~ /\bundef\b/i
not $output->{"type"} $returns_desc =~ /\bundef\b/i
Truth table66%2/3
not(A) and B
A= not $output->{"type"}B= $returns_desc =~ /\bundef\b/i
ABresult
0X0
100
111
4527 0 $output->{type} = 'undef';
4528 }
4529  
4530 # Look for specific values
4531 30 ▶ if ($returns_desc =~ /\b1\s+(?:on\s+success|if\s+successful)\b/i) {
Branch: 3 branches
BranchTrueFalseTotal
if ($returns_desc =~ /\b1\s+(?:on\s+success|if\s+successful)\b/i) { } 0 30 30
elsif ($returns_desc =~ /\b0\s+(?:on\s+failure|if\s+fail)\b/i) { } 0 30 30
elsif ($returns_desc =~ /dies\s+on\s+(?:error|failure)/i) { } 0 30 30
4532 0 $output->{value} = 1;
4533 0 ▶ if(defined($output->{'type'}) && ($output->{type} eq 'scalar')) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $output->{'type'} and $output->{'type'} eq 'scalar') { } 0 0 0
Condition0%0/3
defined $output->{"type"} and $output->{"type"} eq "scalar"
!ll&&!rl&&r
000
MC/DC0%0/2
defined $output->{"type"} and $output->{"type"} eq "scalar"
defined $output->{"type"} $output->{"type"} eq "scalar"
Truth table0%0/3
A and B
A= defined $output->{"type"}B= $output->{"type"} eq "scalar"
ABresult
0X0
100
111
4534 0 $output->{type} = 'boolean';
4535 } else {
4536 0 ▶ $output->{type} ||= 'boolean';
Condition0%0/2
$output->{"type"} ||= "boolean"
l!l
00
MC/DC0%0/1
$output->{"type"} ||= "boolean"
$output->{"type"}
Truth table0%0/2
A
A= $output->{"type"}
Aresult
11
00
4537 }
4538 0 $self->_log(" OUTPUT: Returns 1 on success");
4539 } elsif ($returns_desc =~ /\b0\s+(?:on\s+failure|if\s+fail)\b/i) {
4540 0 $output->{alt_value} = 0;
4541 } elsif ($returns_desc =~ /dies\s+on\s+(?:error|failure)/i) {
4542 0 $output->{_STATUS} = 'LIVES';
4543 0 $self->_log(' OUTPUT: Should not die on success');
4544 }
4545 30 ▶ if ($returns_desc =~ /\b(true|false)\b/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($returns_desc =~ /\b(true|false)\b/i) 3 27 30
4546 3 ▶ $output->{type} ||= 'boolean';
Condition50%1/2
$output->{"type"} ||= "boolean"
l!l
30
MC/DC0%0/1
$output->{"type"} ||= "boolean"
$output->{"type"}
Truth table50%1/2
A
A= $output->{"type"}
Aresult
11
00
4547 }
4548 30 ▶ if ($returns_desc =~ /\bundef\b/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($returns_desc =~ /\bundef\b/i) 0 30 30
4549 0 $output->{optional} = 1;
4550 }
4551 }
4552  
4553 # Pattern 2: Inline "returns X"
4554 512 ▶ if((!$output->{type}) && ($pod =~ /returns?\s+(?:an?\s+)?(\w+)/i)) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $output->{"type"} and $pod =~ /returns?\s+(?:an?\s+)?(\w+)/i) 43 469 512
Condition100%3/3
not $output->{"type"} and $pod =~ /returns?\s+(?:an?\s+)?(\w+)/i
!ll&&!rl&&r
3779243
MC/DC100%2/2
not $output->{"type"} and $pod =~ /returns?\s+(?:an?\s+)?(\w+)/i
not $output->{"type"} $pod =~ /returns?\s+(?:an?\s+)?(\w+)/i
Truth table100%3/3
not(A) and B
A= not $output->{"type"}B= $pod =~ /returns?\s+(?:an?\s+)?(\w+)/i
ABresult
0X0
100
111
4555 43 my $type = lc($1);
4556  
4557 43 ▶ $type = 'boolean' if $type =~ /^(true|false|bool)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $type =~ /^(true|false|bool)$/ 10 33 43
4558 # Skip if it's just a number (like "returns 1")
4559 43 ▶ $type = 'integer' if $type eq 'int';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "int" 0 43 43
4560 43 ▶ $type = 'number' if $type =~ /^(num|float)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $type =~ /^(num|float)$/ 0 43 43
4561 43 ▶ $type = 'arrayref' if $type eq 'array';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "array" 0 43 43
4562 43 ▶ $type = 'hashref' if $type eq 'hash';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "hash" 0 43 43
4563  
4564 43 ▶ if($type =~ /^\d+$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type =~ /^\d+$/) 0 43 43
4565 0 ▶ if($type eq '1' || $type eq '0') {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq '1' or $type eq '0') { } 0 0 0
Condition0%0/3
$type eq 1 or $type eq 0
l!l&&r!l&&!r
000
MC/DC0%0/2
$type eq 1 or $type eq 0
$type eq 1 $type eq 0
Truth table0%0/3
A or B
A= $type eq 1B= $type eq 0
ABresult
1X1
011
000
4566 # Try hard to guess if the result is a boolean
4567 0 ▶ if($pod =~ /1 on success.+0 (on|if) /i) {
Branch: 2 branches
BranchTrueFalseTotal
if ($pod =~ /1 on success.+0 (on|if) /i) { } 0 0 0
elsif ($pod =~ /return 0 .+ 1 on success/) { } 0 0 0
4568 0 $type = 'boolean';
4569 } elsif($pod =~ /return 0 .+ 1 on success/) {
4570 0 $type = 'boolean';
4571 } else {
4572 0 $type = 'integer';
4573 }
4574 } else {
4575 0 $type = 'integer';
4576 }
4577 }
4578  
4579 43 ▶ $type = 'arrayref' if !$type && $pod =~ /returns?\s+.+\slist\b/i;
Branch: 1 branch
BranchTrueFalseTotal
if not $type and $pod =~ /returns?\s+.+\slist\b/i 0 43 43
Condition33%1/3
not $type and $pod =~ /returns?\s+.+\slist\b/i
!ll&&!rl&&r
4300
MC/DC0%0/2
not $type and $pod =~ /returns?\s+.+\slist\b/i
not $type $pod =~ /returns?\s+.+\slist\b/i
Truth table33%1/3
not(A) and B
A= not $typeB= $pod =~ /returns?\s+.+\slist\b/i
ABresult
0X0
100
111
4580 # $output->{type} = $type if $type && $type !~ /^\d+$/;
4581 43 ▶ if ($VALID_OUTPUT_TYPES{$type}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($VALID_OUTPUT_TYPES{$type}) { } 12 31 43
4582 12 $output->{type} = $type;
4583 12 $self->_log(" OUTPUT: Inferred type from POD: $type");
4584 } else {
4585 31 $self->_log(" OUTPUT: POD return type '$type' is not a valid type, ignoring");
4586 }
4587 }
4588 }
4589 }
4590  
4591 # --------------------------------------------------
4592 # _extract_defaults_from_pod
4593 #
4594 # Purpose: Extract default values for parameters
4595 # from POD documentation using multiple
4596 # pattern strategies.
4597 #
4598 # Entry: $pod - POD string for the method.
4599 # May be undef or empty.
4600 #
4601 # Exit: Returns a hashref of parameter name
4602 # to cleaned default value. Returns an
4603 # empty hashref if no POD is provided
4604 # or no defaults are found.
4605 #
4606 # Side effects: None.
4607 #
4608 # Notes: Three strategies are tried: (1) lines
4609 # containing 'Default:' or 'Defaults to:',
4610 # (2) lines containing 'Optional, default',
4611 # (3) inline $name - type, default value
4612 # format. Parameter names are inferred
4613 # by scanning backwards from the default
4614 # phrase to the nearest $variable.
4615 # --------------------------------------------------
4616 522 ▶sub _extract_defaults_from_pod {
Subroutine _extract_defaults_from_pod: called CC=9 SCAR=22.2
4617 522 my ($self, $pod) = @_;
4618  
4619 522 ▶ return {} unless $pod;
Branch: 1 branch
BranchTrueFalseTotal
unless $pod 1 521 522
4620  
4621 521 my %defaults;
4622  
4623 # Pattern 1: Default: 'value' or Defaults to: 'value'
4624 521 ▶ while ($pod =~ /(?:Default(?:s? to)?|default(?:s? to)?)[:]\s*([^\n\r]+)/gi) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /(?:Default(?:s? to)?|default(?:s? to)?)[:]\s*([^\n\r]+)/gi) 38 521 559
4625 38 my $default_text = $1;
4626 38 my $match_pos = pos($pod);
4627 38 $default_text =~ s/^\s+|\s+$//g;
4628  
4629 # Look backwards in the POD to find the parameter name
4630 38 my $context = substr($pod, 0, $match_pos);
4631 38 my @param_matches = ($context =~ /\$(\w+)/g);
4632 38 ▶ my $param = $param_matches[-1] if @param_matches; # Last parameter before default
Branch: 1 branch
BranchTrueFalseTotal
if @param_matches 38 0 38
4633  
4634 38 ▶ if ($param) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param) 38 0 38
4635 # Always clean the default value - let _clean_default_value handle everything
4636 38 ▶ if ($default_text =~ /(\w+)\s*=\s*(.+)$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($default_text =~ /(\w+)\s*=\s*(.+)$/) { } 0 38 38
4637 # Has explicit param = value format in the default text
4638 0 my ($p, $value) = ($1, $2);
4639 0 $defaults{$p} = $self->_clean_default_value($value);
4640 } else {
4641 # Just a value, associate with the found param
4642 38 $defaults{$param} = $self->_clean_default_value($default_text, 0); # NOT from code
4643 }
4644 }
4645 }
4646  
4647 # Pattern 2: Optional, default 'value'
4648 521 ▶ while ($pod =~ /Optional(?:,)?\s+(?:default|value)\s*[:=]?\s*([^\n\r,;]+)/gi) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /Optional(?:,)?\s+(?:default|value)\s*[:=]?\s*([^\n\r,;]+)/gi) 29 521 550
4649 29 my $default_text = $1;
4650 29 my $match_pos = pos($pod);
4651 29 $default_text =~ s/^\s+|\s+$//g;
4652  
4653 # Look backwards for parameter name
4654 29 my $context = substr($pod, 0, $match_pos);
4655 29 my @param_matches = ($context =~ /\$(\w+)/g);
4656 29 ▶ if (@param_matches) {
Branch: 1 branch
BranchTrueFalseTotal
if (@param_matches) 29 0 29
4657 29 my $param = $param_matches[-1]; # Last parameter before the default
4658 29 $defaults{$param} = $self->_clean_default_value($default_text, 0);
4659 }
4660 }
4661  
4662 # Pattern 3: In parameter descriptions: $param - type, default 'value'
4663 521 ▶ while ($pod =~ /\$(\w+)\s*-\s*\w+(?:\([^)]*\))?[,\s]+default\s+['"]?([^'",\n]+)['"]?/gi) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /\$(\w+)\s*-\s*\w+(?:\([^)]*\))?[,\s]+default\s+['"]?([^'",\n]+)['"]?/gi) 1 521 522
4664 1 my ($param, $value) = ($1, $2);
4665 1 $defaults{$param} = $self->_clean_default_value($value, 0);
4666 }
4667  
4668 521 return \%defaults;
4669 }
4670  
4671 # --------------------------------------------------
4672 # _analyze_output_from_code
4673 #
4674 # Purpose: Analyse return statements in a method
4675 # body to infer the output type by
4676 # counting and classifying each return
4677 # expression.
4678 #
4679 # Entry: $output - hashref to populate
4680 # (modified in place).
4681 # $code - method body source string.
4682 # $method_name - method name string.
4683 #
4684 # Exit: Returns nothing. Modifies $output
4685 # in place.
4686 #
4687 # Side effects: Logs detections to stdout when
4688 # verbose is set.
4689 # --------------------------------------------------
4690 sub _analyze_output_from_code
4691 764 ▶{
Subroutine _analyze_output_from_code: called CC=73 SCAR=48.7
4692 764 my ($self, $output, $code, $method_name) = @_;
4693  
4694 764 ▶ if ($code) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code) 764 0 764
4695 # Early boolean detection - check for consistent 1/0 returns
4696 764 my @all_returns = $code =~ /return\s+([^;]+);/g;
4697 764 ▶ if (@all_returns) {
Branch: 1 branch
BranchTrueFalseTotal
if (@all_returns) 666 98 764
4698 666 my $boolean_count = 0;
4699 666 my $total_count = scalar(@all_returns);
4700  
4701 666 foreach my $ret (@all_returns) {
4702 936 $ret =~ s/^\s+|\s+$//g;
4703 # Match 0 or 1, even with conditions
4704 936 ▶ $boolean_count++ if ($ret =~ /^(?:0|1)(?:\s|$)/);
Branch: 1 branch
BranchTrueFalseTotal
if $ret =~ /^(?:0|1)(?:\s|$)/ 112 824 936
4705 }
4706  
4707 # If most returns are 0 or 1, strongly suggest boolean
4708 666 ▶ if ($boolean_count >= 2 && $boolean_count >= $total_count * 0.8) {
Branch: 1 branch
BranchTrueFalseTotal
if ($boolean_count >= 2 and $boolean_count >= $total_count * "0.8") 14 652 666
Condition100%3/3
$boolean_count >= 2 and $boolean_count >= $total_count * "0.8"
!ll&&!rl&&r
6381414
MC/DC100%2/2
$boolean_count >= 2 and $boolean_count >= $total_count * "0.8"
$boolean_count >= 2 $boolean_count >= $total_count * "0.8"
Truth table100%3/3
A and B
A= $boolean_count >= 2B= $boolean_count >= $total_count * "0.8"
ABresult
0X0
100
111
4709 14 ▶ unless ($output->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($output->{"type"}) 4 10 14
4710 4 $output->{type} = 'boolean';
4711 4 $self->_log(" OUTPUT: Early detection - $boolean_count/$total_count returns are 0/1, setting boolean");
4712 }
4713 }
4714 }
4715  
4716 764 my @return_statements;
4717  
4718 764 ▶ if ($code =~ /return\s+bless\s*\{[^}]*\}\s*,\s*['"]?(\w+)['"]?/s) {
Branch: 6 branches
BranchTrueFalseTotal
if ($code =~ /return\s+bless\s*\{[^}]*\}\s*,\s*['"]?(\w+)['"]?/s) { } 14 750 764
elsif ($code =~ /return\s+bless/s) { } 62 688 750
elsif ($code =~ /return\s*\(\s*[^)]+\s*,\s*[^)]+\s*\)\s*;/) { } 1 687 688
elsif ($code =~ /return\s+bless[^,]+,\s*__PACKAGE__/) { } 0 687 687
elsif ($code =~ /return\s*\(([^)]+)\)/) { } 11 676 687
elsif ($code =~ /return\s+\$self\s*;/ and $code =~ /\$self\s*->\s*\{[^}]+\}\s*=/) { } 11 1328 1339
4719 # Detect blessed refs
4720 14 $output->{type} = 'object';
4721 14 ▶ if($method_name eq 'new') {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name eq 'new') { } 13 1 14
4722 # If we found the new() method, the object we're returning should be a sensible one
4723 13 ▶ if($self->{_document} && (my $package_stmt = $self->{_document}->find_first('PPI::Statement::Package'))) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_document"} and my $package_stmt = $self->{"_document"}->find_first("PPI::Statement::Package")) 13 0 13
Condition33%1/3
$self->{"_document"} and my $package_stmt = $self->{"_document"}->find_first("PPI::Statement::Package")
!ll&&!rl&&r
0013
MC/DC0%0/2
$self->{"_document"} and my $package_stmt = $self->{"_document"}->find_first("PPI::Statement::Package")
$self->{"_document"} my $package_stmt = $self->{"_document"}->find_first("PPI::Statement::Package")
Truth table33%1/3
A and B
A= $self->{"_document"}B= my $package_stmt = $self->{"_document"}->find_first("PPI::Statement::Package")
ABresult
0X0
100
111
4724 13 $output->{isa} = $package_stmt->namespace();
4725 13 ▶ $self->{_package_name} //= $output->{isa};
Condition33%1/3
$self->{"_package_name"} //= $output->{"isa"}
l!l&&r!l&&!r
1300
MC/DC0%0/2
$self->{"_package_name"} //= $output->{"isa"}
$self->{"_package_name"} $output->{"isa"}
Truth table33%1/3
A //= B
A= $self->{"_package_name"}B= $output->{"isa"}
ABresult
1X1
011
000
4726 }
4727 } else {
4728 1 $output->{isa} = $1;
4729 }
4730 14 $self->_log(" OUTPUT: Bless found, inferring type from code is $output->{isa}");
4731 } elsif ($code =~ /return\s+bless/s) {
4732 62 $output->{type} = 'object';
4733 62 ▶ if($method_name eq 'new') {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name eq 'new') { } 59 3 62
4734 59 $output->{isa} = $self->_extract_package_name();
4735 59 $self->_log(" OUTPUT: Bless found, inferring type from code is $output->{isa}");
4736 } else {
4737 3 $self->_log(' OUTPUT: Bless found, inferring type from code is object');
4738 }
4739 } elsif ($code =~ /return\s*\(\s*[^)]+\s*,\s*[^)]+\s*\)\s*;/) {
4740 # Detect array context returns - must end with semicolon to be actual return
4741 1 $output->{type} = 'array'; # Not arrayref - actual array
4742 1 $self->_log(' OUTPUT: Found array contect return');
4743 } elsif ($code =~ /return\s+bless[^,]+,\s*__PACKAGE__/) {
4744 # Detect: bless {}, __PACKAGE__
4745 0 $output->{type} = 'object';
4746 # Get package name from the extractor's stored document
4747 0 ▶ if ($self->{_document}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_document"}) 0 0 0
4748 0 my $pkg = $self->{_document}->find_first('PPI::Statement::Package');
4749 0 ▶ $output->{isa} = $pkg ? $pkg->namespace : 'UNKNOWN';
Branch: 1 branch
BranchTrueFalseTotal
$pkg ? : 0 0 0
4750 0 ▶ $self->_log(' OUTPUT: Object blessed into __PACKAGE__: ' . ($output->{isa} || 'UNKNOWN'));
Condition0%0/2
$output->{'isa'} || 'UNKNOWN'
l!l
00
MC/DC0%0/1
$output->{'isa'} || 'UNKNOWN'
$output->{'isa'}
Truth table0%0/2
A
A= $output->{'isa'}
Aresult
11
00
4751 0 ▶ $self->{_package_name} //= $output->{isa};
Condition0%0/3
$self->{"_package_name"} //= $output->{"isa"}
l!l&&r!l&&!r
000
MC/DC0%0/2
$self->{"_package_name"} //= $output->{"isa"}
$self->{"_package_name"} $output->{"isa"}
Truth table0%0/3
A //= B
A= $self->{"_package_name"}B= $output->{"isa"}
ABresult
1X1
011
000
4752 }
4753 } elsif ($code =~ /return\s*\(([^)]+)\)/) {
4754 11 my $content = $1;
4755 11 ▶ if ($content =~ /,/) { # Has comma = multiple values
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /,/) 6 5 11
4756 6 $output->{type} = 'array';
4757 }
4758 ▶ } elsif ($code =~ /return\s+\$self\s*;/ && $code =~ /\$self\s*->\s*\{[^}]+\}\s*=/) {
Condition100%3/3
$code =~ /return\s+\$self\s*;/ and $code =~ /\$self\s*->\s*\{[^}]+\}\s*=/
!ll&&!rl&&r
663211
MC/DC100%2/2
$code =~ /return\s+\$self\s*;/ and $code =~ /\$self\s*->\s*\{[^}]+\}\s*=/
$code =~ /return\s+\$self\s*;/ $code =~ /\$self\s*->\s*\{[^}]+\}\s*=/
Truth table100%3/3
A and B
A= $code =~ /return\s+\$self\s*;/B= $code =~ /\$self\s*->\s*\{[^}]+\}\s*=/
ABresult
0X0
100
111
4759 # Returns $self for chaining
4760 11 $output->{type} = 'object';
4761 11 ▶ if ($self->{_document}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_document"}) 11 0 11
4762 11 my $pkg = $self->{_document}->find_first('PPI::Statement::Package');
4763 11 ▶ $output->{isa} = $pkg ? $pkg->namespace : 'UNKNOWN';
Branch: 1 branch
BranchTrueFalseTotal
$pkg ? : 11 0 11
4764 11 ▶ $self->_log(' OUTPUT: Object chained into __PACKAGE__: ' . ($output->{isa} || 'UNKNOWN'));
Condition50%1/2
$output->{'isa'} || 'UNKNOWN'
l!l
110
MC/DC0%0/1
$output->{'isa'} || 'UNKNOWN'
$output->{'isa'}
Truth table50%1/2
A
A= $output->{'isa'}
Aresult
11
00
4765 11 ▶ $self->{_package_name} //= $output->{isa};
Condition33%1/3
$self->{"_package_name"} //= $output->{"isa"}
l!l&&r!l&&!r
1100
MC/DC0%0/2
$self->{"_package_name"} //= $output->{"isa"}
$self->{"_package_name"} $output->{"isa"}
Truth table33%1/3
A //= B
A= $self->{"_package_name"}B= $output->{"isa"}
ABresult
1X1
011
000
4766 }
4767 }
4768  
4769 # Find all return statements
4770 764 ▶ while ($code =~ /return\s+([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s+([^;]+);/g) 936 764 1700
4771 936 my $return_expr = $1;
4772 936 push @return_statements, $return_expr;
4773 }
4774  
4775 764 ▶ if (@return_statements) {
Branch: 1 branch
BranchTrueFalseTotal
if (@return_statements) { } 666 98 764
4776 666 $self->_log(' OUTPUT: Found ' . scalar(@return_statements) . ' return statement(s)');
4777  
4778 # Analyze return patterns
4779 666 my %return_types;
4780  
4781 666 ▶ if($output->{'type'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"type"}) 353 313 666
4782 353 $return_types{$output->{'type'}} += 3; # Add weighting to what's already been found
4783 }
4784 666 my $min;
4785 666 foreach my $ret (@return_statements) {
4786 936 $ret =~ s/^\s+|\s+$//g;
4787  
4788 # Literal values
4789 936 ▶ if ($ret eq '1' || $ret eq '0') {
Branch: 16 branches
BranchTrueFalseTotal
if ($ret eq '1' or $ret eq '0') { } 69 867 936
elsif ($ret =~ /^['"]/) { } 54 813 867
elsif ($ret =~ /^-?\d+$/) { } 105 708 813
elsif ($ret =~ /^-?\d+\.\d+$/) { } 0 708 708
elsif ($ret eq 'undef') { } 1 707 708
elsif ($ret =~ /^\[/) { } 15 692 707
elsif ($ret =~ /^\{/) { } 20 672 692
elsif ($ret =~ m[ # Numeric expressions (heuristic, medium confidence) # Don't match -> (?: \+ | -\b | \* | / | % | \+\+ | -- ) ]x) { } 171 501 672
elsif ($ret =~ /\|\|\s*\d+\b/) { } 1 500 501
elsif ($ret =~ /^length[\s\(]/) { } 1 499 500
elsif ($ret =~ /^pos[\s\(]/) { } 0 499 499
elsif ($ret =~ /^index[\s\(]/) { } 0 499 499
elsif ($ret =~ /^rindex[\s\(]/) { } 0 499 499
elsif ($ret =~ /^ord[\s\(]/) { } 0 499 499
elsif ($ret =~ /=/ and $ret =~ /\$\w+/) { } 81 418 499
elsif ($ret =~ /\$\w+/) { } 354 64 418
Condition100%3/3
$ret eq 1 or $ret eq 0
l!l&&r!l&&!r
4425867
MC/DC100%2/2
$ret eq 1 or $ret eq 0
$ret eq 1 $ret eq 0
Truth table100%3/3
A or B
A= $ret eq 1B= $ret eq 0
ABresult
1X1
011
000
4790 69 $return_types{boolean}++;
4791 } elsif ($ret =~ /^['"]/) {
4792 54 $return_types{string}++;
4793 } elsif ($ret =~ /^-?\d+$/) {
4794 105 $return_types{integer}++;
4795 } elsif ($ret =~ /^-?\d+\.\d+$/) {
4796 0 $return_types{number}++;
4797 } elsif ($ret eq 'undef') {
4798 1 $return_types{undef}++;
4799 } elsif ($ret =~ /^\[/) {
4800 # Data structures
4801 15 $return_types{arrayref}++;
4802 } elsif ($ret =~ /^\{/) {
4803 20 $return_types{hashref}++;
4804 } elsif ($ret =~ m{
4805 # Numeric expressions (heuristic, medium confidence)
4806 # Don't match ->
4807 (?:
4808 \+ | -\b | \* | / | %
4809 | \+\+ | --
4810 )
4811 }x) {
4812 171 $return_types{number} += 2;
4813 } elsif ($ret =~ /\|\|\s*\d+\b/) {
4814 # Logical-or fallback with numeric literal (e.g. $x || 200)
4815 1 $return_types{integer} += 2;
4816 1 $self->_log(" OUTPUT: Numeric fallback expression detected");
4817 } elsif($ret =~ /^length[\s\(]/) {
4818 1 $return_types{integer}++;
4819 1 $min = 0;
4820 } elsif($ret =~ /^pos[\s\(]/) {
4821 0 $return_types{integer}++;
4822 0 $min = 0;
4823 } elsif($ret =~ /^index[\s\(]/) {
4824 0 $return_types{integer}++;
4825 0 $min = -1;
4826 } elsif($ret =~ /^rindex[\s\(]/) {
4827 0 $return_types{integer}++;
4828 0 $min = -1;
4829 } elsif($ret =~ /^ord[\s\(]/) {
4830 0 $return_types{integer}++;
4831 ▶ } elsif ($ret =~ /=/ && $ret =~ /\$\w+/) {
Condition100%3/3
$ret =~ /=/ and $ret =~ /\$\w+/
!ll&&!rl&&r
417181
MC/DC100%2/2
$ret =~ /=/ and $ret =~ /\$\w+/
$ret =~ /=/ $ret =~ /\$\w+/
Truth table100%3/3
A and B
A= $ret =~ /=/B= $ret =~ /\$\w+/
ABresult
0X0
100
111
4832 # Assignment returning a value (e.g. $self->{status} = $status)
4833 # If assignment involves a numeric literal or variable, assume numeric intent.
4834 # $1, $2 and friends are regex captures - strings, not numeric
4835 # literals - so drop them before looking for digits. CGI::Info::script_dir
4836 # returns "$self->{script_path} =~ $dir_regex ? $1 : ..." and the
4837 # "1" in $1 was being read as a numeric literal.
4838 81 (my $numeric_ret = $ret) =~ s/\$\d+//g;
4839 81 ▶ if ($numeric_ret =~ /\b\d+\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($numeric_ret =~ /\b\d+\b/) { } 19 62 81
4840 19 $return_types{integer} += 2;
4841 19 $self->_log(" OUTPUT: Assignment with numeric value detected");
4842 } else {
4843 62 $return_types{scalar}++;
4844 }
4845 }
4846 # Variables/expressions
4847 elsif ($ret =~ /\$\w+/) {
4848 # \@_ is this routine's own argument list being passed
4849 # along, not an arrayref being returned. CGI::Info::get_cookie
4850 # returns $self->cookie(\@_) and was typed as returning an
4851 # arrayref because of it.
4852 354 (my $ref_ret = $ret) =~ s/\\\@_\b//g;
4853 354 ▶ if ($ref_ret =~ /\\\@/) {
Branch: 5 branches
BranchTrueFalseTotal
if ($ref_ret =~ /\\\@/) { } 0 354 354
elsif ($ref_ret =~ /\\\%/) { } 0 354 354
elsif ($ret =~ /bless/) { } 22 332 354
elsif ($ret =~ /^\{[^}]*\}$/) { } 0 332 332
elsif ($ret =~ /^\[[^\]]*\]$/) { } 0 332 332
4854 0 $return_types{arrayref}++;
4855 } elsif ($ref_ret =~ /\\\%/) {
4856 0 $return_types{hashref}++;
4857 } elsif ($ret =~ /bless/) {
4858 22 $return_types{object} += 2; # Heigher weight
4859 } elsif ($ret =~ /^\{[^}]*\}$/) {
4860 0 $return_types{hashref}++;
4861 } elsif ($ret =~ /^\[[^\]]*\]$/) {
4862 0 $return_types{arrayref}++;
4863 } else {
4864 332 $return_types{scalar}++;
4865 }
4866 }
4867 }
4868  
4869 # Determine most common return type
4870 666 ▶ if (keys %return_types) {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %return_types) 653 13 666
4871 653 my ($most_common) = sort { $return_types{$b} <=> $return_types{$a} } keys %return_types;
4872 # Prefer integer over scalar if numeric returns dominate
4873 653 ▶ if ($return_types{integer} && (!$return_types{string})) {
Branch: 1 branch
BranchTrueFalseTotal
if ($return_types{"integer"} and not $return_types{"string"}) 120 533 653
Condition66%2/3
$return_types{"integer"} and not $return_types{"string"}
!ll&&!rl&&r
5330120
MC/DC50%1/2
$return_types{"integer"} and not $return_types{"string"}
$return_types{"integer"} not $return_types{"string"}
Truth table66%2/3
A and not(B)
A= $return_types{"integer"}B= not $return_types{"string"}
ABresult
0X0
100
111
4874 120 ▶ if (!$output->{type} || $output->{type} eq 'scalar') {
Branch: 1 branch
BranchTrueFalseTotal
if (not $output->{"type"} or $output->{"type"} eq "scalar") 104 16 120
Condition66%2/3
not $output->{"type"} or $output->{"type"} eq "scalar"
l!l&&r!l&&!r
104016
MC/DC50%1/2
not $output->{"type"} or $output->{"type"} eq "scalar"
not $output->{"type"} $output->{"type"} eq "scalar"
Truth table66%2/3
not(A) or B
A= not $output->{"type"}B= $output->{"type"} eq "scalar"
ABresult
1X1
011
000
4875 104 $output->{type} = 'integer';
4876 104 $self->_log(" OUTPUT: Numeric returns dominate, forcing integer");
4877 104 ▶ $output->{_type_confidence} ||= 'low';
Condition50%1/2
$output->{"_type_confidence"} ||= "low"
l!l
0104
MC/DC0%0/1
$output->{"_type_confidence"} ||= "low"
$output->{"_type_confidence"}
Truth table50%1/2
A
A= $output->{"_type_confidence"}
Aresult
11
00
4878 104 ▶ if(defined($min)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $min) 1 103 104
4879 1 $output->{min} = $min;
4880 }
4881 }
4882 }
4883 653 ▶ unless ($output->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($output->{"type"}) 196 457 653
4884 196 $output->{type} = $most_common;
4885  
4886 # Assign confidence for inferred numeric expressions
4887 196 ▶ if ($most_common eq 'number') {
Branch: 1 branch
BranchTrueFalseTotal
if ($most_common eq "number") 33 163 196
4888 33 ▶ $output->{_type_confidence} ||= 'medium';
Condition50%1/2
$output->{"_type_confidence"} ||= "medium"
l!l
033
MC/DC0%0/1
$output->{"_type_confidence"} ||= "medium"
$output->{"_type_confidence"}
Truth table50%1/2
A
A= $output->{"_type_confidence"}
Aresult
11
00
4889 33 ▶ if(defined($min)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $min) 0 33 33
4890 0 $output->{min} = $min;
4891 }
4892 }
4893  
4894 196 $self->_log(" OUTPUT: Inferred type from code: $most_common");
4895 }
4896 }
4897  
4898 # Check for consistent single value returns
4899 666 ▶ if (@return_statements == 1 && $return_statements[0] eq '1') {
Branch: 1 branch
BranchTrueFalseTotal
if (@return_statements == 1 and $return_statements[0] eq 1) 31 635 666
Condition100%3/3
@return_statements == 1 and $return_statements[0] eq 1
!ll&&!rl&&r
10652931
MC/DC100%2/2
@return_statements == 1 and $return_statements[0] eq 1
@return_statements == 1 $return_statements[0] eq 1
Truth table100%3/3
A and B
A= @return_statements == 1B= $return_statements[0] eq 1
ABresult
0X0
100
111
4900 31 $output->{value} = 1;
4901 31 ▶ $output->{type} = 'boolean' if !$output->{type} || $output->{type} eq 'scalar';
Branch: 1 branch
BranchTrueFalseTotal
if not $output->{"type"} or $output->{"type"} eq "scalar" 0 31 31
Condition33%1/3
not $output->{"type"} or $output->{"type"} eq "scalar"
l!l&&r!l&&!r
0031
MC/DC0%0/2
not $output->{"type"} or $output->{"type"} eq "scalar"
not $output->{"type"} $output->{"type"} eq "scalar"
Truth table33%1/3
not(A) or B
A= not $output->{"type"}B= $output->{"type"} eq "scalar"
ABresult
1X1
011
000
4902 31 ▶ $self->_log(" OUTPUT: Type already set to '$output->{type}', overriding with boolean") if($output->{'type'});
Branch: 1 branch
BranchTrueFalseTotal
if $output->{"type"} 31 0 31
4903 }
4904 } else {
4905 # No explicit return - might return nothing or implicit undef
4906 98 $self->_log(" OUTPUT: No explicit return statement found");
4907 }
4908 }
4909 }
4910  
4911 # --------------------------------------------------
4912 # _enhance_boolean_detection
4913 #
4914 # Purpose: Apply additional boolean-specific
4915 # detection heuristics using a weighted
4916 # scoring system, to override weak
4917 # type assignments when there is strong
4918 # evidence of a boolean return.
4919 #
4920 # Entry: $output - output hashref
4921 # (modified in place).
4922 # $pod - POD string.
4923 # $code - method body source string.
4924 # $method_name - method name string.
4925 #
4926 # Exit: Returns nothing. Modifies $output
4927 # in place, setting type to 'boolean'
4928 # if the score reaches
4929 # $BOOLEAN_SCORE_THRESHOLD.
4930 #
4931 # Side effects: Logs scoring details to stdout when
4932 # verbose is set.
4933 #
4934 # Notes: Only fires when output type is
4935 # not yet set or is 'unknown'. Does not
4936 # override explicitly set types.
4937 # --------------------------------------------------
4938 764 ▶sub _enhance_boolean_detection {
Subroutine _enhance_boolean_detection: called CC=22 SCAR=46.4
4939 764 my ($self, $output, $pod, $code, $method_name) = @_;
4940  
4941 764 my $boolean_score = 0; # Track evidence for boolean return
4942  
4943 764 ▶ return unless !$output->{type} || $output->{type} eq 'unknown';
Branch: 1 branch
BranchTrueFalseTotal
unless not $output->{"type"} or $output->{"type"} eq "unknown" 731 33 764
Condition66%2/3
not $output->{"type"} or $output->{"type"} eq "unknown"
l!l&&r!l&&!r
330731
MC/DC50%1/2
not $output->{"type"} or $output->{"type"} eq "unknown"
not $output->{"type"} $output->{"type"} eq "unknown"
Truth table66%2/3
not(A) or B
A= not $output->{"type"}B= $output->{"type"} eq "unknown"
ABresult
1X1
011
000
4944  
4945 # Look for stronger boolean indicators
4946 33 ▶ if ($pod && !$output->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod and not $output->{"type"}) 9 24 33
Condition66%2/3
$pod and not $output->{"type"}
!ll&&!rl&&r
2409
MC/DC50%1/2
$pod and not $output->{"type"}
$pod not $output->{"type"}
Truth table66%2/3
A and not(B)
A= $podB= not $output->{"type"}
ABresult
0X0
100
111
4947 # Common boolean return patterns in POD
4948 9 ▶ if ($pod =~ /returns?\s+(?:true|false|1|0)\s+(?:on|for|upon)\s+(?:success|failure|error|valid|invalid)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /returns?\s+(?:true|false|1|0)\s+(?:on|for|upon)\s+(?:success|failure|error|valid|invalid)/i) 0 9 9
4949 0 $boolean_score += 30;
4950 0 $self->_log(' OUTPUT: Strong boolean indicator in POD (+30)');
4951 }
4952  
4953 # Check for method names that suggest boolean returns
4954 9 ▶ if ($pod =~ /(?:method|sub)\s+(\w+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /(?:method|sub)\s+(\w+)/) 0 9 9
4955 0 my $inferred_method_name = $1;
4956 0 ▶ if ($inferred_method_name =~ /^(is_|has_|can_|should_|contains_|exists_)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($inferred_method_name =~ /^(is_|has_|can_|should_|contains_|exists_)/) 0 0 0
4957 0 $boolean_score += 20;
4958 0 $self->_log(" OUTPUT: Inferred method name '$inferred_method_name' suggests boolean return (+20)");
4959 }
4960 }
4961 }
4962  
4963 # Analyze code for boolean patterns
4964 33 ▶ if ($code) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code) 33 0 33
4965 # Count boolean return idioms
4966 33 my $true_returns = () = $code =~ /return\s+1\s*;/g;
4967 33 my $false_returns = () = $code =~ /return\s+0\s*;/g;
4968  
4969 33 ▶ if ($true_returns + $false_returns >= 2) {
Branch: 2 branches
BranchTrueFalseTotal
if ($true_returns + $false_returns >= 2) { } 0 33 33
elsif ($true_returns + $false_returns == 1) { } 0 33 33
4970 0 $boolean_score += 40;
4971 0 $self->_log(' OUTPUT: Multiple 1/0 returns suggest boolean (+40)');
4972 } elsif ($true_returns + $false_returns == 1) {
4973 0 $boolean_score += 10;
4974 0 $self->_log(' OUTPUT: Single 1/0 return (+10)');
4975 }
4976  
4977 # Ternary operators that return booleans
4978 33 ▶ if ($code =~ /return\s+(?:\w+\s*[!=]=\s*\w+|\w+\s*>\s*\w+|\w+\s*<\s*\w+)\s*\?\s*(?:1|0)\s*:\s*(?:1|0)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s+(?:\w+\s*[!=]=\s*\w+|\w+\s*>\s*\w+|\w+\s*<\s*\w+)\s*\?\s*(?:1|0)\s*:\s*(?:1|0)/) 0 33 33
4979 0 $boolean_score += 25;
4980 0 $self->_log(' OUTPUT: Ternary with 1/0 suggests boolean (+25)');
4981 }
4982  
4983 # Check for common boolean method patterns
4984 33 ▶ if ($code =~ /return\s+[!\$\@\%]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s+[!\$\@\%]/) 6 27 33
4985 # Returns negation or existence check
4986 6 $boolean_score += 15;
4987 6 $self->_log(' OUTPUT: Returns negation/existence check (+15)');
4988 }
4989 }
4990  
4991 # Check method name for boolean indicators
4992 33 ▶ if ($method_name) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name) 33 0 33
4993 33 ▶ if ($method_name =~ /^(?:is_|has_|can_|should_|contains_|exists_|check_|verify_|validate_)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name =~ /^(?:is_|has_|can_|should_|contains_|exists_|check_|verify_|validate_)/) 0 33 33
4994 0 $boolean_score += 25;
4995 0 $self->_log(" OUTPUT: Method name '$method_name' suggests boolean return (+25)");
4996 }
4997 33 ▶ if ($method_name =~ /_ok$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name =~ /_ok$/) 0 33 33
4998 0 $boolean_score += 30;
4999 0 $self->_log(" OUTPUT: Method name '$method_name' ends with '_ok' (+30)");
5000 }
5001 }
5002  
5003 # Apply boolean type if we have strong evidence
5004 # Override weak type assignments (like 'array' from false positive)
5005 33 ▶ if($boolean_score >= $BOOLEAN_SCORE_THRESHOLD) {
Branch: 1 branch
BranchTrueFalseTotal
if ($boolean_score >= $BOOLEAN_SCORE_THRESHOLD) 0 33 33
5006 0 ▶ if (!$output->{type} || $output->{type} eq 'scalar' || $output->{type} eq 'array' || $output->{type} eq 'undef') {
Branch: 1 branch
BranchTrueFalseTotal
if (not $output->{"type"} or $output->{"type"} eq "scalar" or $output->{"type"} eq "array" or $output->{"type"} eq "undef") 0 0 0
Condition0%0/9
not $output->{"type"} or $output->{"type"} eq "scalar" or $output->{"type"} eq "array" or $output->{"type"} eq "undef"
l!l&&r!l&&!r
000
not $output->{"type"} or $output->{"type"} eq "scalar" or $output->{"type"} eq "array"
l!l&&r!l&&!r
000
not $output->{"type"} or $output->{"type"} eq "scalar"
l!l&&r!l&&!r
000
MC/DC0%0/4
not $output->{"type"} or $output->{"type"} eq "scalar" or $output->{"type"} eq "array" or $output->{"type"} eq "undef"
not $output->{"type"} $output->{"type"} eq "scalar" $output->{"type"} eq "array" $output->{"type"} eq "undef"
Truth table0%0/5
not(A) or B or C or D
A= not $output->{"type"}B= $output->{"type"} eq "scalar"C= $output->{"type"} eq "array"D= $output->{"type"} eq "undef"
ABCDresult
1XXX1
01XX1
001X1
00011
00000
5007 0 ▶ my $old_type = $output->{type} || 'none';
Condition0%0/2
$output->{'type'} || 'none'
l!l
00
MC/DC0%0/1
$output->{'type'} || 'none'
$output->{'type'}
Truth table0%0/2
A
A= $output->{'type'}
Aresult
11
00
5008 0 $output->{type} = 'boolean';
5009 0 $self->_log(" OUTPUT: Boolean score $boolean_score >= $BOOLEAN_SCORE_THRESHOLD, setting type to boolean (was: $old_type)");
5010 }
5011 }
5012 }
5013  
5014 # --------------------------------------------------
5015 # _detect_list_context
5016 #
5017 # Purpose: Detect methods that return different
5018 # values depending on calling context
5019 # via wantarray, and methods that
5020 # return explicit lists.
5021 #
5022 # Entry: $output - output hashref (modified
5023 # in place).
5024 # $code - method body source string.
5025 #
5026 # Exit: Returns nothing. Modifies $output
5027 # in place, setting _context_aware,
5028 # _list_context, _scalar_context,
5029 # _list_return, and/or type keys.
5030 #
5031 # Side effects: Logs detections to stdout when
5032 # verbose is set.
5033 # --------------------------------------------------
5034 764 ▶sub _detect_list_context {
Subroutine _detect_list_context: called CC=16 SCAR=27.9
5035 764 my ($self, $output, $code) = @_;
5036 764 ▶ return unless $code;
Branch: 1 branch
BranchTrueFalseTotal
unless $code 0 764 764
5037  
5038 # Check for wantarray usage
5039 764 ▶ if ($code =~ /wantarray/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /wantarray/) 7 757 764
5040 7 $output->{_context_aware} = 1;
5041 7 $self->_log(' OUTPUT: Method uses wantarray - context sensitive');
5042  
5043 # Debug: show what we're matching against
5044 7 ▶ if ($code =~ /(wantarray[^;]+;)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(wantarray[^;]+;)/s) 6 1 7
5045 6 $self->_log(" DEBUG wantarray line: $1");
5046 }
5047  
5048 7 ▶ if ($code =~ /wantarray\s*\?\s*\(([^)]+)\)\s*:\s*([^;]+)/s) {
Branch: 3 branches
BranchTrueFalseTotal
if ($code =~ /wantarray\s*\?\s*\(([^)]+)\)\s*:\s*([^;]+)/s) { } 1 6 7
elsif ($code =~ /wantarray\s*\?\s*([^:]+?)\s*:\s*([^;]+)/s) { } 5 1 6
elsif ($code =~ /return[^;]*unless\s+wantarray.*?return\s*\(([^)]+)\)/s) { } 1 0 1
5049 # Pattern 1: wantarray ? (list, items) : scalar_value (with parens)
5050 1 my ($list_return, $scalar_return) = ($1, $2);
5051 1 $self->_log(" DEBUG list (with parens): [$list_return], scalar: [$scalar_return]");
5052  
5053 1 $output->{_list_context} = $self->_infer_type_from_expression($list_return);
5054 1 $output->{_scalar_context} = $self->_infer_type_from_expression($scalar_return);
5055 1 $self->_log(' OUTPUT: Detected context-dependent returns (parenthesized)');
5056 } elsif ($code =~ /wantarray\s*\?\s*([^:]+?)\s*:\s*([^;]+)/s) {
5057 # Pattern 2: wantarray ? @array : scalar (no parens around list)
5058 5 my ($list_return, $scalar_return) = ($1, $2);
5059 # Clean up
5060 5 $list_return =~ s/^\s+|\s+$//g;
5061 5 $scalar_return =~ s/^\s+|\s+$//g;
5062  
5063 5 $self->_log(" DEBUG list (no parens): [$list_return], scalar: [$scalar_return]");
5064  
5065 5 $output->{_list_context} = $self->_infer_type_from_expression($list_return);
5066 5 $output->{_scalar_context} = $self->_infer_type_from_expression($scalar_return);
5067 5 $self->_log(' OUTPUT: Detected context-dependent returns (non-parenthesized)');
5068 } elsif ($code =~ /return[^;]*unless\s+wantarray.*?return\s*\(([^)]+)\)/s) {
5069 # Pattern 3: return unless wantarray; return (list);
5070 1 $output->{_list_context} = { type => 'array' };
5071 1 $self->_log(' OUTPUT: Detected list context return after wantarray check');
5072 }
5073 }
5074  
5075 # Detect explicit list returns (multiple values in parentheses)
5076 # Avoid false positives from function calls
5077 764 ▶ if ($code =~ /return\s*\(\s*([^)]+)\s*\)\s*;/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s*\(\s*([^)]+)\s*\)\s*;/) 2 762 764
5078 2 my $content = $1;
5079  
5080 # Count commas outside of nested structures, jumping over each
5081 # balanced bracketed block in one step via extract_bracketed
5082 2 require Text::Balanced;
5083 2 my $comma_count = 0;
5084 2 my $rest = $content;
5085 2 ▶ while (length $rest) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $rest) 29 2 31
5086 29 ▶ if (substr($rest, 0, 1) =~ /[(\[{]/) {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($rest, 0, 1) =~ /[(\[{]/) 4 25 29
5087 4 my $extracted = Text::Balanced::extract_bracketed($rest, '(){}[]');
5088 4 ▶ last unless defined $extracted; # Unbalanced brackets
Branch: 1 branch
BranchTrueFalseTotal
unless defined $extracted 0 4 4
5089 4 next;
5090 }
5091 25 ▶ $comma_count++ if substr($rest, 0, 1) eq ',';
Branch: 1 branch
BranchTrueFalseTotal
if substr($rest, 0, 1) eq "," 2 23 25
5092 25 $rest = substr($rest, 1);
5093 }
5094  
5095 2 ▶ if ($comma_count > 0 && $content !~ /\b(?:bless|new)\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($comma_count > 0 and not $content =~ /\b(?:bless|new)\b/) 1 1 2
Condition66%2/3
$comma_count > 0 and not $content =~ /\b(?:bless|new)\b/
!ll&&!rl&&r
101
MC/DC50%1/2
$comma_count > 0 and not $content =~ /\b(?:bless|new)\b/
$comma_count > 0 not $content =~ /\b(?:bless|new)\b/
Truth table66%2/3
A and not(B)
A= $comma_count > 0B= not $content =~ /\b(?:bless|new)\b/
ABresult
0X0
100
111
5096 # Multiple values returned
5097 1 ▶ unless ($output->{type} && $output->{type} eq 'boolean') {
Branch: 1 branch
BranchTrueFalseTotal
unless ($output->{"type"} and $output->{"type"} eq "boolean") 1 0 1
Condition33%1/3
$output->{"type"} and $output->{"type"} eq "boolean"
!ll&&!rl&&r
010
MC/DC0%0/2
$output->{"type"} and $output->{"type"} eq "boolean"
$output->{"type"} $output->{"type"} eq "boolean"
Truth table33%1/3
A and B
A= $output->{"type"}B= $output->{"type"} eq "boolean"
ABresult
0X0
100
111
5098 1 $output->{type} = 'array';
5099 1 $output->{_list_return} = $comma_count + 1;
5100 1 $self->_log(' OUTPUT: Returns list of ' . ($comma_count + 1) . ' values');
5101 }
5102 }
5103 }
5104 }
5105  
5106 # --------------------------------------------------
5107 # _detect_void_context
5108 #
5109 # Purpose: Detect methods that return nothing
5110 # meaningful (void context), methods
5111 # that always return 1 as a success
5112 # indicator, and methods whose name
5113 # suggests void context (setters,
5114 # mutators, loggers).
5115 #
5116 # Entry: $output - output hashref
5117 # (modified in place).
5118 # $code - method body source string.
5119 # $method_name - method name string.
5120 #
5121 # Exit: Returns nothing. Modifies $output
5122 # in place, setting _void_context,
5123 # _success_indicator, and/or type.
5124 #
5125 # Side effects: Logs detections to stdout when
5126 # verbose is set.
5127 # --------------------------------------------------
5128 764 ▶sub _detect_void_context {
Subroutine _detect_void_context: called CC=17 SCAR=28.3
5129 764 my ($self, $output, $code, $method_name) = @_;
5130 764 ▶ return unless $code;
Branch: 1 branch
BranchTrueFalseTotal
unless $code 0 764 764
5131  
5132 764 $self->_log(" DEBUG _detect_void_context called for $method_name");
5133  
5134 # Methods that typically don't return meaningful values
5135 764 my $void_patterns = {
5136 'setter' => qr/^set_\w+$/,
5137 'mutator' => qr/^(?:add|remove|delete|clear|reset|update)_/,
5138 'logger' => qr/^(?:log|debug|warn|error|info)$/,
5139 'printer' => qr/^(?:print|say|dump)_/,
5140 };
5141  
5142 # Check if method name suggests void context
5143 764 foreach my $type (keys %$void_patterns) {
5144 3017 ▶ if ($method_name =~ $void_patterns->{$type}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name =~ /$void_patterns->{$type}/) 22 2995 3017
5145 22 $output->{_void_context_hint} = $type;
5146 22 $self->_log(" OUTPUT: Method name suggests $type (typically void context)");
5147 22 last;
5148 }
5149 }
5150  
5151 # Analyze return statements
5152 764 my @returns = $code =~ /return\s*([^;]*);/g;
5153  
5154 764 $self->_log(' DEBUG Found ' . scalar(@returns) . ' return statements');
5155  
5156 # Count different return patterns
5157 764 my $no_value_returns = 0;
5158 764 my $true_returns = 0;
5159 764 my $self_returns = 0;
5160  
5161 764 foreach my $ret (@returns) {
5162 1091 $ret =~ s/^\s+|\s+$//g;
5163 1091 $self->_log(" DEBUG return value: [$ret]");
5164 1091 ▶ $no_value_returns++ if $ret eq '';
Branch: 1 branch
BranchTrueFalseTotal
if $ret eq "" 13 1078 1091
5165 1091 ▶ $no_value_returns++ if($ret =~ /^(if|unless)\s/);
Branch: 1 branch
BranchTrueFalseTotal
if $ret =~ /^(if|unless)\s/ 10 1081 1091
5166 1091 ▶ $true_returns++ if $ret eq '1';
Branch: 1 branch
BranchTrueFalseTotal
if $ret eq 1 44 1047 1091
5167 1091 ▶ $self_returns++ if $ret eq '$self';
Branch: 1 branch
BranchTrueFalseTotal
if $ret eq "\$self" 13 1078 1091
5168 1091 ▶ if ($ret =~ /\?\s*1\s*:\s*0\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ret =~ /\?\s*1\s*:\s*0\b/) 25 1066 1091
5169 # Strong boolean signal: ternary returning 1/0
5170 25 $true_returns++;
5171 # $self->_log(" OUTPUT: Ternary 1:0 return detected, treating as boolean (+40)");
5172 25 $self->_log(' OUTPUT: Ternary 1:0 return detected, treating as boolean');
5173 }
5174 }
5175  
5176 764 my $total_returns = scalar(@returns);
5177  
5178 764 $self->_log(" DEBUG no_value=$no_value_returns, true=$true_returns, self=$self_returns, total=$total_returns");
5179  
5180 # Void context indicators
5181 764 ▶ if ($no_value_returns > 0 && $no_value_returns == $total_returns) {
Branch: 2 branches
BranchTrueFalseTotal
if ($no_value_returns > 0 and $no_value_returns == $total_returns) { } 10 754 764
elsif ($true_returns > 0 and $true_returns == $total_returns and $total_returns >= 1) { } 47 1414 1461
Condition100%3/3
$no_value_returns > 0 and $no_value_returns == $total_returns
!ll&&!rl&&r
7431110
MC/DC100%2/2
$no_value_returns > 0 and $no_value_returns == $total_returns
$no_value_returns > 0 $no_value_returns == $total_returns
Truth table100%3/3
A and B
A= $no_value_returns > 0B= $no_value_returns == $total_returns
ABresult
0X0
100
111
5182 10 $output->{_void_context} = 1;
5183 10 $output->{type} = 'void'; # This should override any previous type
5184 10 $self->_log(' OUTPUT: All returns are empty - void context method');
5185 ▶ } elsif ($true_returns > 0 && $true_returns == $total_returns && $total_returns >= 1) {
Condition83%5/6
$true_returns > 0 and $true_returns == $total_returns and $total_returns >= 1
!ll&&!rl&&r
707047
$true_returns > 0 and $true_returns == $total_returns
!ll&&!rl&&r
6852247
MC/DC66%2/3
$true_returns > 0 and $true_returns == $total_returns and $total_returns >= 1
$true_returns > 0 $true_returns == $total_returns $total_returns >= 1
Truth table75%3/4
A and B and C
A= $true_returns > 0B= $true_returns == $total_returnsC= $total_returns >= 1
ABCresult
0XX0
10X0
1100
1111
5186 # Methods that always return true (success indicator)
5187 47 $output->{_success_indicator} = 1;
5188 # Don't override type if already set to boolean
5189 47 ▶ unless ($output->{type} && $output->{type} eq 'boolean') {
Branch: 1 branch
BranchTrueFalseTotal
unless ($output->{"type"} and $output->{"type"} eq "boolean") 13 34 47
Condition66%2/3
$output->{"type"} and $output->{"type"} eq "boolean"
!ll&&!rl&&r
01334
MC/DC50%1/2
$output->{"type"} and $output->{"type"} eq "boolean"
$output->{"type"} $output->{"type"} eq "boolean"
Truth table66%2/3
A and B
A= $output->{"type"}B= $output->{"type"} eq "boolean"
ABresult
0X0
100
111
5190 13 $output->{type} = 'boolean';
5191 }
5192 47 $self->_log(' OUTPUT: Always returns 1 - success indicator pattern');
5193 }
5194 }
5195  
5196 # --------------------------------------------------
5197 # _detect_chaining_pattern
5198 #
5199 # Purpose: Detect methods that return $self for
5200 # fluent interface chaining, by counting
5201 # the proportion of return statements
5202 # that return $self.
5203 #
5204 # Entry: $output - output hashref (modified
5205 # in place).
5206 # $code - method body source string.
5207 #
5208 # Exit: Returns nothing. Modifies $output
5209 # in place, setting type to 'object',
5210 # _returns_self to 1, and isa to the
5211 # current package name when the
5212 # proportion of $self returns is >= 0.8.
5213 #
5214 # Side effects: Logs detection to stdout when
5215 # verbose is set.
5216 # --------------------------------------------------
5217 764 ▶sub _detect_chaining_pattern {
Subroutine _detect_chaining_pattern: called CC=10 SCAR=23.4
5218 764 my ($self, $output, $code) = @_;
5219 764 ▶ return unless $code;
Branch: 1 branch
BranchTrueFalseTotal
unless $code 0 764 764
5220  
5221 # Count returns of $self
5222 764 my $self_returns = 0;
5223 764 my $total_returns = 0;
5224  
5225 764 ▶ while ($code =~ /return\s+([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s+([^;]+);/g) 936 764 1700
5226 936 my $ret = $1;
5227 936 $ret =~ s/^\s+|\s+$//g;
5228 936 $total_returns++;
5229 936 ▶ $self_returns++ if $ret eq '$self';
Branch: 1 branch
BranchTrueFalseTotal
if $ret eq "\$self" 13 923 936
5230 }
5231  
5232 # If most/all returns are $self, it's a chaining method
5233 764 ▶ if ($self_returns > 0 && $total_returns > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self_returns > 0 and $total_returns > 0) 13 751 764
Condition66%2/3
$self_returns > 0 and $total_returns > 0
!ll&&!rl&&r
751013
MC/DC50%1/2
$self_returns > 0 and $total_returns > 0
$self_returns > 0 $total_returns > 0
Truth table66%2/3
A and B
A= $self_returns > 0B= $total_returns > 0
ABresult
0X0
100
111
5234 13 my $ratio = $self_returns / $total_returns;
5235  
5236 13 ▶ if ($ratio >= 0.8) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ratio >= "0.8") 11 2 13
5237 11 $output->{type} = 'object';
5238 11 $output->{_returns_self} = 1;
5239  
5240 # Get the class name
5241 11 ▶ if ($self->{_document}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_document"}) 11 0 11
5242 11 my $pkg = $self->{_document}->find_first('PPI::Statement::Package');
5243 11 ▶ $output->{isa} = $pkg ? $pkg->namespace : 'UNKNOWN';
Branch: 1 branch
BranchTrueFalseTotal
$pkg ? : 11 0 11
5244 11 ▶ $self->{_package_name} //= $output->{isa};
Condition33%1/3
$self->{"_package_name"} //= $output->{"isa"}
l!l&&r!l&&!r
1100
MC/DC0%0/2
$self->{"_package_name"} //= $output->{"isa"}
$self->{"_package_name"} $output->{"isa"}
Truth table33%1/3
A //= B
A= $self->{"_package_name"}B= $output->{"isa"}
ABresult
1X1
011
000
5245 }
5246  
5247 11 $self->_log(" OUTPUT: Chainable method - returns \$self ($self_returns/$total_returns returns)");
5248 }
5249 }
5250 }
5251  
5252 # --------------------------------------------------
5253 # _detect_error_conventions
5254 #
5255 # Purpose: Analyse how a method signals errors
5256 # by detecting patterns such as
5257 # 'return undef if', implicit bare
5258 # returns, empty list returns, 0/1
5259 # boolean error patterns, and eval
5260 # exception handling.
5261 #
5262 # Entry: $output - output hashref (modified
5263 # in place).
5264 # $code - method body source string.
5265 #
5266 # Exit: Returns nothing. Modifies $output
5267 # in place, setting _error_handling,
5268 # _error_return, and
5269 # _success_failure_pattern keys.
5270 #
5271 # Side effects: Logs detections to stdout when
5272 # verbose is set.
5273 # --------------------------------------------------
5274 764 ▶sub _detect_error_conventions {
Subroutine _detect_error_conventions: called CC=21 SCAR=30.5
5275 764 my ($self, $output, $code) = @_;
5276  
5277 764 ▶ return unless $code;
Branch: 1 branch
BranchTrueFalseTotal
unless $code 0 764 764
5278  
5279 764 $self->_log(' DEBUG _detect_error_conventions called');
5280  
5281 764 my %error_patterns;
5282  
5283 # Pattern 1: return undef if/unless condition
5284 764 ▶ while ($code =~ /return\s+undef\s+(?:if|unless)\s+([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s+undef\s+(?:if|unless)\s+([^;]+);/g) 4 764 768
5285 4 push @{$error_patterns{undef_on_error}}, $1;
5286 4 $self->_log(" DEBUG Found 'return undef' pattern");
5287 }
5288  
5289 # Pattern 2: return if/unless (implicit undef)
5290 764 ▶ while ($code =~ /return\s+(?:if|unless)\s+([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s+(?:if|unless)\s+([^;]+);/g) 13 764 777
5291 13 push @{$error_patterns{implicit_undef}}, $1;
5292 13 $self->_log(" DEBUG Found implicit undef pattern");
5293 }
5294  
5295 # Pattern 3: return () - matches with or without conditions
5296 764 ▶ if ($code =~ /return\s*\(\s*\)\s*(?:if|unless|;)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s*\(\s*\)\s*(?:if|unless|;)/) 3 761 764
5297 3 $error_patterns{empty_list} = 1;
5298 3 $self->_log(" DEBUG Found empty list return");
5299 }
5300  
5301 # Pattern 4: return 0/1 pattern (indicates boolean with error handling)
5302 764 my $zero_returns = 0;
5303 764 my $one_returns = 0;
5304 # Match "return 0" or "return 1" followed by anything (condition or semicolon)
5305 764 ▶ while ($code =~ /return\s+(0|1)\s*(?:;|if|unless)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /return\s+(0|1)\s*(?:;|if|unless)/g) 124 764 888
5306 124 ▶ if ($1 eq '0') {
Branch: 1 branch
BranchTrueFalseTotal
if ($1 eq '0') { } 67 57 124
5307 67 $zero_returns++;
5308 } else {
5309 57 $one_returns++;
5310 }
5311 }
5312  
5313 764 ▶ if ($zero_returns > 0 && $one_returns > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($zero_returns > 0 and $one_returns > 0) 15 749 764
Condition100%3/3
$zero_returns > 0 and $one_returns > 0
!ll&&!rl&&r
7252415
MC/DC100%2/2
$zero_returns > 0 and $one_returns > 0
$zero_returns > 0 $one_returns > 0
Truth table100%3/3
A and B
A= $zero_returns > 0B= $one_returns > 0
ABresult
0X0
100
111
5314 15 $error_patterns{zero_on_error} = 1;
5315 15 $self->_log(" DEBUG Found 0/1 return pattern ($zero_returns zeros, $one_returns ones)");
5316 }
5317  
5318 # Pattern 5: Exception handling with eval
5319 764 ▶ if ($code =~ /eval\s*\{/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /eval\s*\{/) 30 734 764
5320 # Check if there's error handling after eval
5321 30 ▶ if ($code =~ /eval\s*\{.*?\}[^}]*(?:if\s*\(\s*\$\@|catch|return\s+undef)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /eval\s*\{.*?\}[^}]*(?:if\s*\(\s*\$\@|catch|return\s+undef)/s) 20 10 30
5322 20 $error_patterns{exception_handling} = 1;
5323 20 $self->_log(' DEBUG Found exception handling with eval');
5324 }
5325 }
5326  
5327 # Detect success/failure return pattern
5328 764 my @all_returns = $code =~ /return\s+([^;]+);/g;
5329 764 my $has_undef = grep { /^\s*undef\s*(?:if|unless|$)/ } @all_returns;
5330 764 ▶ my $has_value = grep { !/^\s*undef\s*$/ && !/^\s*$/ } @all_returns;
Condition66%2/3
/^\s*undef\s*$/ || /^\s*$/
l!l&&r!l&&!r
10935
MC/DC50%1/2
/^\s*undef\s*$/ || /^\s*$/
/^\s*undef\s*$/ /^\s*$/
Truth table66%2/3
A || B
A= /^\s*undef\s*$/B= /^\s*$/
ABresult
1X1
011
000
5331  
5332 764 ▶ if ($has_undef && $has_value && scalar(@all_returns) >= 2) {
Branch: 1 branch
BranchTrueFalseTotal
if ($has_undef and $has_value and scalar @all_returns >= 2) 3 761 764
Condition66%4/6
$has_undef and $has_value and scalar @all_returns >= 2
!ll&&!rl&&r
76103
$has_undef and $has_value
!ll&&!rl&&r
76103
MC/DC33%1/3
$has_undef and $has_value and scalar @all_returns >= 2
$has_undef $has_value scalar @all_returns >= 2
Truth table50%2/4
A and B and C
A= $has_undefB= $has_valueC= scalar @all_returns >= 2
ABCresult
0XX0
10X0
1100
1111
5333 3 $output->{_success_failure_pattern} = 1;
5334 3 $self->_log(" OUTPUT: Uses success/failure return pattern");
5335 }
5336  
5337 # Store error conventions in output
5338 764 ▶ if(scalar(keys %error_patterns)) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar keys %error_patterns) { } 48 716 764
5339 48 $output->{_error_handling} = \%error_patterns;
5340  
5341 # Determine primary error convention
5342 48 ▶ if ($error_patterns{undef_on_error}) {
Branch: 4 branches
BranchTrueFalseTotal
if ($error_patterns{'undef_on_error'}) { } 2 46 48
elsif ($error_patterns{'implicit_undef'}) { } 12 34 46
elsif ($error_patterns{'empty_list'}) { } 3 31 34
elsif ($error_patterns{'zero_on_error'}) { } 15 16 31
5343 2 $output->{_error_return} = 'undef';
5344 2 $self->_log(" OUTPUT: Returns undef on error");
5345 } elsif ($error_patterns{implicit_undef}) {
5346 12 $output->{_error_return} = 'undef';
5347 12 $self->_log(" OUTPUT: Returns implicit undef on error");
5348 } elsif ($error_patterns{empty_list}) {
5349 3 $output->{_error_return} = 'empty_list';
5350 3 $self->_log(" OUTPUT: Returns empty list on error");
5351 } elsif ($error_patterns{zero_on_error}) {
5352 15 $output->{_error_return} = 'false';
5353 15 $self->_log(" OUTPUT: Returns 0/false on error");
5354 }
5355  
5356 48 ▶ if ($error_patterns{exception_handling}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($error_patterns{"exception_handling"}) 20 28 48
5357 20 $self->_log(" OUTPUT: Has exception handling");
5358 }
5359 } else {
5360 716 delete $output->{_error_handling};
5361 }
5362 }
5363  
5364 # --------------------------------------------------
5365 # _infer_type_from_expression
5366 #
5367 # Purpose: Infer the data type of a return
5368 # expression string by matching it
5369 # against common Perl literal and
5370 # variable patterns.
5371 #
5372 # Entry: $expr - return expression string,
5373 # trimmed of leading and
5374 # trailing whitespace.
5375 # May be undef.
5376 #
5377 # Exit: Returns a type hashref of the form
5378 # { type => '...' } and optionally
5379 # { min => N }. Defaults to
5380 # { type => 'scalar' } when no
5381 # pattern matches.
5382 #
5383 # Side effects: None.
5384 # --------------------------------------------------
5385 28 ▶sub _infer_type_from_expression {
Subroutine _infer_type_from_expression: called CC=25 SCAR=32.3
5386 28 my ($self, $expr) = @_;
5387  
5388 28 ▶ return { type => 'scalar' } unless defined $expr;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $expr 1 27 28
5389  
5390 27 $expr =~ s/^\s+|\s+$//g;
5391  
5392 # Check for multiple comma-separated values (indicates array/list)
5393 27 ▶ if ($expr =~ /,/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /,/) 3 24 27
5394 3 require Text::Balanced;
5395 3 my $comma_count = 0;
5396 3 my $rest = $expr;
5397 3 ▶ while (length $rest) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $rest) 35 3 38
5398 35 ▶ if (substr($rest, 0, 1) =~ /[(\[{]/) {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($rest, 0, 1) =~ /[(\[{]/) 4 31 35
5399 4 my $extracted = Text::Balanced::extract_bracketed($rest, '(){}[]');
5400 4 ▶ last unless defined $extracted; # Unbalanced brackets
Branch: 1 branch
BranchTrueFalseTotal
unless defined $extracted 0 4 4
5401 4 next;
5402 }
5403 31 ▶ $comma_count++ if substr($rest, 0, 1) eq ',';
Branch: 1 branch
BranchTrueFalseTotal
if substr($rest, 0, 1) eq "," 3 28 31
5404 31 $rest = substr($rest, 1);
5405 }
5406  
5407 3 ▶ if ($comma_count > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($comma_count > 0) 2 1 3
5408 2 return { type => 'array' };
5409 }
5410 }
5411  
5412 # Check for @ prefix (array)
5413 25 ▶ if ($expr =~ /^\@\w+/ || $expr =~ /^qw\(/ || $expr =~ /^\@\{/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^\@\w+/ or $expr =~ /^qw\(/ or $expr =~ /^\@\{/) 7 18 25
Condition100%6/6
$expr =~ /^\@\w+/ or $expr =~ /^qw\(/ or $expr =~ /^\@\{/
l!l&&r!l&&!r
4318
$expr =~ /^\@\w+/ or $expr =~ /^qw\(/
l!l&&r!l&&!r
3121
MC/DC100%3/3
$expr =~ /^\@\w+/ or $expr =~ /^qw\(/ or $expr =~ /^\@\{/
$expr =~ /^\@\w+/ $expr =~ /^qw\(/ $expr =~ /^\@\{/
Truth table100%4/4
A or B or C
A= $expr =~ /^\@\w+/B= $expr =~ /^qw\(/C= $expr =~ /^\@\{/
ABCresult
1XX1
01X1
0011
0000
5414 7 return { type => 'array' };
5415 }
5416  
5417 # Check for scalar() function - returns count
5418 18 ▶ if ($expr =~ /scalar\s*\(/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /scalar\s*\(/) 2 16 18
5419 2 return { type => 'integer', min => 0 };
5420 }
5421  
5422 # Check for array reference
5423 16 ▶ if ($expr =~ /^\[/ || $expr =~ /^\\\@/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^\[/ or $expr =~ /^\\\@/) 3 13 16
Condition100%3/3
$expr =~ /^\[/ or $expr =~ /^\\\@/
l!l&&r!l&&!r
1213
MC/DC100%2/2
$expr =~ /^\[/ or $expr =~ /^\\\@/
$expr =~ /^\[/ $expr =~ /^\\\@/
Truth table100%3/3
A or B
A= $expr =~ /^\[/B= $expr =~ /^\\\@/
ABresult
1X1
011
000
5424 3 return { type => 'arrayref' };
5425 }
5426  
5427 # Check for hash reference
5428 13 ▶ if ($expr =~ /^\{/ || $expr =~ /^\\\%/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^\{/ or $expr =~ /^\\\%/) 2 11 13
Condition100%3/3
$expr =~ /^\{/ or $expr =~ /^\\\%/
l!l&&r!l&&!r
1111
MC/DC100%2/2
$expr =~ /^\{/ or $expr =~ /^\\\%/
$expr =~ /^\{/ $expr =~ /^\\\%/
Truth table100%3/3
A or B
A= $expr =~ /^\{/B= $expr =~ /^\\\%/
ABresult
1X1
011
000
5429 2 return { type => 'hashref' };
5430 }
5431  
5432 # Check for hash
5433 11 ▶ if ($expr =~ /^\%\w+/ || $expr =~ /^\%\{/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^\%\w+/ or $expr =~ /^\%\{/) 0 11 11
Condition33%1/3
$expr =~ /^\%\w+/ or $expr =~ /^\%\{/
l!l&&r!l&&!r
0011
MC/DC0%0/2
$expr =~ /^\%\w+/ or $expr =~ /^\%\{/
$expr =~ /^\%\w+/ $expr =~ /^\%\{/
Truth table33%1/3
A or B
A= $expr =~ /^\%\w+/B= $expr =~ /^\%\{/
ABresult
1X1
011
000
5434 0 return { type => 'hash' };
5435 }
5436  
5437 # Check for strings
5438 11 ▶ if ($expr =~ /^['"]/ || $expr =~ /['"]$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^['"]/ or $expr =~ /['"]$/) 1 10 11
Condition66%2/3
$expr =~ /^['"]/ or $expr =~ /['"]$/
l!l&&r!l&&!r
1010
MC/DC50%1/2
$expr =~ /^['"]/ or $expr =~ /['"]$/
$expr =~ /^['"]/ $expr =~ /['"]$/
Truth table66%2/3
A or B
A= $expr =~ /^['"]/B= $expr =~ /['"]$/
ABresult
1X1
011
000
5439 1 return { type => 'string' };
5440 }
5441  
5442 # Check for booleans first — must come before the integer check
5443 # since /^-?\d+$/ would otherwise match 0 and 1 as integers
5444 10 ▶ if($expr =~ /^[01]$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^[01]$/) 2 8 10
5445 2 return { type => 'boolean' };
5446 }
5447  
5448 # Check for integers
5449 8 ▶ if($expr =~ /^-?\d+$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^-?\d+$/) 2 6 8
5450 2 return { type => 'integer' };
5451 }
5452  
5453 6 ▶ if ($expr =~ /^-?\d+\.\d+$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /^-?\d+\.\d+$/) 1 5 6
5454 1 return { type => 'number' };
5455 }
5456  
5457 # Check for objects
5458 5 ▶ if ($expr =~ /bless/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /bless/) 0 5 5
5459 0 return { type => 'object' };
5460 }
5461  
5462 5 ▶ if($expr =~ /\blength\s*\(/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr =~ /\blength\s*\(/) 1 4 5
5463 1 return { type => 'integer', min => 0 };
5464 }
5465  
5466 # Default to scalar
5467 4 return { type => 'scalar' };
5468 }
5469  
5470 # --------------------------------------------------
5471 # _detect_chaining_from_pod
5472 #
5473 # Purpose: Check POD documentation for explicit
5474 # indications that a method is chainable
5475 # or part of a fluent interface.
5476 #
5477 # Entry: $output - output hashref (modified
5478 # in place).
5479 # $pod - POD string for the method.
5480 #
5481 # Exit: Returns nothing. Sets _returns_self
5482 # in $output if chaining keywords are
5483 # found.
5484 #
5485 # Side effects: Logs detection to stdout when
5486 # verbose is set.
5487 # --------------------------------------------------
5488 0 ▶sub _detect_chaining_from_pod {
Subroutine _detect_chaining_from_pod: not called CC=6 SCAR=37.4
5489 0 my ($self, $output, $pod) = @_;
5490 0 ▶ return unless $pod;
Branch: 1 branch
BranchTrueFalseTotal
unless $pod 0 0 0
5491  
5492 # Look for explicit chaining documentation
5493 0 ▶ if ($pod =~ /returns?\s+(?:\$)?self\b/i ||
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /returns?\s+(?:\$)?self\b/i or $pod =~ /chainable/i or $pod =~ /fluent\s+interface/i or $pod =~ /method\s+chaining/i) 0 0 0
Condition0%0/9
$pod =~ /returns?\s+(?:\$)?self\b/i or $pod =~ /chainable/i or $pod =~ /fluent\s+interface/i or $pod =~ /method\s+chaining/i
l!l&&r!l&&!r
000
$pod =~ /returns?\s+(?:\$)?self\b/i or $pod =~ /chainable/i or $pod =~ /fluent\s+interface/i
l!l&&r!l&&!r
000
$pod =~ /returns?\s+(?:\$)?self\b/i or $pod =~ /chainable/i
l!l&&r!l&&!r
000
MC/DC0%0/4
$pod =~ /returns?\s+(?:\$)?self\b/i or $pod =~ /chainable/i or $pod =~ /fluent\s+interface/i or $pod =~ /method\s+chaining/i
$pod =~ /returns?\s+(?:\$)?self\b/i $pod =~ /chainable/i $pod =~ /fluent\s+interface/i $pod =~ /method\s+chaining/i
Truth table0%0/5
A or B or C or D
A= $pod =~ /returns?\s+(?:\$)?self\b/iB= $pod =~ /chainable/iC= $pod =~ /fluent\s+interface/iD= $pod =~ /method\s+chaining/i
ABCDresult
1XXX1
01XX1
001X1
00011
00000
5494 $pod =~ /chainable/i ||
5495 $pod =~ /fluent\s+interface/i ||
5496 $pod =~ /method\s+chaining/i) {
5497  
5498 0 $output->{_returns_self} = 1;
5499 0 $self->_log(" OUTPUT: POD indicates chainable/fluent interface");
5500 }
5501 }
5502  
5503 # --------------------------------------------------
5504 # _validate_output
5505 #
5506 # Purpose: Apply basic sanity checks to the
5507 # assembled output hashref and warn
5508 # about suspicious type combinations,
5509 # normalising clearly invalid types to
5510 # 'string'.
5511 #
5512 # Entry: $output - output hashref (modified
5513 # in place).
5514 #
5515 # Exit: Returns nothing. May modify type key
5516 # in $output. Logs warnings to stdout
5517 # when verbose is set.
5518 #
5519 # Side effects: None.
5520 # --------------------------------------------------
5521 739 ▶sub _validate_output {
Subroutine _validate_output: called CC=9 SCAR=22.2
5522 739 my ($self, $output) = @_;
5523  
5524 # Warn about suspicious combinations
5525 739 ▶ if (defined $output->{type} && $output->{type} eq 'boolean' && !defined($output->{value})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $output->{"type"} and $output->{"type"} eq "boolean" and not defined $output->{"value"}) 29 710 739
Condition100%6/6
defined $output->{"type"} and $output->{"type"} eq "boolean" and not defined $output->{"value"}
!ll&&!rl&&r
6793129
defined $output->{"type"} and $output->{"type"} eq "boolean"
!ll&&!rl&&r
567460
MC/DC100%3/3
defined $output->{"type"} and $output->{"type"} eq "boolean" and not defined $output->{"value"}
defined $output->{"type"} $output->{"type"} eq "boolean" not defined $output->{"value"}
Truth table100%4/4
A and B and not(C)
A= defined $output->{"type"}B= $output->{"type"} eq "boolean"C= not defined $output->{"value"}
ABCresult
0XX0
10X0
1100
1111
5526 29 $self->_log(' WARNING Boolean type without value - may want to set value: 1');
5527 }
5528 739 ▶ if ($output->{value} && defined $output->{type} && $output->{type} ne 'boolean') {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"value"} and defined $output->{"type"} and $output->{"type"} ne "boolean") 0 739 739
Condition66%4/6
$output->{"value"} and defined $output->{"type"} and $output->{"type"} ne "boolean"
!ll&&!rl&&r
708310
$output->{"value"} and defined $output->{"type"}
!ll&&!rl&&r
708031
MC/DC0%0/3
$output->{"value"} and defined $output->{"type"} and $output->{"type"} ne "boolean"
$output->{"value"} defined $output->{"type"} $output->{"type"} ne "boolean"
Truth table50%2/4
A and B and C
A= $output->{"value"}B= defined $output->{"type"}C= $output->{"type"} ne "boolean"
ABCresult
0XX0
10X0
1100
1111
5529 0 $self->_log(" WARNING Value set but type is not boolean: $output->{type}");
5530 }
5531 739 my %valid_types = map { $_ => 1 } qw(string integer number boolean array arrayref hashref object void);
5532 739 ▶ if(exists $output->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $output->{"type"}) 734 5 739
5533 734 ▶ if(!$valid_types{$output->{type}}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $valid_types{$output->{"type"}}) 118 616 734
5534 118 $self->_log(" WARNING Output value type is unknown: '$output->{type}', setting to string");
5535 118 $output->{type} = 'string';
5536 }
5537 }
5538 }
5539  
5540 # --------------------------------------------------
5541 # _prose_memberof
5542 #
5543 # Purpose: Recognise a documented list of allowed values written as
5544 # prose, such as "one of red, green or blue", "must be one
5545 # of C<low>, C<moderate> or C<high>", "valid values are 1,
5546 # 5 and 111" or "either C<host> or C<port>".
5547 # The list is documentation, not a check the routine was
5548 # seen to make, so callers mark the parameter
5549 # _source => 'pod': the harness uses the values as valid
5550 # data and generates no must-die case outside the set.
5551 # Entry: $text - a parameter description or constraint, possibly
5552 # containing POD formatting codes.
5553 # Exit: Arrayref of the documented values, or undef when the text
5554 # holds no recognisable list. Every value must be a single
5555 # token, so prose like "one of the four recognised keys set
5556 # to a true value also adds ..." is not mistaken for a list.
5557 # --------------------------------------------------
5558 764 ▶sub _prose_memberof {
Subroutine _prose_memberof: called CC=10 SCAR=23.0
5559 764 my ($self, $text) = @_;
5560  
5561 764 ▶ return undef unless defined($text) && length($text);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $text and length $text 37 727 764
Condition66%2/3
defined $text and length $text
!ll&&!rl&&r
037727
MC/DC50%1/2
defined $text and length $text
defined $text length $text
Truth table66%2/3
A and B
A= defined $textB= length $text
ABresult
0X0
100
111
5562  
5563 727 my $plain = $text;
5564 727 $plain =~ s/\b[CLIB]<([^<>]*)>/$1/g; # drop POD formatting
5565 727 $plain =~ s/\bE<([^<>]*)>/$1/g;
5566 727 $plain =~ s/\A\s+//;
5567 727 $plain =~ s/\s+\z//;
5568  
5569 727 my $list;
5570 727 ▶ if($plain =~ /\b(?:one\s+of|valid\s+values?\s*(?:are|is)?\s*:?|allowed\s+values?\s*(?:are|is)?\s*:?|accepted\s+values?\s*(?:are|is)?\s*:?|permitted\s+values?\s*(?:are|is)?\s*:?)\s*(.+)$/i) {
Branch: 3 branches
BranchTrueFalseTotal
if ($plain =~ /\b(?:one\s+of|valid\s+values?\s*(?:are|is)?\s*:?|allowed\s+values?\s*(?:are|is)?\s*:?|accepted\s+values?\s*(?:are|is)?\s*:?|permitted\s+values?\s*(?:are|is)?\s*:?)\s*(.+)$/i) { } 6 721 727
elsif ($plain =~ /\b(?:must\s+be\s+)?either\s+(.+)$/i) { } 1 720 721
elsif ($plain =~ /\b(?:also\s+)?accepts\s+the\s+strings?\s+(.+)$/i) { } 4 716 720
5571 6 $list = $1;
5572 } elsif($plain =~ /\b(?:must\s+be\s+)?either\s+(.+)$/i) {
5573 1 $list = $1;
5574 } elsif($plain =~ /\b(?:also\s+)?accepts\s+the\s+strings?\s+(.+)$/i) {
5575 # "Also accepts the strings off, warn, and fatal."
5576 4 $list = $1;
5577 } else {
5578 716 return undef;
5579 }
5580  
5581 11 $list =~ s/\.(?:\s|\z).*\z//s; # stop at the end of the sentence
5582 11 $list =~ s/\s*\.\s*\z//;
5583 11 $list =~ s/\s+\z//;
5584  
5585 11 my @values = grep { length } split(/\s*,\s*(?:(?:and|or)\s+)?|\s+(?:and|or)\s+/i, $list);
5586 11 ▶ return undef if(@values < 2 || @values > 20);
Branch: 1 branch
BranchTrueFalseTotal
if @values < 2 or @values > 20 2 9 11
Condition66%2/3
@values < 2 or @values > 20
l!l&&r!l&&!r
209
MC/DC50%1/2
@values < 2 or @values > 20
@values < 2 @values > 20
Truth table66%2/3
A or B
A= @values < 2B= @values > 20
ABresult
1X1
011
000
5587  
5588 9 for my $value (@values) {
5589 24 $value =~ s/\A\s+|\s+\z//g;
5590 24 $value =~ s/\A['"]|['"]\z//g;
5591 24 ▶ return undef unless $value =~ /\A[A-Za-z0-9_:.+-]+\z/;
Branch: 1 branch
BranchTrueFalseTotal
unless $value =~ /\A[A-Za-z0-9_:.+-]+\z/ 1 23 24
5592 }
5593  
5594 8 return \@values;
5595 }
5596  
5597 # --------------------------------------------------
5598 # _parse_constraints
5599 #
5600 # Purpose: Parse a constraint string extracted
5601 # from POD documentation and populate
5602 # min, max, or other constraint fields
5603 # in a parameter hashref.
5604 #
5605 # Entry: $param - hashref for the parameter
5606 # being annotated (modified
5607 # in place).
5608 # $constraint - the constraint string,
5609 # e.g. '3-50', 'positive',
5610 # '>= 0', 'min 3'.
5611 #
5612 # Exit: Returns nothing. Modifies $param in
5613 # place by setting min and/or max keys.
5614 #
5615 # Side effects: Logs min/max values to stdout when
5616 # verbose is set, and marks the constraints as
5617 # documented (documentation only).
5618 # --------------------------------------------------
5619 30 ▶sub _parse_constraints {
Subroutine _parse_constraints: called CC=23 SCAR=34.6
5620 30 my ($self, $param, $constraint) = @_;
5621  
5622 # A documented list of values, e.g. "(one of red, green)"
5623 30 ▶ if(my $values = $self->_prose_memberof($constraint)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $values = $self->_prose_memberof($constraint)) 0 30 30
5624 0 $param->{memberof} = $values;
5625 }
5626  
5627 # Range: "3-50" or "1-100 chars"
5628 30 ▶ if ($constraint =~ /(\d+)\s*-\s*(\d+)/) {
Branch: 7 branches
BranchTrueFalseTotal
if ($constraint =~ /(\d+)\s*-\s*(\d+)/) { } 6 24 30
elsif ($constraint =~ /(\d+)\s*\.\.\s*(\d+)/) { } 1 23 24
elsif ($constraint =~ /(?:min|minimum|at least)\s*(\d+)/i) { } 4 19 23
elsif ($constraint =~ /(?:max|maximum|up to)\s*(\d+)/i) { } 3 16 19
elsif ($constraint =~ /positive/i) { } 2 14 16
elsif ($constraint =~ /non-negative/i) { } 1 13 14
elsif ($constraint =~ /^(\S+)\s+(.+)$/) { } 8 5 13
5629 6 $param->{min} = $1;
5630 6 $param->{max} = $2;
5631 }
5632 elsif ($constraint =~ /(\d+)\s*\.\.\s*(\d+)/) {
5633 # Range: 0..19
5634 1 $param->{min} = $1;
5635 1 $param->{max} = $2;
5636 }
5637 # Minimum: "min 3" or "at least 5"
5638 elsif ($constraint =~ /(?:min|minimum|at least)\s*(\d+)/i) {
5639 4 $param->{min} = $1;
5640 }
5641 # Maximum: "max 50" or "up to 100"
5642 elsif ($constraint =~ /(?:max|maximum|up to)\s*(\d+)/i) {
5643 3 $param->{max} = $1;
5644 }
5645 # Positive
5646 elsif ($constraint =~ /positive/i) {
5647 2 ▶ $param->{min} = 1 if $param->{type} && $param->{type} eq 'integer';
Branch: 1 branch
BranchTrueFalseTotal
if $param->{"type"} and $param->{"type"} eq "integer" 1 1 2
Condition66%2/3
$param->{"type"} and $param->{"type"} eq "integer"
!ll&&!rl&&r
011
MC/DC50%1/2
$param->{"type"} and $param->{"type"} eq "integer"
$param->{"type"} $param->{"type"} eq "integer"
Truth table66%2/3
A and B
A= $param->{"type"}B= $param->{"type"} eq "integer"
ABresult
0X0
100
111
5648 2 ▶ $param->{min} = 0.01 if $param->{type} && $param->{type} eq 'number';
Branch: 1 branch
BranchTrueFalseTotal
if $param->{"type"} and $param->{"type"} eq "number" 1 1 2
Condition66%2/3
$param->{"type"} and $param->{"type"} eq "number"
!ll&&!rl&&r
011
MC/DC50%1/2
$param->{"type"} and $param->{"type"} eq "number"
$param->{"type"} $param->{"type"} eq "number"
Truth table66%2/3
A and B
A= $param->{"type"}B= $param->{"type"} eq "number"
ABresult
0X0
100
111
5649 }
5650 # Non-negative
5651 elsif ($constraint =~ /non-negative/i) {
5652 1 $param->{min} = 0;
5653 } elsif($constraint =~ /^(\S+)\s+(.+)$/) {
5654 8 my ($op, $val) = ($1, $2);
5655 8 ▶ if(looks_like_number($val)) {
Branch: 1 branch
BranchTrueFalseTotal
if (&looks_like_number($val)) 0 8 8
5656 0 ▶ if ($op eq '<') {
Branch: 4 branches
BranchTrueFalseTotal
if ($op eq '<') { } 0 0 0
elsif ($op eq '<=') { } 0 0 0
elsif ($op eq '>') { } 0 0 0
elsif ($op eq '>=') { } 0 0 0
5657 0 $param->{max} = $val - 1;
5658 } elsif ($op eq '<=') {
5659 0 $param->{max} = $val;
5660 } elsif ($op eq '>') {
5661 0 $param->{min} = $val + 1;
5662 } elsif ($op eq '>=') {
5663 0 $param->{min} = $val;
5664 }
5665 }
5666 }
5667  
5668 30 ▶ if(defined($param->{max})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $param->{"max"}) 10 20 30
5669 10 $self->_log(" Set max to $param->{max}");
5670 }
5671 30 ▶ if(defined($param->{min})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $param->{"min"}) 14 16 30
5672 14 $self->_log(" Set min to $param->{min}");
5673 }
5674  
5675 # These constraints come from prose ("3-50 chars", "at least 5"): they
5676 # describe valid input rather than a check the code was seen to make, so
5677 # the harness uses them as data hints and expects no croak outside them.
5678 30 ▶ if(defined($param->{min}) || defined($param->{max}) || $param->{memberof}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $param->{"min"} or defined $param->{"max"} or $param->{"memberof"}) 17 13 30
Condition83%5/6
defined $param->{"min"} or defined $param->{"max"} or $param->{"memberof"}
l!l&&r!l&&!r
17013
defined $param->{"min"} or defined $param->{"max"}
l!l&&r!l&&!r
14313
MC/DC66%2/3
defined $param->{"min"} or defined $param->{"max"} or $param->{"memberof"}
defined $param->{"min"} defined $param->{"max"} $param->{"memberof"}
Truth table75%3/4
A or B or C
A= defined $param->{"min"}B= defined $param->{"max"}C= $param->{"memberof"}
ABCresult
1XX1
01X1
0011
0000
5679 17 $param->{_source} = SOURCE_POD;
5680 }
5681 }
5682  
5683 # --------------------------------------------------
5684 # _analyze_code
5685 #
5686 # Purpose: Analyse a method's source code using
5687 # pattern matching to infer parameter
5688 # names, types, constraints, defaults,
5689 # and optionality. Orchestrates all
5690 # per-parameter code analysis helpers.
5691 #
5692 # Entry: $code - method body source string.
5693 # $method - method hashref (used for
5694 # constructor-specific logic
5695 # when extracting parameters
5696 # from @_ patterns).
5697 #
5698 # Exit: Returns a hashref of parameter name
5699 # to parameter spec hashref, with as
5700 # much type and constraint information
5701 # as could be inferred from the code.
5702 #
5703 # Side effects: Logs progress and warnings to stdout
5704 # when verbose is set.
5705 #
5706 # Notes: Analysis is capped at max_parameters
5707 # to prevent runaway processing on
5708 # pathological methods. Falls back to
5709 # classic @_ extraction if signature
5710 # extraction found no parameters.
5711 # --------------------------------------------------
5712 770 ▶sub _analyze_code {
Subroutine _analyze_code: called CC=27 SCAR=38.5
5713 770 my ($self, $code, $method) = @_;
5714  
5715 770 my %params;
5716  
5717 # Safety check - limit parameter analysis to prevent runaway processing
5718 770 my $param_count = 0;
5719  
5720 # Extract parameter names from various signature styles
5721 770 $self->_extract_parameters_from_signature(\%params, $code);
5722  
5723 # Params::Get: get_params('key', \@_) passes the param name as a string,
5724 # not as a $var in the signature, so run this unconditionally as a second
5725 # pass after the early-returning signature parsers have finished.
5726 770 ▶ if($code =~ /Params::Get/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /Params::Get/) 13 757 770
5727 13 my $pos = scalar keys %params;
5728 13 ▶ while($code =~ /get_params\s*\(\s*['"](\w+)['"]/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /get_params\s*\(\s*['"](\w+)['"]/g) 7 13 20
5729 7 my $name = $1;
5730 7 ▶ next if $name =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass)$/i 0 7 7
5731 7 ▶ $params{$name} //= { _source => SOURCE_CODE, position => $pos++ };
Condition50%1/2
$params{$name} //= {"_source", "code", "position", $pos++}
l!l
07
MC/DC0%0/1
$params{$name} //= {"_source", "code", "position", $pos++}
$params{$name}
Truth table50%1/2
A
A= $params{$name}
Aresult
11
00
5732 7 $self->_log(" CODE: Found Params::Get parameter '$name'");
5733 }
5734 }
5735  
5736 770 $self->_extract_defaults_from_code(\%params, $code, $method);
5737  
5738 # Infer types from defaults
5739 770 foreach my $param (keys %params) {
5740 510 ▶ if ($params{$param}{_default} && !$params{$param}{type}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($params{$param}{"_default"} and not $params{$param}{"type"}) 33 477 510
Condition66%2/3
$params{$param}{"_default"} and not $params{$param}{"type"}
!ll&&!rl&&r
477033
MC/DC50%1/2
$params{$param}{"_default"} and not $params{$param}{"type"}
$params{$param}{"_default"} not $params{$param}{"type"}
Truth table66%2/3
A and not(B)
A= $params{$param}{"_default"}B= not $params{$param}{"type"}
ABresult
0X0
100
111
5741 33 my $default = $params{$param}{_default};
5742 33 ▶ if (ref($default) eq 'HASH') {
Branch: 2 branches
BranchTrueFalseTotal
if (ref $default eq 'HASH') { } 6 27 33
elsif (ref $default eq 'ARRAY') { } 2 25 27
5743 6 $params{$param}{type} = 'hashref';
5744 6 $self->_log(" CODE: $param type inferred as hashref from default");
5745 } elsif (ref($default) eq 'ARRAY') {
5746 2 $params{$param}{type} = 'arrayref';
5747 2 $self->_log(" CODE: $param type inferred as arrayref from default");
5748 }
5749 }
5750 }
5751  
5752 770 ▶ if($code =~ /(?:croak|die)\(.*\)\s+if\s*\(\s*scalar\(\@_\)\s*<\s*(\d+)\s*\)/s) {
Branch: 2 branches
BranchTrueFalseTotal
if ($code =~ /(?:croak|die)\(.*\)\s+if\s*\(\s*scalar\(\@_\)\s*<\s*(\d+)\s*\)/s) { } 0 770 770
elsif ($code =~ /(?:croak|die)\(.*\)\s+if\s*\(\s*scalar\(\@_\)\s*==\s*0\s*\)/s) { } 0 770 770
5753 0 my $required_count = $1;
5754 0 my @param_names = sort { $params{$a}{position} <=> $params{$b}{position} } keys %params;
5755 0 for my $i (0 .. $required_count-1) {
5756 0 $params{$param_names[$i]}{optional} = 0;
5757 0 $self->_log(" CODE: $param_names[$i] marked required due to croak scalar check");
5758 }
5759 } elsif ($code =~ /(?:croak|die)\(.*\)\s+if\s*\(\s*scalar\(\@_\)\s*==\s*0\s*\)/s) {
5760 0 foreach my $param (keys %params) {
5761 0 $params{$param}{optional} = 0;
5762 0 $self->_log(" CODE: $param: all parameters are required due to 'scalar(@_) == 0' check");
5763 }
5764 }
5765  
5766 # Analyze each parameter (with safety limit)
5767 770 foreach my $param (keys %params) {
5768 510 ▶ if ($param_count++ > $self->{max_parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param_count++ > $self->{"max_parameters"}) 0 510 510
5769 0 $self->_log(" WARNING: Max parameters ($self->{max_parameters}) exceeded, skipping remaining");
5770 0 last;
5771 }
5772  
5773 510 my $p = \$params{$param};
5774  
5775 510 $self->_analyze_parameter_type($p, $param, $code);
5776 510 $self->_analyze_parameter_constraints($p, $param, $code);
5777 510 $self->_analyze_parameter_validation($p, $param, $code);
5778 510 $self->_analyze_advanced_types($p, $param, $code);
5779  
5780 # Defined checks
5781 510 ▶ if ($code =~ /defined\s*\(\s*\$$param\s*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /defined\s*\(\s*\$$param\s*\)/) 42 468 510
5782 42 $$p->{optional} = 0;
5783 42 $self->_log(" CODE: $param is required (defined check)");
5784 }
5785  
5786 # Determine optional/required and numeric type from code
5787 510 ▶ if ($code =~ /\s*\$$param\s*(?:\/\/|\|\|)=/) {
Branch: 3 branches
BranchTrueFalseTotal
if ($code =~ m[\s*\$$param\s*(?://|\|\|)=]) { } 21 489 510
elsif ($code =~ m[\s*\$$param\s*(?:[\+\-\*\%]|/(?!/)|(?:\+\+)|(?:--)|(?:[\+\-\*\%]=|/(?!/)=)|\+\$|\$[+-])]) { } 134 355 489
elsif ($code =~ /\$\b$param\b\s*(?:\+0|\*1)/) { } 0 355 355
5788 # e.g. $var //= 5; or $var ||= 5;
5789 21 $$p->{optional} = 1;
5790 21 $self->_log(" CODE: $param is optional (default value assigned in code)");
5791 } elsif ($code =~ /\s*\$$param\s*(?:[\+\-\*\%]|\/(?!\/)|(?:\+\+)|(?:--)|(?:[\+\-\*\%]=|\/(?!\/)=)|\+\$|\$[+-])/ ) {
5792 # Covers arithmetic usage:
5793 # $x + $param, $param++, $param--, $x += $param, $x -= $param, etc.
5794 134 $$p->{optional} = 0;
5795 134 ▶ $$p->{type} //= 'number';
Condition50%1/2
$$p->{"type"} //= "number"
l!l
1340
MC/DC0%0/1
$$p->{"type"} //= "number"
$$p->{"type"}
Truth table50%1/2
A
A= $$p->{"type"}
Aresult
11
00
5796 134 $self->_log(" CODE: $param is required (used in arithmetic context)");
5797 } elsif ($code =~ /\$\b$param\b\s*(?:\+0|\*1)/) {
5798 # Forces numeric context, e.g., "$param + 0" or "$param * 1"
5799 0 $$p->{optional} = 0;
5800 0 ▶ $$p->{type} //= 'number';
Condition0%0/2
$$p->{"type"} //= "number"
l!l
00
MC/DC0%0/1
$$p->{"type"} //= "number"
$$p->{"type"}
Truth table0%0/2
A
A= $$p->{"type"}
Aresult
11
00
5801 0 $self->_log(" CODE: $param is required (numeric context)");
5802 }
5803  
5804 # Required parameter checks (undef causes error)
5805  
5806 # Style 1: block form
5807 510 ▶ if ($code =~ /if\s*\(\s*!\s*defined\s*\(\s*\$$param\s*\)\s*\)\s*\{([^}]+)\}/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /if\s*\(\s*!\s*defined\s*\(\s*\$$param\s*\)\s*\)\s*\{([^}]+)\}/s) 0 510 510
5808 0 my $block = $1;
5809 0 ▶ if ($block =~ /\b(croak|die|confess)\b/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($block =~ /\b(croak|die|confess)\b/) 0 0 0
5810 0 $$p->{optional} = 0;
5811 0 $self->_log(" CODE: $param is required (undef causes error)");
5812 }
5813 }
5814  
5815 # Style 2: postfix unless
5816 510 ▶ if ($code =~ /\b(croak|die|confess)\b[^;]*\bunless\s+defined\s*\(\s*\$$param\s*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\b(croak|die|confess)\b[^;]*\bunless\s+defined\s*\(\s*\$$param\s*\)/) 18 492 510
5817 18 $$p->{optional} = 0;
5818 18 $self->_log(" CODE: $param is required (postfix undef check)");
5819 }
5820  
5821 # Exists checks for hash keys
5822 510 ▶ if ($code =~ /exists\s*\(\s*\$$param\s*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /exists\s*\(\s*\$$param\s*\)/) 0 510 510
5823 0 $$p->{type} = 'hashkey';
5824 0 $self->_log(" CODE: $param is a hash key");
5825 }
5826  
5827 # Scalar context for arrays
5828 510 ▶ if ($code =~ /scalar\s*\(\s*\@?\$$param\s*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /scalar\s*\(\s*\@?\$$param\s*\)/) 1 509 510
5829 1 $$p->{type} = 'array';
5830 1 $self->_log(" CODE: $param used in scalar context (array)");
5831 }
5832  
5833 510 $self->_extract_error_constraints($p, $param, $code);
5834 }
5835  
5836 770 $self->_sanitize_parameter_names(\%params, 'code analysis');
5837 770 return \%params;
5838 }
5839  
5840 # --------------------------------------------------
5841 # _analyze_parameter_type
5842 #
5843 # Purpose: Infer the type of a single parameter
5844 # from ref() checks, isa() calls,
5845 # bless patterns, array/hash operations,
5846 # and numeric operator usage in the
5847 # method body.
5848 #
5849 # Entry: $p_ref - reference to the parameter
5850 # hashref (modified in place
5851 # via the referenced hash).
5852 # $param - parameter name string.
5853 # $code - method body source string.
5854 #
5855 # Exit: Returns nothing. Modifies the
5856 # referenced parameter hashref.
5857 #
5858 # Side effects: Logs detections to stdout when
5859 # verbose is set.
5860 # --------------------------------------------------
5861 510 ▶sub _analyze_parameter_type {
Subroutine _analyze_parameter_type: called CC=23 SCAR=31.7
5862 510 my ($self, $p_ref, $param, $code) = @_;
5863 510 my $p = $$p_ref;
5864  
5865 # Type inference from ref() checks
5866 510 ▶ if ($code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"](ARRAY|HASH|SCALAR)['"]/gi) {
Branch: 3 branches
BranchTrueFalseTotal
if ($code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"](ARRAY|HASH|SCALAR)['"]/gi) { } 40 470 510
elsif ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]([^'"]+)['"]\s*\)/i) { } 3 467 470
elsif ($code =~ /bless\s+.*\$$param/) { } 6 461 467
5867 40 my $reftype = lc($1);
5868 40 ▶ $p->{type} = $reftype eq 'array' ? 'arrayref' :
Branch: 2 branches
BranchTrueFalseTotal
$reftype eq 'array' ? : 5 35 40
$reftype eq 'hash' ? : 35 0 35
5869 $reftype eq 'hash' ? 'hashref' :
5870 'scalar';
5871 40 $self->_log(" CODE: $param is $p->{type} (ref check)");
5872 }
5873 # ISA checks for objects
5874 elsif ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]([^'"]+)['"]\s*\)/i) {
5875 3 $p->{type} = 'object';
5876 3 $p->{isa} = $1;
5877 3 $self->_log(" CODE: $param is object of class $1");
5878 }
5879 # Blessed references
5880 elsif ($code =~ /bless\s+.*\$$param/) {
5881 6 $p->{type} = 'object';
5882 6 $self->_log(" CODE: $param is blessed object");
5883 }
5884 # Array/hash operations
5885 510 ▶ if (!$p->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($p->{"type"}) 456 54 510
5886 456 ▶ if ($code =~ /\@\{\s*\$$param\s*\}/ || $code =~ /push\s*\(\s*\@?\$$param/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($code =~ /\@\{\s*\$$param\s*\}/ or $code =~ /push\s*\(\s*\@?\$$param/) { } 5 451 456
elsif ($code =~ /\%\{\s*\$$param\s*\}/ or $code =~ /\$$param\s*->\s*\{/) { } 27 424 451
Condition66%2/3
$code =~ /\@\{\s*\$$param\s*\}/ or $code =~ /push\s*\(\s*\@?\$$param/
l!l&&r!l&&!r
50451
MC/DC50%1/2
$code =~ /\@\{\s*\$$param\s*\}/ or $code =~ /push\s*\(\s*\@?\$$param/
$code =~ /\@\{\s*\$$param\s*\}/ $code =~ /push\s*\(\s*\@?\$$param/
Truth table66%2/3
A or B
A= $code =~ /\@\{\s*\$$param\s*\}/B= $code =~ /push\s*\(\s*\@?\$$param/
ABresult
1X1
011
000
5887 5 $p->{type} = 'arrayref';
5888 ▶ } elsif ($code =~ /\%\{\s*\$$param\s*\}/ || $code =~ /\$$param\s*->\s*\{/) {
Condition66%2/3
$code =~ /\%\{\s*\$$param\s*\}/ or $code =~ /\$$param\s*->\s*\{/
l!l&&r!l&&!r
027424
MC/DC50%1/2
$code =~ /\%\{\s*\$$param\s*\}/ or $code =~ /\$$param\s*->\s*\{/
$code =~ /\%\{\s*\$$param\s*\}/ $code =~ /\$$param\s*->\s*\{/
Truth table66%2/3
A or B
A= $code =~ /\%\{\s*\$$param\s*\}/B= $code =~ /\$$param\s*->\s*\{/
ABresult
1X1
011
000
5889 27 $p->{type} = 'hashref';
5890 }
5891 }
5892  
5893 # Infer type from the default value if type is unknown
5894 510 ▶ if (!$p->{type} && exists $p->{_default}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $p->{"type"} and exists $p->{"_default"}) 32 478 510
Condition100%3/3
not $p->{"type"} and exists $p->{"_default"}
!ll&&!rl&&r
8639232
MC/DC100%2/2
not $p->{"type"} and exists $p->{"_default"}
not $p->{"type"} exists $p->{"_default"}
Truth table100%3/3
not(A) and B
A= not $p->{"type"}B= exists $p->{"_default"}
ABresult
0X0
100
111
5895 32 my $default = $p->{_default};
5896 32 ▶ if (ref($default) eq 'HASH') {
Branch: 2 branches
BranchTrueFalseTotal
if (ref $default eq 'HASH') { } 0 32 32
elsif (ref $default eq 'ARRAY') { } 0 32 32
5897 0 $p->{type} = 'hashref';
5898 0 $self->_log(" CODE: $param type inferred as hashref from default");
5899 } elsif (ref($default) eq 'ARRAY') {
5900 0 $p->{type} = 'arrayref';
5901 0 $self->_log(" CODE: $param type inferred as arrayref from default");
5902 }
5903 }
5904  
5905 # ------------------------------------------------------------
5906 # Heuristic numeric inference (low confidence)
5907 # ------------------------------------------------------------
5908 510 ▶ if (!$p->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $p->{"type"}) 424 86 510
5909 # An explicit looks_like_number($param) check is a direct
5910 # numeric-type assertion by the author, stronger evidence than
5911 # incidental arithmetic adjacency (e.g. $param is only ever
5912 # used inside a defined-or default before the arithmetic, so
5913 # the arithmetic-operator check below never sees $param itself
5914 # next to an operator).
5915 424 ▶ if ($code =~ /\blooks_like_number\s*\(\s*\$$param\s*\)/) {
Branch: 3 branches
BranchTrueFalseTotal
if ($code =~ /\blooks_like_number\s*\(\s*\$$param\s*\)/) { } 13 411 424
elsif ($code =~ m[\$$param\s*(?:[\+\-\*\%]|/(?!/))] or $code =~ m[(?:[\+\-\*\%]|/(?!/))\s*\$$param] or $code =~ /\bint\s*\(\s*\$$param\s*\)/ or $code =~ /\babs\s*\(\s*\$$param\s*\)/) { } 99 312 411
elsif ($code =~ /\$$param\s*(?:==|!=|<=|>=|<|>)/ or $code =~ /(?:==|!=|<=|>=|<|>)\s*\$$param/) { } 33 279 312
5916 13 $p->{type} = 'number';
5917 13 $p->{_type_confidence} = 'heuristic';
5918 13 $self->_log(" CODE: $param inferred as number (looks_like_number check)");
5919 }
5920 # Numeric operators: + - * / % **
5921 # Use \/(?!\/) to exclude // (defined-or) from matching as division.
5922 ▶ elsif (
Condition88%8/9
$code =~ m[\$$param\s*(?:[\+\-\*\%]|/(?!/))] or $code =~ m[(?:[\+\-\*\%]|/(?!/))\s*\$$param] or $code =~ /\bint\s*\(\s*\$$param\s*\)/ or $code =~ /\babs\s*\(\s*\$$param\s*\)/
l!l&&r!l&&!r
990312
$code =~ m[\$$param\s*(?:[\+\-\*\%]|/(?!/))] or $code =~ m[(?:[\+\-\*\%]|/(?!/))\s*\$$param] or $code =~ /\bint\s*\(\s*\$$param\s*\)/
l!l&&r!l&&!r
972312
$code =~ m[\$$param\s*(?:[\+\-\*\%]|/(?!/))] or $code =~ m[(?:[\+\-\*\%]|/(?!/))\s*\$$param]
l!l&&r!l&&!r
6928314
MC/DC75%3/4
$code =~ m[\$$param\s*(?:[\+\-\*\%]|/(?!/))] or $code =~ m[(?:[\+\-\*\%]|/(?!/))\s*\$$param] or $code =~ /\bint\s*\(\s*\$$param\s*\)/ or $code =~ /\babs\s*\(\s*\$$param\s*\)/
$code =~ m[\$$param\s*(?:[\+\-\*\%]|/(?!/))] $code =~ m[(?:[\+\-\*\%]|/(?!/))\s*\$$param] $code =~ /\bint\s*\(\s*\$$param\s*\)/ $code =~ /\babs\s*\(\s*\$$param\s*\)/
Truth table80%4/5
A or B or C or D
A= $code =~ m[\$$param\s*(?:[\+\-\*\%]|/(?!/))]B= $code =~ m[(?:[\+\-\*\%]|/(?!/))\s*\$$param]C= $code =~ /\bint\s*\(\s*\$$param\s*\)/D= $code =~ /\babs\s*\(\s*\$$param\s*\)/
ABCDresult
1XXX1
01XX1
001X1
00011
00000
5923 $code =~ /\$$param\s*(?:[\+\-\*\%]|\/(?!\/))/ ||
5924 $code =~ /(?:[\+\-\*\%]|\/(?!\/))\s*\$$param/ ||
5925 $code =~ /\bint\s*\(\s*\$$param\s*\)/ ||
5926 $code =~ /\babs\s*\(\s*\$$param\s*\)/
5927 ) {
5928 99 $p->{type} = 'number';
5929 99 $p->{_type_confidence} = 'heuristic';
5930 99 $self->_log(" CODE: $param inferred as number (numeric operator)");
5931 }
5932 # Numeric comparison
5933 ▶ elsif (
Condition100%3/3
$code =~ /\$$param\s*(?:==|!=|<=|>=|<|>)/ or $code =~ /(?:==|!=|<=|>=|<|>)\s*\$$param/
l!l&&r!l&&!r
2112279
MC/DC100%2/2
$code =~ /\$$param\s*(?:==|!=|<=|>=|<|>)/ or $code =~ /(?:==|!=|<=|>=|<|>)\s*\$$param/
$code =~ /\$$param\s*(?:==|!=|<=|>=|<|>)/ $code =~ /(?:==|!=|<=|>=|<|>)\s*\$$param/
Truth table100%3/3
A or B
A= $code =~ /\$$param\s*(?:==|!=|<=|>=|<|>)/B= $code =~ /(?:==|!=|<=|>=|<|>)\s*\$$param/
ABresult
1X1
011
000
5934 $code =~ /\$$param\s*(?:==|!=|<=|>=|<|>)/ ||
5935 $code =~ /(?:==|!=|<=|>=|<|>)\s*\$$param/
5936 ) {
5937 33 $p->{type} = 'number';
5938 33 $p->{_type_confidence} = 'heuristic';
5939 33 $self->_log(" CODE: $param inferred as number (numeric comparison)");
5940 }
5941 }
5942 }
5943  
5944 # --------------------------------------------------
5945 # _analyze_advanced_types
5946 #
5947 # Purpose: Apply enhanced type detection to a
5948 # single parameter, checking for
5949 # DateTime objects, file handles,
5950 # coderefs, and enum-like constraints
5951 # beyond what basic type inference
5952 # can determine.
5953 #
5954 # Entry: $p_ref - reference to the parameter
5955 # hashref (modified in place
5956 # via the referenced hash).
5957 # $param - the parameter name string.
5958 # $code - method body source string.
5959 #
5960 # Exit: Returns nothing. Modifies the
5961 # referenced parameter hashref in place.
5962 #
5963 # Side effects: Logs detections to stdout when
5964 # verbose is set.
5965 #
5966 # Notes: Delegates to four specialised
5967 # detectors: _detect_datetime_type,
5968 # _detect_filehandle_type,
5969 # _detect_coderef_type, and
5970 # _detect_enum_type. Each detector
5971 # returns early on first match so
5972 # detectors are implicitly prioritised
5973 # in that order.
5974 # --------------------------------------------------
5975 511 ▶sub _analyze_advanced_types {
Subroutine _analyze_advanced_types: called CC=1 SCAR=0.0
5976 511 my ($self, $p_ref, $param, $code) = @_;
5977  
5978 # Dereference once to get the hash reference
5979 511 my $p = $$p_ref;
5980  
5981 # Now pass the dereferenced hash to the detection methods
5982 511 $self->_detect_datetime_type($p, $param, $code);
5983 511 $self->_detect_filehandle_type($p, $param, $code);
5984 511 $self->_detect_coderef_type($p, $param, $code);
5985 511 $self->_detect_enum_type($p, $param, $code);
5986 }
5987  
5988 # --------------------------------------------------
5989 # _detect_datetime_type
5990 #
5991 # Purpose: Detect DateTime objects, Time::Piece
5992 # objects, date strings, ISO 8601
5993 # strings, and UNIX timestamps by
5994 # analysing code patterns involving
5995 # the parameter.
5996 #
5997 # Entry: $p - parameter hashref (modified
5998 # in place).
5999 # $param - parameter name string.
6000 # $code - method body source string.
6001 #
6002 # Exit: Returns nothing. Modifies $p in place,
6003 # setting type, isa, semantic, min,
6004 # matches, and/or format keys.
6005 # Returns immediately on first match.
6006 #
6007 # Side effects: Logs detections to stdout when
6008 # verbose is set.
6009 # --------------------------------------------------
6010 510 ▶sub _detect_datetime_type {
Subroutine _detect_datetime_type: called CC=14 SCAR=28.8
6011 510 my ($self, $p, $param, $code) = @_;
6012  
6013 # Validate param is just a simple word
6014 510 ▶ return unless defined $param && $param =~ /^\w+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $param and $param =~ /^\w+$/ 0 510 510
Condition33%1/3
defined $param and $param =~ /^\w+$/
!ll&&!rl&&r
00510
MC/DC0%0/2
defined $param and $param =~ /^\w+$/
defined $param $param =~ /^\w+$/
Truth table33%1/3
A and B
A= defined $paramB= $param =~ /^\w+$/
ABresult
0X0
100
111
6015  
6016 # DateTime object detection via isa/UNIVERSAL checks
6017 510 ▶ if ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]DateTime['"]\s*\)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]DateTime['"]\s*\)/i) 1 509 510
6018 1 $p->{type} = 'object';
6019 1 $p->{isa} = 'DateTime';
6020 1 $p->{semantic} = 'datetime_object';
6021 1 $self->_log(" ADVANCED: $param is DateTime object");
6022 1 return;
6023 }
6024  
6025 # Check for DateTime method calls
6026 509 ▶ if ($code =~ /\$$param\s*->\s*(ymd|dmy|mdy|hms|iso8601|epoch|strftime)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*->\s*(ymd|dmy|mdy|hms|iso8601|epoch|strftime)/) 1 508 509
6027 1 $p->{type} = 'object';
6028 1 $p->{isa} = 'DateTime';
6029 1 $p->{semantic} = 'datetime_object';
6030 1 $self->_log(" ADVANCED: $param uses DateTime methods");
6031 1 return;
6032 }
6033  
6034 # Time::Piece detection
6035 508 ▶ if ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]Time::Piece['"]\s*\)/i ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]Time::Piece['"]\s*\)/i or $code =~ /\$$param\s*->\s*(strftime|epoch|year|mon|mday)/) 0 508 508
Condition33%1/3
$code =~ /\$$param\s*->\s*isa\s*\(\s*['"]Time::Piece['"]\s*\)/i or $code =~ /\$$param\s*->\s*(strftime|epoch|year|mon|mday)/
l!l&&r!l&&!r
00508
MC/DC0%0/2
$code =~ /\$$param\s*->\s*isa\s*\(\s*['"]Time::Piece['"]\s*\)/i or $code =~ /\$$param\s*->\s*(strftime|epoch|year|mon|mday)/
$code =~ /\$$param\s*->\s*isa\s*\(\s*['"]Time::Piece['"]\s*\)/i $code =~ /\$$param\s*->\s*(strftime|epoch|year|mon|mday)/
Truth table33%1/3
A or B
A= $code =~ /\$$param\s*->\s*isa\s*\(\s*['"]Time::Piece['"]\s*\)/iB= $code =~ /\$$param\s*->\s*(strftime|epoch|year|mon|mday)/
ABresult
1X1
011
000
6036 $code =~ /\$$param\s*->\s*(strftime|epoch|year|mon|mday)/) {
6037 0 $p->{type} = 'object';
6038 0 $p->{isa} = 'Time::Piece';
6039 0 $p->{semantic} = 'timepiece_object';
6040 0 $self->_log(" ADVANCED: $param is Time::Piece object");
6041 0 return;
6042 }
6043  
6044 # String date/time patterns via regex matching
6045 508 ▶ if ($code =~ /\$$param\s*=~\s*\/.*?\\d\{4\}.*?\\d\{2\}.*?\\d\{2\}/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ m[\$$param\s*=~\s*/.*?\\d\{4\}.*?\\d\{2\}.*?\\d\{2\}]) 1 507 508
6046 1 $p->{type} = 'string';
6047 1 $p->{semantic} = 'date_string';
6048 1 $p->{format} = 'YYYY-MM-DD or similar';
6049 1 $self->_log(" ADVANCED: $param validated as date string pattern");
6050 1 return;
6051 }
6052  
6053 # ISO 8601 date pattern
6054 507 ▶ if ($code =~ /\$$param\s*=~\s*\/.*?[Tt].*?[Zz].*?\//) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ m[\$$param\s*=~\s*/.*?[Tt].*?[Zz].*?/]) 1 506 507
6055 1 $p->{type} = 'string';
6056 1 $p->{semantic} = 'iso8601_string';
6057 1 $p->{matches} = '/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z?$/';
6058 1 $self->_log(" ADVANCED: $param validated as ISO 8601 datetime");
6059 1 return;
6060 }
6061  
6062 # UNIX timestamp detection (numeric with specific range)
6063 506 ▶ if ($code =~ /\$$param\s*>\s*\d{9,}/ || # UNIX timestamps are 10+ digits
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*>\s*\d{9,}/ or $code =~ /time\(\s*\)\s*-\s*\$$param/ or $code =~ /\$$param\s*-\s*time\(\s*\)/) 1 505 506
Condition66%4/6
$code =~ /\$$param\s*>\s*\d{9,}/ or $code =~ /time\(\s*\)\s*-\s*\$$param/ or $code =~ /\$$param\s*-\s*time\(\s*\)/
l!l&&r!l&&!r
10505
$code =~ /\$$param\s*>\s*\d{9,}/ or $code =~ /time\(\s*\)\s*-\s*\$$param/
l!l&&r!l&&!r
10505
MC/DC33%1/3
$code =~ /\$$param\s*>\s*\d{9,}/ or $code =~ /time\(\s*\)\s*-\s*\$$param/ or $code =~ /\$$param\s*-\s*time\(\s*\)/
$code =~ /\$$param\s*>\s*\d{9,}/ $code =~ /time\(\s*\)\s*-\s*\$$param/ $code =~ /\$$param\s*-\s*time\(\s*\)/
Truth table50%2/4
A or B or C
A= $code =~ /\$$param\s*>\s*\d{9,}/B= $code =~ /time\(\s*\)\s*-\s*\$$param/C= $code =~ /\$$param\s*-\s*time\(\s*\)/
ABCresult
1XX1
01X1
0011
0000
6064 $code =~ /time\(\s*\)\s*-\s*\$$param/ ||
6065 $code =~ /\$$param\s*-\s*time\(\s*\)/) {
6066 1 $p->{type} = 'integer';
6067 1 $p->{semantic} = 'unix_timestamp';
6068 1 $p->{min} = 0;
6069 1 $self->_log(" ADVANCED: $param appears to be UNIX timestamp");
6070 1 return;
6071 }
6072  
6073 # Date parsing with strptime or similar
6074 505 ▶ if ($code =~ /strptime\s*\(\s*\$$param/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /strptime\s*\(\s*\$$param/ or $code =~ /DateTime::Format::\w+\s*->\s*parse_datetime\s*\(\s*\$$param/) 0 505 505
Condition33%1/3
$code =~ /strptime\s*\(\s*\$$param/ or $code =~ /DateTime::Format::\w+\s*->\s*parse_datetime\s*\(\s*\$$param/
l!l&&r!l&&!r
00505
MC/DC0%0/2
$code =~ /strptime\s*\(\s*\$$param/ or $code =~ /DateTime::Format::\w+\s*->\s*parse_datetime\s*\(\s*\$$param/
$code =~ /strptime\s*\(\s*\$$param/ $code =~ /DateTime::Format::\w+\s*->\s*parse_datetime\s*\(\s*\$$param/
Truth table33%1/3
A or B
A= $code =~ /strptime\s*\(\s*\$$param/B= $code =~ /DateTime::Format::\w+\s*->\s*parse_datetime\s*\(\s*\$$param/
ABresult
1X1
011
000
6075 $code =~ /DateTime::Format::\w+\s*->\s*parse_datetime\s*\(\s*\$$param/) {
6076 0 $p->{type} = 'string';
6077 0 $p->{semantic} = 'datetime_parseable';
6078 0 $self->_log(" ADVANCED: $param is parsed as datetime");
6079 0 return;
6080 }
6081 }
6082  
6083 # --------------------------------------------------
6084 # _detect_filehandle_type
6085 #
6086 # Purpose: Detect file handle parameters and
6087 # file path string parameters by
6088 # analysing I/O operations, file test
6089 # operators, and path manipulation
6090 # patterns involving the parameter.
6091 #
6092 # Entry: $p - parameter hashref (modified
6093 # in place).
6094 # $param - parameter name string.
6095 # $code - method body source string.
6096 #
6097 # Exit: Returns nothing. Modifies $p in place,
6098 # setting type, isa, and semantic keys.
6099 # Returns immediately on first match.
6100 #
6101 # Side effects: Logs detections to stdout when
6102 # verbose is set.
6103 # --------------------------------------------------
6104 510 ▶sub _detect_filehandle_type {
Subroutine _detect_filehandle_type: called CC=13 SCAR=30.5
6105 510 my ($self, $p, $param, $code) = @_;
6106  
6107 510 ▶ return unless defined $param && $param =~ /^\w+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $param and $param =~ /^\w+$/ 0 510 510
Condition33%1/3
defined $param and $param =~ /^\w+$/
!ll&&!rl&&r
00510
MC/DC0%0/2
defined $param and $param =~ /^\w+$/
defined $param $param =~ /^\w+$/
Truth table33%1/3
A and B
A= defined $paramB= $param =~ /^\w+$/
ABresult
0X0
100
111
6108  
6109 # File handle operations
6110 510 ▶ if ($code =~ /(?:open|close|read|print|say|sysread|syswrite)\s*\(?\s*\$$param/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:open|close|read|print|say|sysread|syswrite)\s*\(?\s*\$$param/) 1 509 510
6111 1 $p->{type} = 'object';
6112 1 $p->{isa} = 'IO::Handle';
6113 1 $p->{semantic} = 'filehandle';
6114 1 $self->_log(" ADVANCED: $param is a file handle");
6115 1 return;
6116 }
6117  
6118 # Filehandle-specific operations
6119 509 ▶ if ($code =~ /\$$param\s*->\s*(readline|getline|print|say|close|flush|autoflush)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*->\s*(readline|getline|print|say|close|flush|autoflush)/) 1 508 509
6120 1 $p->{type} = 'object';
6121 1 $p->{isa} = 'IO::Handle';
6122 1 $p->{semantic} = 'filehandle';
6123 1 $self->_log(" ADVANCED: $param uses filehandle methods");
6124 1 return;
6125 }
6126  
6127 # File test operators. A -d test is a directory requirement: the value
6128 # has to name an existing directory, which no spelling pattern can
6129 # capture, so it gets its own semantic rather than a filepath pattern.
6130 508 ▶ if ($code =~ /(?:-[frwxoOeszlpSbctugkTBMAC])\s+\$$param/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:-[frwxoOeszlpSbctugkTBMAC])\s+\$$param/) 2 506 508
6131 2 $p->{type} = 'string';
6132 2 ▶ if ($code =~ /-d\s+\$$param/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /-d\s+\$$param/) { } 1 1 2
6133 1 $p->{semantic} = 'directory';
6134 1 $self->_log(" ADVANCED: $param is tested as a directory");
6135 } else {
6136 1 $p->{semantic} = 'filepath';
6137 1 $self->_log(" ADVANCED: $param is tested as file path");
6138 }
6139 2 return;
6140 }
6141  
6142 # File::Spec operations or path manipulation
6143 506 ▶ if ($code =~ /File::(?:Spec|Basename)::\w+\s*\(\s*\$$param/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /File::(?:Spec|Basename)::\w+\s*\(\s*\$$param/ or $code =~ /(?:basename|dirname|fileparse)\s*\(\s*\$$param/) 0 506 506
Condition33%1/3
$code =~ /File::(?:Spec|Basename)::\w+\s*\(\s*\$$param/ or $code =~ /(?:basename|dirname|fileparse)\s*\(\s*\$$param/
l!l&&r!l&&!r
00506
MC/DC0%0/2
$code =~ /File::(?:Spec|Basename)::\w+\s*\(\s*\$$param/ or $code =~ /(?:basename|dirname|fileparse)\s*\(\s*\$$param/
$code =~ /File::(?:Spec|Basename)::\w+\s*\(\s*\$$param/ $code =~ /(?:basename|dirname|fileparse)\s*\(\s*\$$param/
Truth table33%1/3
A or B
A= $code =~ /File::(?:Spec|Basename)::\w+\s*\(\s*\$$param/B= $code =~ /(?:basename|dirname|fileparse)\s*\(\s*\$$param/
ABresult
1X1
011
000
6144 $code =~ /(?:basename|dirname|fileparse)\s*\(\s*\$$param/) {
6145 0 $p->{type} = 'string';
6146 0 $p->{semantic} = 'filepath';
6147 0 $self->_log(" ADVANCED: $param manipulated as file path");
6148 0 return;
6149 }
6150  
6151 # Path validation patterns
6152 # Only match a literal path assigned or defaulted to this variable
6153 506 ▶ if(defined $p->{_default} && $p->{_default} =~ m{^([A-Za-z]:\\|/|\./|\.\./)}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $p->{"_default"} and $p->{"_default"} =~ m[^([A-Za-z]:\\|/|\./|\.\./)]) 0 506 506
Condition66%2/3
defined $p->{"_default"} and $p->{"_default"} =~ m[^([A-Za-z]:\\|/|\./|\.\./)]
!ll&&!rl&&r
465410
MC/DC0%0/2
defined $p->{"_default"} and $p->{"_default"} =~ m[^([A-Za-z]:\\|/|\./|\.\./)]
defined $p->{"_default"} $p->{"_default"} =~ m[^([A-Za-z]:\\|/|\./|\.\./)]
Truth table66%2/3
A and B
A= defined $p->{"_default"}B= $p->{"_default"} =~ m[^([A-Za-z]:\\|/|\./|\.\./)]
ABresult
0X0
100
111
6154 0 $p->{type} = 'string';
6155 0 $p->{semantic} = 'filepath';
6156 0 $self->_log(" ADVANCED: $param default looks like a path");
6157 0 return;
6158 }
6159  
6160 # IO::File detection
6161 506 ▶ if ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]IO::File['"]\s*\)/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*->\s*isa\s*\(\s*['"]IO::File['"]\s*\)/ or $code =~ /IO::File\s*->\s*new\s*\(\s*\$$param/) 0 506 506
Condition33%1/3
$code =~ /\$$param\s*->\s*isa\s*\(\s*['"]IO::File['"]\s*\)/ or $code =~ /IO::File\s*->\s*new\s*\(\s*\$$param/
l!l&&r!l&&!r
00506
MC/DC0%0/2
$code =~ /\$$param\s*->\s*isa\s*\(\s*['"]IO::File['"]\s*\)/ or $code =~ /IO::File\s*->\s*new\s*\(\s*\$$param/
$code =~ /\$$param\s*->\s*isa\s*\(\s*['"]IO::File['"]\s*\)/ $code =~ /IO::File\s*->\s*new\s*\(\s*\$$param/
Truth table33%1/3
A or B
A= $code =~ /\$$param\s*->\s*isa\s*\(\s*['"]IO::File['"]\s*\)/B= $code =~ /IO::File\s*->\s*new\s*\(\s*\$$param/
ABresult
1X1
011
000
6162 $code =~ /IO::File\s*->\s*new\s*\(\s*\$$param/) {
6163 0 $p->{type} = 'object';
6164 0 $p->{isa} = 'IO::File';
6165 0 $p->{semantic} = 'filehandle';
6166 0 $self->_log(" ADVANCED: $param is IO::File object");
6167 0 return;
6168 }
6169 }
6170  
6171 # --------------------------------------------------
6172 # _detect_coderef_type
6173 #
6174 # Purpose: Detect coderef and callback parameters
6175 # by analysing ref() checks, invocation
6176 # patterns, and parameter naming
6177 # conventions.
6178 #
6179 # Entry: $p - parameter hashref (modified
6180 # in place).
6181 # $param - parameter name string.
6182 # $code - method body source string.
6183 #
6184 # Exit: Returns nothing. Modifies $p in place,
6185 # setting type and semantic keys.
6186 # Returns immediately on first match.
6187 #
6188 # Side effects: Logs detections to stdout when
6189 # verbose is set.
6190 # --------------------------------------------------
6191 510 ▶sub _detect_coderef_type {
Subroutine _detect_coderef_type: called CC=11 SCAR=26.0
6192 510 my ($self, $p, $param, $code) = @_;
6193  
6194 510 ▶ return unless defined $param && $param =~ /^\w+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $param and $param =~ /^\w+$/ 0 510 510
Condition33%1/3
defined $param and $param =~ /^\w+$/
!ll&&!rl&&r
00510
MC/DC0%0/2
defined $param and $param =~ /^\w+$/
defined $param $param =~ /^\w+$/
Truth table33%1/3
A and B
A= defined $paramB= $param =~ /^\w+$/
ABresult
0X0
100
111
6195  
6196 # ref() check for CODE, for a plain variable or a named argument
6197 510 ▶ if ($code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i or $code =~ /ref\s*\(\s*\$args\{\s*['"]?${param}['"]?\s*\}\s*\)\s*eq\s*['"]CODE['"]/i) 1 509 510
Condition66%2/3
$code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i or $code =~ /ref\s*\(\s*\$args\{\s*['"]?${param}['"]?\s*\}\s*\)\s*eq\s*['"]CODE['"]/i
l!l&&r!l&&!r
10509
MC/DC50%1/2
$code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i or $code =~ /ref\s*\(\s*\$args\{\s*['"]?${param}['"]?\s*\}\s*\)\s*eq\s*['"]CODE['"]/i
$code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i $code =~ /ref\s*\(\s*\$args\{\s*['"]?${param}['"]?\s*\}\s*\)\s*eq\s*['"]CODE['"]/i
Truth table66%2/3
A or B
A= $code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/iB= $code =~ /ref\s*\(\s*\$args\{\s*['"]?${param}['"]?\s*\}\s*\)\s*eq\s*['"]CODE['"]/i
ABresult
1X1
011
000
6198 || $code =~ /ref\s*\(\s*\$args\{\s*['"]?$param['"]?\s*\}\s*\)\s*eq\s*['"]CODE['"]/i) {
6199 1 $p->{type} = 'coderef';
6200 1 $p->{semantic} = 'callback';
6201 1 $self->_log(" ADVANCED: $param is coderef (ref check)");
6202 1 return;
6203 }
6204  
6205 # Invocation as coderef - note the escaped @ in \@_
6206 509 ▶ if ($code =~ /\$$param\s*->\s*\(/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*->\s*\(/ or $code =~ /\$$param\s*->\s*\(\s*\@_\s*\)/ or $code =~ /&\s*\{\s*\$$param\s*\}/) 2 507 509
Condition66%4/6
$code =~ /\$$param\s*->\s*\(/ or $code =~ /\$$param\s*->\s*\(\s*\@_\s*\)/ or $code =~ /&\s*\{\s*\$$param\s*\}/
l!l&&r!l&&!r
20507
$code =~ /\$$param\s*->\s*\(/ or $code =~ /\$$param\s*->\s*\(\s*\@_\s*\)/
l!l&&r!l&&!r
20507
MC/DC33%1/3
$code =~ /\$$param\s*->\s*\(/ or $code =~ /\$$param\s*->\s*\(\s*\@_\s*\)/ or $code =~ /&\s*\{\s*\$$param\s*\}/
$code =~ /\$$param\s*->\s*\(/ $code =~ /\$$param\s*->\s*\(\s*\@_\s*\)/ $code =~ /&\s*\{\s*\$$param\s*\}/
Truth table50%2/4
A or B or C
A= $code =~ /\$$param\s*->\s*\(/B= $code =~ /\$$param\s*->\s*\(\s*\@_\s*\)/C= $code =~ /&\s*\{\s*\$$param\s*\}/
ABCresult
1XX1
01X1
0011
0000
6207 $code =~ /\$$param\s*->\s*\(\s*\@_\s*\)/ ||
6208 $code =~ /&\s*\{\s*\$$param\s*\}/) {
6209 2 $p->{type} = 'coderef';
6210 2 $p->{semantic} = 'callback';
6211 2 $self->_log(" ADVANCED: $param invoked as coderef");
6212 2 return;
6213 }
6214  
6215 # Parameter name suggests callback
6216 507 ▶ if ($param =~ /^(?:callback|cb|handler|sub|code|fn|func|on_\w+)$/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param =~ /^(?:callback|cb|handler|sub|code|fn|func|on_\w+)$/i) 3 504 507
6217 3 $p->{type} = 'coderef';
6218 3 $p->{semantic} = 'callback';
6219 3 $self->_log(" ADVANCED: $param name suggests coderef");
6220 3 return;
6221 }
6222  
6223 # Blessed coderef (unusual but valid)
6224 504 ▶ if ($code =~ /blessed\s*\(\s*\$$param\s*\)/ &&
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /blessed\s*\(\s*\$$param\s*\)/ and $code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i) 0 504 504
Condition66%2/3
$code =~ /blessed\s*\(\s*\$$param\s*\)/ and $code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i
!ll&&!rl&&r
50130
MC/DC0%0/2
$code =~ /blessed\s*\(\s*\$$param\s*\)/ and $code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i
$code =~ /blessed\s*\(\s*\$$param\s*\)/ $code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i
Truth table66%2/3
A and B
A= $code =~ /blessed\s*\(\s*\$$param\s*\)/B= $code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i
ABresult
0X0
100
111
6225 $code =~ /ref\s*\(\s*\$$param\s*\)\s*eq\s*['"]CODE['"]/i) {
6226 0 $p->{type} = 'object';
6227 0 $p->{isa} = 'blessed_coderef';
6228 0 $p->{semantic} = 'callback';
6229 0 $self->_log(" ADVANCED: $param is blessed coderef");
6230 0 return;
6231 }
6232 }
6233  
6234 # --------------------------------------------------
6235 # _detect_enum_type
6236 #
6237 # Purpose: Detect enum-like parameters whose
6238 # valid values are a fixed set, by
6239 # analysing validation patterns
6240 # including regex alternations, hash
6241 # lookups, grep checks, given/when,
6242 # if/elsif chains, and smart match.
6243 #
6244 # Entry: $p - parameter hashref (modified
6245 # in place).
6246 # $param - parameter name string.
6247 # $code - method body source string.
6248 #
6249 # Exit: Returns nothing. Modifies $p in place,
6250 # setting type, enum, and semantic keys.
6251 # Returns immediately on first match.
6252 #
6253 # Side effects: Logs detections to stdout when
6254 # verbose is set.
6255 #
6256 # Notes: Requires at least 3 if/elsif branches
6257 # for pattern 5 to avoid false positives
6258 # from ordinary conditional code.
6259 # --------------------------------------------------
6260 510 ▶sub _detect_enum_type {
Subroutine _detect_enum_type: called CC=24 SCAR=36.1
6261 510 my ($self, $p, $param, $code) = @_;
6262  
6263 510 ▶ return unless defined $param && $param =~ /^\w+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $param and $param =~ /^\w+$/ 0 510 510
Condition33%1/3
defined $param and $param =~ /^\w+$/
!ll&&!rl&&r
00510
MC/DC0%0/2
defined $param and $param =~ /^\w+$/
defined $param $param =~ /^\w+$/
Truth table33%1/3
A and B
A= defined $paramB= $param =~ /^\w+$/
ABresult
0X0
100
111
6264  
6265 # Pattern 1: die/croak unless value is in list
6266 # die 'Invalid status' unless $status =~ /^(active|inactive|pending)$/;
6267 510 ▶ if ($code =~ /unless\s+\$$param\s*=~\s*\/\^?\(([^)]+)\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ m[unless\s+\$$param\s*=~\s*/\^?\(([^)]+)\)]) 6 504 510
6268 6 my $values = $1;
6269 6 my @enum_values = split(/\|/, $values);
6270 6 ▶ $p->{type} = 'string' unless $p->{type};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"type"} 2 4 6
6271 6 $p->{enum} = \@enum_values;
6272 6 $p->{semantic} = 'enum';
6273 6 $self->_log(" ADVANCED: $param is enum with values: " . join(', ', @enum_values));
6274 6 return;
6275 }
6276  
6277 # Pattern 2: Hash lookup for validation
6278 # my %valid = map { $_ => 1 } qw(red green blue);
6279 # die unless $valid{$param};
6280 504 ▶ if ($code =~ /\%(\w+)\s*=.*?qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\%(\w+)\s*=.*?qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/) 1 503 504
6281 1 my $hash_name = $1;
6282 1 my $values_str = $2;
6283 1 ▶ if (defined $values_str && $code =~ /\$$hash_name\s*\{\s*\$$param\s*\}/) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $values_str and $code =~ /\$$hash_name\s*\{\s*\$$param\s*\}/) 1 0 1
Condition33%1/3
defined $values_str and $code =~ /\$$hash_name\s*\{\s*\$$param\s*\}/
!ll&&!rl&&r
001
MC/DC0%0/2
defined $values_str and $code =~ /\$$hash_name\s*\{\s*\$$param\s*\}/
defined $values_str $code =~ /\$$hash_name\s*\{\s*\$$param\s*\}/
Truth table33%1/3
A and B
A= defined $values_strB= $code =~ /\$$hash_name\s*\{\s*\$$param\s*\}/
ABresult
0X0
100
111
6284 1 my @enum_values = split(/\s+/, $values_str);
6285 1 ▶ $p->{type} = 'string' unless $p->{type};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"type"} 1 0 1
6286 1 $p->{enum} = \@enum_values;
6287 1 $p->{semantic} = 'enum';
6288 1 $self->_log(" ADVANCED: $param validated via hash lookup: " . join(', ', @enum_values));
6289 1 return;
6290 }
6291 }
6292  
6293 # Pattern 3: Array grep validation
6294 # die unless grep { $_ eq $param } qw(foo bar baz);
6295 503 ▶ if ($code =~ /grep\s*\{[^}]*\$$param[^}]*\}\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /grep\s*\{[^}]*\$${param}[^}]*\}\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/) 1 502 503
6296 1 my $values_str = $1;
6297 1 my @enum_values = split(/\s+/, $values_str);
6298 1 ▶ $p->{type} = 'string' unless $p->{type};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"type"} 1 0 1
6299 1 $p->{enum} = \@enum_values;
6300 1 $p->{semantic} = 'enum';
6301 1 $self->_log(" ADVANCED: $param validated via grep: " . join(', ', @enum_values));
6302 1 return;
6303 }
6304  
6305 # Pattern 4: Given/when (Perl 5.10+)
6306 502 ▶ if ($code =~ /given\s*\(\s*\$$param\s*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /given\s*\(\s*\$$param\s*\)/) 1 501 502
6307 1 my @enum_values;
6308 1 ▶ while ($code =~ /when\s*\(\s*['"]([^'"]+)['"]\s*\)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /when\s*\(\s*['"]([^'"]+)['"]\s*\)/g) 2 1 3
6309 2 push @enum_values, $1;
6310 }
6311 1 ▶ if (@enum_values >= 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (@enum_values >= 2) 1 0 1
6312 1 ▶ $p->{type} = 'string' unless $p->{type};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"type"} 1 0 1
6313 1 $p->{enum} = \@enum_values;
6314 1 $p->{semantic} = 'enum';
6315 1 $self->_log(" ADVANCED: $param has enum values from given/when: " .
6316 join(', ', @enum_values));
6317 1 return;
6318 }
6319 }
6320  
6321 # Pattern 5: Multiple if/elsif checking specific values
6322 501 my @if_values;
6323 501 ▶ while ($code =~ /if\s*\(\s*\$$param\s*eq\s*['"]([^'"]+)['"]\s*\)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /if\s*\(\s*\$$param\s*eq\s*['"]([^'"]+)['"]\s*\)/g) 7 501 508
6324 7 push @if_values, $1;
6325 }
6326 501 ▶ while ($code =~ /elsif\s*\(\s*\$$param\s*eq\s*['"]([^'"]+)['"]\s*\)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /elsif\s*\(\s*\$$param\s*eq\s*['"]([^'"]+)['"]\s*\)/g) 5 501 506
6327 5 push @if_values, $1;
6328 }
6329 501 ▶ if (@if_values >= 3) {
Branch: 1 branch
BranchTrueFalseTotal
if (@if_values >= 3) 2 499 501
6330 2 ▶ $p->{type} = 'string' unless $p->{type};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"type"} 2 0 2
6331 2 $p->{enum} = \@if_values;
6332 2 $p->{semantic} = 'enum';
6333 2 $self->_log(" ADVANCED: $param appears to be enum from if/elsif: " .
6334 join(', ', @if_values));
6335 2 return;
6336 }
6337  
6338 # Pattern 6: Smart match (~~) with array
6339 499 ▶ if ($code =~ /\$$param\s*~~\s*\[([^\]]+)\]/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$$param\s*~~\s*\[([^\]]+)\]/ or $code =~ /\$$param\s*~~\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/) 0 499 499
Condition33%1/3
$code =~ /\$$param\s*~~\s*\[([^\]]+)\]/ or $code =~ /\$$param\s*~~\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/
l!l&&r!l&&!r
00499
MC/DC0%0/2
$code =~ /\$$param\s*~~\s*\[([^\]]+)\]/ or $code =~ /\$$param\s*~~\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/
$code =~ /\$$param\s*~~\s*\[([^\]]+)\]/ $code =~ /\$$param\s*~~\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/
Truth table33%1/3
A or B
A= $code =~ /\$$param\s*~~\s*\[([^\]]+)\]/B= $code =~ /\$$param\s*~~\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/
ABresult
1X1
011
000
6340 $code =~ /\$$param\s*~~\s*qw\s*[\(\[<{]([^)\]>}]+)[\)\]>}]/) {
6341 0 my $values_str = $1;
6342 0 my @enum_values;
6343 0 ▶ if ($values_str =~ /['"]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($values_str =~ /['"]/) { } 0 0 0
6344 0 @enum_values = $values_str =~ /['"](.*?)['"]/g;
6345 } else {
6346 0 @enum_values = split(/\s+/, $values_str);
6347 }
6348 0 ▶ if (@enum_values) {
Branch: 1 branch
BranchTrueFalseTotal
if (@enum_values) 0 0 0
6349 0 ▶ $p->{type} = 'string' unless $p->{type};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"type"} 0 0 0
6350 0 $p->{enum} = \@enum_values;
6351 0 $p->{semantic} = 'enum';
6352 0 $self->_log(" ADVANCED: $param validated with smart match: " .
6353 join(', ', @enum_values));
6354 0 return;
6355 }
6356 }
6357 }
6358  
6359 # --------------------------------------------------
6360 # _extract_error_constraints
6361 #
6362 # Purpose: Extract invalid-value constraints and
6363 # error messages from die/croak patterns
6364 # referencing a specific parameter, and
6365 # infer numeric bounds from comparisons
6366 # with literals.
6367 #
6368 # Entry: $p_ref - reference to the parameter
6369 # hashref (modified in place).
6370 # $param - parameter name string.
6371 # $code - method body source string.
6372 #
6373 # Exit: Returns nothing. May add _invalid,
6374 # _errors, min, and/or max to the
6375 # referenced parameter hashref.
6376 #
6377 # Side effects: Logs detections to stdout when
6378 # verbose is set.
6379 # --------------------------------------------------
6380 510 ▶sub _extract_error_constraints {
Subroutine _extract_error_constraints: called CC=17 SCAR=28.4
6381 510 my ($self, $p, $param, $code) = @_;
6382  
6383 # Look for die/croak/confess with a condition involving this param
6384 510 ▶ while ($code =~ /
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ / (?:die|croak|confess) # error call \s* (?: ["']([^"']+)["'] # captured error message | q[qw]?\s*[\(\[]([^)\]]+)[\)\]] # q(), qq(), qw() )? \s* if\s+ (.+?) # condition \s*; /gsx) 64 510 574
6385 (?:die|croak|confess) # error call
6386 \s*
6387 (?:
6388 ["']([^"']+)["'] # captured error message
6389 |
6390 q[qw]?\s*[\(\[]([^)\]]+)[\)\]] # q(), qq(), qw()
6391 )?
6392 \s*
6393 if\s+
6394 (.+?) # condition
6395 \s*;
6396 /gsx) {
6397  
6398 64 ▶ my $message = $1 || $2;
Condition66%2/3
$1 || $2
l!l&&r!l&&!r
53011
MC/DC50%1/2
$1 || $2
$1 $2
Truth table66%2/3
A || B
A= $1B= $2
ABresult
1X1
011
000
6399 64 my $condition = $3;
6400  
6401 # Only keep conditions that reference this parameter
6402 64 ▶ next unless $condition =~ /\$$param\b/;
Branch: 1 branch
BranchTrueFalseTotal
unless $condition =~ /\$$param\b/ 25 39 64
6403  
6404 # Initialize storage
6405 39 ▶ $$p->{_invalid} ||= [];
Condition100%2/2
$$p->{"_invalid"} ||= []
l!l
138
MC/DC100%1/1
$$p->{"_invalid"} ||= []
$$p->{"_invalid"}
Truth table100%2/2
A
A= $$p->{"_invalid"}
Aresult
11
00
6406 39 ▶ $$p->{_errors} ||= [];
Condition100%2/2
$$p->{"_errors"} ||= []
l!l
138
MC/DC100%1/1
$$p->{"_errors"} ||= []
$$p->{"_errors"}
Truth table100%2/2
A
A= $$p->{"_errors"}
Aresult
11
00
6407  
6408 # Normalize condition (strip surrounding parens)
6409 39 $condition =~ s/^\(|\)$//g;
6410 39 $condition =~ s/\s+/ /g;
6411  
6412 # Try to extract a meaningful invalid constraint
6413 39 my $constraint;
6414  
6415 # Examples:
6416 # $age <= 0
6417 # $x eq ''
6418 # length($s) < 3
6419 39 ▶ if ($condition =~ /\$$param\s*([!<>=]=?|eq|ne|lt|gt|le|ge)\s*(.+)/) {
Branch: 3 branches
BranchTrueFalseTotal
if ($condition =~ /\$$param\s*([!<>=]=?|eq|ne|lt|gt|le|ge)\s*(.+)/) { } 7 32 39
elsif ($condition =~ /length\s*\(\s*\$$param\s*\)\s*([<>=!]+)\s*(\d+)/) { } 4 28 32
elsif ($condition =~ /\$$param\s*==\s*0/) { } 0 28 28
6420 7 $constraint = "$1 $2";
6421 }
6422 elsif ($condition =~ /length\s*\(\s*\$$param\s*\)\s*([<>=!]+)\s*(\d+)/) {
6423 4 $constraint = "length $1 $2";
6424 }
6425 elsif ($condition =~ /\$$param\s*==\s*0/) {
6426 0 $constraint = '== 0';
6427 }
6428  
6429 # Store results
6430 39 ▶ push @{ $$p->{_invalid} }, $constraint if $constraint;
Branch: 1 branch
BranchTrueFalseTotal
if $constraint 11 28 39
6431 39 ▶ push @{ $$p->{_errors} }, $message if defined $message;
Branch: 1 branch
BranchTrueFalseTotal
if defined $message 34 5 39
6432  
6433 39 ▶ $self->_log(
Branch: 1 branch
BranchTrueFalseTotal
defined $message ? : 34 5 39
6434 " ERROR: $param invalid when [$condition]" .
6435 (defined $message ? " => '$message'" : '')
6436 );
6437 }
6438  
6439 # Numeric comparison with literal
6440 510 ▶ if ($code =~ /\b\Q$param\E\s*(<=|<|>=|>)\s*(-?\d+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\b\Q$param\E\s*(<=|<|>=|>)\s*(-?\d+)/) 21 489 510
6441 21 my ($op, $num) = ($1, $2);
6442  
6443 # Mark required
6444 21 $$p->{optional} = 0;
6445  
6446 21 ▶ if ($op eq '<=') {
Branch: 4 branches
BranchTrueFalseTotal
if ($op eq '<=') { } 1 20 21
elsif ($op eq '<') { } 5 15 20
elsif ($op eq '>=') { } 2 13 15
elsif ($op eq '>') { } 13 0 13
6447 1 $$p->{min} = $num + 1;
6448 } elsif ($op eq '<') {
6449 5 $$p->{min} = $num;
6450 } elsif ($op eq '>=') {
6451 2 $$p->{max} = $num - 1;
6452 } elsif ($op eq '>') {
6453 13 $$p->{max} = $num;
6454 }
6455  
6456 21 $self->_log(" ERROR: $param normalized constraint from '$op $num'");
6457 }
6458 }
6459  
6460 # --------------------------------------------------
6461 # _extract_parameters_from_signature
6462 #
6463 # Purpose: Extract parameter names and positions
6464 # from a method's signature, trying
6465 # modern Perl subroutine signatures
6466 # first and falling back to traditional
6467 # @_ extraction styles.
6468 #
6469 # Entry: $params - hashref to populate with
6470 # parameter specs (modified
6471 # in place).
6472 # $code - method body source string.
6473 #
6474 # Exit: Returns nothing. Populates $params.
6475 #
6476 # Side effects: Logs detections to stdout when
6477 # verbose is set.
6478 #
6479 # Notes: Three traditional styles are
6480 # supported: (1) my ($self, ...) = @_,
6481 # (2) my $self = shift; my $x = shift,
6482 # (3) my $x = $_[N]. $self and $class
6483 # are always excluded from the returned
6484 # parameters.
6485 # --------------------------------------------------
6486 1534 ▶sub _extract_parameters_from_signature {
Subroutine _extract_parameters_from_signature: called CC=24 SCAR=35.7
6487 1534 my ($self, $params, $code) = @_;
6488  
6489 # Modern Style: Subroutine signatures with attributes
6490 # Handle multi-line signatures
6491 # sub foo :attr1 :attr2(val) (
6492 # $self,
6493 # $x :Type,
6494 # $y = default
6495 # ) { }
6496  
6497 # Try to match signature after attributes
6498 # Look for the parameter list - it's the last (...) before the opening brace
6499 # that contains sigils ($, %, @)
6500 1534 ▶ if ($code =~ /sub\s+\w+\s*(?::\w+(?:\([^)]*\))?\s*)*\(((?:[^()]|\([^)]*\))*)\)\s*\{/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /sub\s+\w+\s*(?::\w+(?:\([^)]*\))?\s*)*\(((?:[^()]|\([^)]*\))*)\)\s*\{/s) 6 1528 1534
6501 6 my $potential_sig = $1;
6502  
6503 # Check if this looks like parameters (has sigils)
6504 6 ▶ if ($potential_sig =~ /[\$\%\@]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($potential_sig =~ /[\$\%\@]/) 6 0 6
6505 6 $self->_log(" SIG: Found modern signature: ($potential_sig)");
6506 6 $self->_parse_modern_signature($params, $potential_sig);
6507 6 return;
6508 }
6509 }
6510  
6511 # Direct-index style: my $self = $_[0]; my $arg = $_[1]; ...
6512 # Must be checked before Style 1 to avoid matching @_ inside closures
6513 # defined in the body of a method that uses this style.
6514 1528 ▶ if($code =~ /my\s+\$(?:self|class)\s*=\s*\$_\[0\]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s+\$(?:self|class)\s*=\s*\$_\[0\]/) 138 1390 1528
6515 138 my $pos = 0;
6516 138 ▶ while($code =~ /my\s+\$(\w+)\s*=\s*\$_\[(\d+)\]/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s+\$(\w+)\s*=\s*\$_\[(\d+)\]/g) 140 138 278
6517 140 my $name = $1;
6518 140 ▶ next if $name =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass)$/i 138 2 140
6519 2 ▶ $params->{$name} //= { _source => SOURCE_CODE, optional => 1, position => $pos++ };
Condition50%1/2
$params->{$name} //= {"_source", "code", "optional", 1, "position", $pos++}
l!l
02
MC/DC0%0/1
$params->{$name} //= {"_source", "code", "optional", 1, "position", $pos++}
$params->{$name}
Truth table50%1/2
A
A= $params->{$name}
Aresult
11
00
6520 2 $self->_log(" CODE: Found direct-index parameter '\$$name' at \$_[$2]");
6521 }
6522 138 return;
6523 }
6524  
6525 # Traditional Style 1: my ($self, $arg1, $arg2) = @_;
6526 1390 ▶ if ($code =~ /my\s*\(\s*([^)]+)\)\s*=\s*\@_/s) {
Branch: 2 branches
BranchTrueFalseTotal
if ($code =~ /my\s*\(\s*([^)]+)\)\s*=\s*\@_/s) { } 794 596 1390
elsif ($code =~ /my\s+\$self\s*=\s*shift/) { } 56 540 596
6527 794 my $sig = $1;
6528 794 my $pos = 0;
6529  
6530 794 ▶ while ($sig =~ /\$(\w+)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($sig =~ /\$(\w+)/g) 1552 794 2346
6531 1552 my $name = $1;
6532  
6533 1552 ▶ next if $name =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^(self|class|pkg|proto|klass)$/i 716 836 1552
6534  
6535 836 ▶ $params->{$name} //= {
Condition50%1/2
$params->{$name} //= {"_source", "code", "optional", 1}
l!l
0836
MC/DC0%0/1
$params->{$name} //= {"_source", "code", "optional", 1}
$params->{$name}
Truth table50%1/2
A
A= $params->{$name}
Aresult
11
00
6536 _source => SOURCE_CODE,
6537 optional => 1,
6538 };
6539  
6540 836 ▶ $params->{$name}{position} = $pos unless exists $params->{$name}{position};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$name}{"position"} 836 0 836
6541  
6542 836 $pos++;
6543 }
6544 794 return;
6545 } elsif ($code =~ /my\s+\$self\s*=\s*shift/) {
6546 # Traditional Style 2: my $self = shift; my $arg1 = shift;
6547 56 my @shifts;
6548 56 ▶ while ($code =~ /my\s+\$(\w+)\s*=\s*shift/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s+\$(\w+)\s*=\s*shift/g) 66 56 122
6549 66 push @shifts, $1;
6550 }
6551 56 ▶ shift @shifts if @shifts && $shifts[0] =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if @shifts and $shifts[0] =~ /^(self|class|pkg|proto|klass)$/i 56 0 56
Condition33%1/3
@shifts and $shifts[0] =~ /^(self|class|pkg|proto|klass)$/i
!ll&&!rl&&r
0056
MC/DC0%0/2
@shifts and $shifts[0] =~ /^(self|class|pkg|proto|klass)$/i
@shifts $shifts[0] =~ /^(self|class|pkg|proto|klass)$/i
Truth table33%1/3
A and B
A= @shiftsB= $shifts[0] =~ /^(self|class|pkg|proto|klass)$/i
ABresult
0X0
100
111
6552 56 my $pos = 0;
6553 56 foreach my $param (@shifts) {
6554 10 ▶ $params->{$param} ||= { _source => SOURCE_CODE, optional => 1, position => $pos++ };
Condition50%1/2
$params->{$param} ||= {"_source", "code", "optional", 1, "position", $pos++}
l!l
010
MC/DC0%0/1
$params->{$param} ||= {"_source", "code", "optional", 1, "position", $pos++}
$params->{$param}
Truth table50%1/2
A
A= $params->{$param}
Aresult
11
00
6555 }
6556 56 return;
6557 }
6558  
6559 # Traditional Style 3: Function parameters (no $self)
6560 540 ▶ if ($code =~ /my\s*\(\s*([^)]+)\)\s*=\s*\@_/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s*\(\s*([^)]+)\)\s*=\s*\@_/s) 0 540 540
6561 0 my $sig = $1;
6562 0 my @param_names = $sig =~ /\$(\w+)/g;
6563 0 my $pos = 0;
6564 0 foreach my $param (@param_names) {
6565 0 ▶ next if $param =~ /^(self|class|pkg|proto|klass)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $param =~ /^(self|class|pkg|proto|klass)$/i 0 0 0
6566 0 ▶ $params->{$param} ||= { _source => SOURCE_CODE, optional => 1, position => $pos++ };
Condition0%0/2
$params->{$param} ||= {"_source", "code", "optional", 1, "position", $pos++}
l!l
00
MC/DC0%0/1
$params->{$param} ||= {"_source", "code", "optional", 1, "position", $pos++}
$params->{$param}
Truth table0%0/2
A
A= $params->{$param}
Aresult
11
00
6567 }
6568 }
6569  
6570 # De-duplicate
6571 540 my %seen;
6572 540 foreach my $param (keys %$params) {
6573 0 ▶ if ($seen{$param}++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($seen{$param}++) 0 0 0
6574 0 $self->_log(" WARNING: Duplicate parameter '$param' found");
6575 }
6576 }
6577 }
6578  
6579 # --------------------------------------------------
6580 # _parse_modern_signature
6581 #
6582 # Purpose: Parse a Perl 5.20+ subroutine
6583 # signature string into individual
6584 # parameter specs, respecting nested
6585 # structures when splitting on commas.
6586 #
6587 # Entry: $params - hashref to populate
6588 # (modified in place).
6589 # $sig - signature string with outer
6590 # parentheses already removed.
6591 #
6592 # Exit: Returns nothing. Populates $params
6593 # via _parse_signature_parameter.
6594 #
6595 # Side effects: Logs parsing details to stdout when
6596 # verbose is set.
6597 # --------------------------------------------------
6598 8 ▶sub _parse_modern_signature {
Subroutine _parse_modern_signature: called CC=12 SCAR=24.9
6599 8 my ($self, $params, $sig) = @_;
6600  
6601 8 $self->_log(" DEBUG: Parsing signature: [$sig]");
6602  
6603 # Split signature by commas, but respect nested structures (e.g. a
6604 # default value containing a hashref/arrayref literal)
6605 8 require Text::Balanced;
6606 8 my @parts;
6607 8 my $current = '';
6608 8 my $rest = $sig;
6609  
6610 8 ▶ while (length $rest) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $rest) 173 8 181
6611 173 ▶ if (substr($rest, 0, 1) =~ /[(\[{]/) {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($rest, 0, 1) =~ /[(\[{]/) 1 172 173
6612 # extract_bracketed advances $rest past the extracted block
6613 # in place, so $rest must not be re-truncated afterwards
6614 1 my $extracted = Text::Balanced::extract_bracketed($rest, '(){}[]');
6615 1 ▶ last unless defined $extracted; # Unbalanced brackets
Branch: 1 branch
BranchTrueFalseTotal
unless defined $extracted 0 1 1
6616 1 $current .= $extracted;
6617 1 next;
6618 }
6619 172 ▶ if (substr($rest, 0, 1) eq ',') {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($rest, 0, 1) eq ",") 15 157 172
6620 15 push @parts, $current;
6621 15 $current = '';
6622 15 $rest = substr($rest, 1);
6623 15 next;
6624 }
6625 157 $current .= substr($rest, 0, 1);
6626 157 $rest = substr($rest, 1);
6627 }
6628 8 ▶ push @parts, $current if $current =~ /\S/;
Branch: 1 branch
BranchTrueFalseTotal
if $current =~ /\S/ 8 0 8
6629  
6630 8 my $position = 0;
6631  
6632 8 foreach my $part (@parts) {
6633 23 $part =~ s/^\s+|\s+$//g;
6634  
6635 # Skip empty parts
6636 23 ▶ next unless $part;
Branch: 1 branch
BranchTrueFalseTotal
unless $part 0 23 23
6637  
6638 # Parse different parameter types
6639 23 my $param_info = $self->_parse_signature_parameter($part, $position);
6640  
6641 23 ▶ if ($param_info) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param_info) 23 0 23
6642 23 my $name = $param_info->{name};
6643  
6644 # Skip self/class
6645 23 ▶ if ($name =~ /^(self|class|pkg|proto|klass)$/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($name =~ /^(self|class|pkg|proto|klass)$/i) 8 15 23
6646 8 next;
6647 }
6648  
6649 15 $params->{$name} = $param_info;
6650 $self->_log(" SIG: $name has position $position" .
6651 ($param_info->{optional} ? ' (optional)' : '') .
6652 15 ▶ ($param_info->{_default} ? ", default: $param_info->{_default}" : ''));
Branch: 2 branches
BranchTrueFalseTotal
$param_info->{'optional'} ? : 1 14 15
$param_info->{'_default'} ? : 1 14 15
6653 15 $position++;
6654 }
6655 }
6656 }
6657  
6658 # --------------------------------------------------
6659 # _parse_signature_parameter
6660 #
6661 # Purpose: Parse a single parameter declaration
6662 # from a modern Perl signature, handling
6663 # type constraints, default values,
6664 # plain scalars, and slurpy array/hash
6665 # parameters.
6666 #
6667 # Entry: $part - a single parameter string
6668 # (one comma-separated
6669 # element from the signature).
6670 # $position - zero-based position index
6671 # of this parameter.
6672 #
6673 # Exit: Returns a parameter info hashref on
6674 # success, or undef if the string does
6675 # not match any known pattern.
6676 #
6677 # Side effects: None.
6678 #
6679 # Notes: Six patterns are tried in order:
6680 # (1) :Type with default,
6681 # (2) :Type without default,
6682 # (3) default without type,
6683 # (4) plain $name,
6684 # (5) slurpy @name,
6685 # (6) slurpy %name.
6686 # --------------------------------------------------
6687 30 ▶sub _parse_signature_parameter {
Subroutine _parse_signature_parameter: called CC=20 SCAR=38.2
6688 30 my ($self, $part, $position) = @_;
6689  
6690 30 my %info = (
6691 _source => SOURCE_SIGNATURE,
6692 position => $position,
6693 optional => 0,
6694 );
6695  
6696 # Pattern 1: Type constraint WITH default: $name :Type = default
6697 30 ▶ if ($part =~ /^\$(\w+)\s*:\s*(\w+)\s*=\s*(.+)$/s) {
Branch: 6 branches
BranchTrueFalseTotal
if ($part =~ /^\$(\w+)\s*:\s*(\w+)\s*=\s*(.+)$/s) { } 1 29 30
elsif ($part =~ /^\$(\w+)\s*:\s*(\w+)\s*$/s) { } 1 28 29
elsif ($part =~ /^\$(\w+)\s*=\s*(.+)$/s) { } 2 26 28
elsif ($part =~ /^\$(\w+)$/s) { } 23 3 26
elsif ($part =~ /^\@(\w+)$/s) { } 1 2 3
elsif ($part =~ /^\%(\w+)$/s) { } 1 1 2
6698 1 my ($name, $constraint, $default) = ($1, $2, $3);
6699 1 $default =~ s/^\s+|\s+$//g;
6700  
6701 1 $info{name} = $name;
6702 1 $info{optional} = 1;
6703 1 $info{_default} = $self->_clean_default_value($default, 1);
6704  
6705 # Apply type constraint
6706 1 ▶ if ($constraint =~ /^(Int|Integer)$/i) {
Branch: 6 branches
BranchTrueFalseTotal
if ($constraint =~ /^(Int|Integer)$/i) { } 0 1 1
elsif ($constraint =~ /^(Num|Number)$/i) { } 1 0 1
elsif ($constraint =~ /^(Str|String)$/i) { } 0 0 0
elsif ($constraint =~ /^(Bool|Boolean)$/i) { } 0 0 0
elsif ($constraint =~ /^(Array|ArrayRef)$/i) { } 0 0 0
elsif ($constraint =~ /^(Hash|HashRef)$/i) { } 0 0 0
6707 0 $info{type} = 'integer';
6708 } elsif ($constraint =~ /^(Num|Number)$/i) {
6709 1 $info{type} = 'number';
6710 } elsif ($constraint =~ /^(Str|String)$/i) {
6711 0 $info{type} = 'string';
6712 } elsif ($constraint =~ /^(Bool|Boolean)$/i) {
6713 0 $info{type} = 'boolean';
6714 } elsif ($constraint =~ /^(Array|ArrayRef)$/i) {
6715 0 $info{type} = 'arrayref';
6716 } elsif ($constraint =~ /^(Hash|HashRef)$/i) {
6717 0 $info{type} = 'hashref';
6718 } else {
6719 0 $info{type} = 'object';
6720 0 $info{isa} = $constraint;
6721 }
6722  
6723 1 return \%info;
6724 } elsif ($part =~ /^\$(\w+)\s*:\s*(\w+)\s*$/s) {
6725 # Pattern 2: Type constraint WITHOUT default: $name :Type
6726 1 my ($name, $constraint) = ($1, $2);
6727 1 $info{name} = $name;
6728 1 $info{optional} = 0;
6729  
6730 # Apply type constraint (same as above)
6731 1 ▶ if ($constraint =~ /^(Int|Integer)$/i) {
Branch: 6 branches
BranchTrueFalseTotal
if ($constraint =~ /^(Int|Integer)$/i) { } 1 0 1
elsif ($constraint =~ /^(Num|Number)$/i) { } 0 0 0
elsif ($constraint =~ /^(Str|String)$/i) { } 0 0 0
elsif ($constraint =~ /^(Bool|Boolean)$/i) { } 0 0 0
elsif ($constraint =~ /^(Array|ArrayRef)$/i) { } 0 0 0
elsif ($constraint =~ /^(Hash|HashRef)$/i) { } 0 0 0
6732 1 $info{type} = 'integer';
6733 } elsif ($constraint =~ /^(Num|Number)$/i) {
6734 0 $info{type} = 'number';
6735 } elsif ($constraint =~ /^(Str|String)$/i) {
6736 0 $info{type} = 'string';
6737 } elsif ($constraint =~ /^(Bool|Boolean)$/i) {
6738 0 $info{type} = 'boolean';
6739 } elsif ($constraint =~ /^(Array|ArrayRef)$/i) {
6740 0 $info{type} = 'arrayref';
6741 } elsif ($constraint =~ /^(Hash|HashRef)$/i) {
6742 0 $info{type} = 'hashref';
6743 } else {
6744 0 $info{type} = 'object';
6745 0 $info{isa} = $constraint;
6746 }
6747  
6748 1 return \%info;
6749 } elsif ($part =~ /^\$(\w+)\s*=\s*(.+)$/s) {
6750 # Pattern 3: Default WITHOUT type: $name = default
6751 2 my ($name, $default) = ($1, $2);
6752 2 $default =~ s/^\s+|\s+$//g;
6753  
6754 2 $info{name} = $name;
6755 2 $info{optional} = 1;
6756 2 $info{_default} = $self->_clean_default_value($default, 1);
6757 2 ▶ $info{type} = $self->_infer_type_from_default($info{_default}) if $self->can('_infer_type_from_default');
Branch: 1 branch
BranchTrueFalseTotal
if $self->can("_infer_type_from_default") 2 0 2
6758  
6759 2 return \%info;
6760 }
6761  
6762 # Pattern 4: Plain parameter: $name
6763 elsif ($part =~ /^\$(\w+)$/s) {
6764 23 $info{name} = $1;
6765 23 $info{optional} = 0;
6766 23 return \%info;
6767 }
6768  
6769 # Pattern 5: Array parameter: @name
6770 elsif ($part =~ /^\@(\w+)$/s) {
6771 1 $info{name} = $1;
6772 1 $info{type} = 'array';
6773 1 $info{slurpy} = 1;
6774 1 $info{optional} = 1;
6775 1 return \%info;
6776 }
6777  
6778 # Pattern 6: Hash parameter: %name
6779 elsif ($part =~ /^\%(\w+)$/s) {
6780 1 $info{name} = $1;
6781 1 $info{type} = 'hash';
6782 1 $info{slurpy} = 1;
6783 1 $info{optional} = 1;
6784 1 return \%info;
6785 }
6786  
6787 1 return undef;
6788 }
6789  
6790 # --------------------------------------------------
6791 # _infer_type_from_default
6792 #
6793 # Purpose: Infer a parameter type from its
6794 # default value when no explicit type
6795 # annotation is available.
6796 #
6797 # Entry: $default - the cleaned default value
6798 # scalar, hashref, or
6799 # arrayref. May be undef.
6800 #
6801 # Exit: Returns a type string ('hashref',
6802 # 'arrayref', 'integer', 'number',
6803 # 'boolean', 'string'), or undef if
6804 # $default is undef.
6805 #
6806 # Side effects: None.
6807 # --------------------------------------------------
6808 11 ▶sub _infer_type_from_default {
Subroutine _infer_type_from_default: called CC=8 SCAR=21.2
6809 11 my ($self, $default) = @_;
6810  
6811 11 ▶ return undef unless defined $default;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $default 1 10 11
6812  
6813 10 ▶ if (ref($default) eq 'HASH') {
Branch: 5 branches
BranchTrueFalseTotal
if (ref $default eq 'HASH') { } 1 9 10
elsif (ref $default eq 'ARRAY') { } 1 8 9
elsif ($default =~ /^-?\d+$/) { } 5 3 8
elsif ($default =~ /^-?\d+\.\d+$/) { } 1 2 3
elsif ($default eq '1' or $default eq '0') { } 0 2 2
6814 1 return 'hashref';
6815 } elsif (ref($default) eq 'ARRAY') {
6816 1 return 'arrayref';
6817 } elsif ($default =~ /^-?\d+$/) {
6818 5 return 'integer';
6819 } elsif ($default =~ /^-?\d+\.\d+$/) {
6820 1 return 'number';
6821 ▶ } elsif ($default eq '1' || $default eq '0') {
Condition33%1/3
$default eq 1 or $default eq 0
l!l&&r!l&&!r
002
MC/DC0%0/2
$default eq 1 or $default eq 0
$default eq 1 $default eq 0
Truth table33%1/3
A or B
A= $default eq 1B= $default eq 0
ABresult
1X1
011
000
6822 0 return 'boolean';
6823 } else {
6824 2 return 'string';
6825 }
6826 }
6827  
6828 # --------------------------------------------------
6829 # _extract_subroutine_attributes
6830 #
6831 # Purpose: Extract Perl subroutine attributes
6832 # (e.g. :lvalue, :method, :Returns(Int))
6833 # from a method's source string.
6834 #
6835 # Entry: $code - method body source string.
6836 #
6837 # Exit: Returns a hashref of attribute name
6838 # to value (1 for flag-only attributes,
6839 # the attribute argument string for
6840 # attributes with values).
6841 # Returns an empty hashref if no
6842 # attributes are found.
6843 #
6844 # Side effects: Logs detections to stdout when
6845 # verbose is set.
6846 # --------------------------------------------------
6847 772 ▶sub _extract_subroutine_attributes {
Subroutine _extract_subroutine_attributes: called CC=10 SCAR=23.0
6848 772 my ($self, $code) = @_;
6849  
6850 772 my %attributes;
6851  
6852 # Extract all attributes from the sub declaration
6853 # Attributes are :name or :name(value) between sub name and either ( or {
6854 # Pattern: sub name ATTRIBUTES ( params ) { }
6855 # or: sub name ATTRIBUTES { }
6856  
6857 # First, find the attributes section (everything between sub name and ( or { )
6858 772 my $attr_section = '';
6859  
6860 772 ▶ if($code =~ /sub\s+\w+\s+((?::\w+(?:\([^)]*\))?\s*)+)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /sub\s+\w+\s+((?::\w+(?:\([^)]*\))?\s*)+)/s) 3 769 772
6861 3 $attr_section = $1;
6862 }
6863  
6864 # Parse individual attributes from the section
6865 772 ▶ if($attr_section) {
Branch: 1 branch
BranchTrueFalseTotal
if ($attr_section) 3 769 772
6866 3 ▶ while($attr_section =~ /:(\w+)(?:\(([^)]*)\))?/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($attr_section =~ /:(\w+)(?:\(([^)]*)\))?/g) 4 3 7
6867 4 my ($name, $value) = ($1, $2);
6868  
6869 4 ▶ if (defined $value && $value ne '') {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $value and $value ne '') { } 1 3 4
Condition66%2/3
defined $value and $value ne ""
!ll&&!rl&&r
301
MC/DC50%1/2
defined $value and $value ne ""
defined $value $value ne ""
Truth table66%2/3
A and B
A= defined $valueB= $value ne ""
ABresult
0X0
100
111
6870 1 $attributes{$name} = $value;
6871 1 $self->_log(" ATTR: Found attribute :$name($value)");
6872 } else {
6873 3 $attributes{$name} = 1;
6874 3 $self->_log(" ATTR: Found attribute :$name");
6875 }
6876 }
6877 }
6878  
6879 # Process common attributes
6880 772 ▶ if ($attributes{Returns}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($attributes{"Returns"}) 1 771 772
6881 1 my $return_type = $attributes{Returns};
6882 1 ▶ if ($return_type ne '1') { # Only log if it's an actual type, not just the flag
Branch: 1 branch
BranchTrueFalseTotal
if ($return_type ne 1) 1 0 1
6883 1 $self->_log(" ATTR: Method declares return type: $return_type");
6884 }
6885 }
6886  
6887 772 ▶ if ($attributes{lvalue}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($attributes{"lvalue"}) 2 770 772
6888 2 $self->_log(" ATTR: Method is lvalue (can be assigned to)");
6889 }
6890  
6891 772 ▶ if ($attributes{method}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($attributes{"method"}) 1 771 772
6892 1 $self->_log(' ATTR: Method explicitly marked as :method');
6893 }
6894  
6895 772 return \%attributes;
6896 }
6897  
6898 # --------------------------------------------------
6899 # _analyze_postfix_dereferencing
6900 #
6901 # Purpose: Detect usage of Perl 5.20+ postfix
6902 # dereferencing syntax in a method body
6903 # and record which dereference forms
6904 # are used.
6905 #
6906 # Entry: $code - method body source string.
6907 #
6908 # Exit: Returns a hashref whose keys are
6909 # dereference form names (array_deref,
6910 # hash_deref, scalar_deref, code_deref,
6911 # array_slice, hash_slice) with value 1
6912 # when detected.
6913 # Returns an empty hashref if no
6914 # postfix dereferencing is found.
6915 #
6916 # Side effects: Logs detections to stdout when
6917 # verbose is set.
6918 # --------------------------------------------------
6919 774 ▶sub _analyze_postfix_dereferencing {
Subroutine _analyze_postfix_dereferencing: called CC=7 SCAR=19.5
6920 774 my ($self, $code) = @_;
6921  
6922 774 my %derefs;
6923  
6924 # Array dereference: $ref->@*
6925 774 ▶ if ($code =~ /\$\w+\s*->\s*\@\*/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*->\s*\@\*/) 1 773 774
6926 1 $derefs{array_deref} = 1;
6927 1 $self->_log(" MODERN: Uses postfix array dereferencing (->@*)");
6928 }
6929  
6930 # Hash dereference: $ref->%*
6931 774 ▶ if ($code =~ /\$\w+\s*->\s*\%\*/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*->\s*\%\*/) 1 773 774
6932 1 $derefs{hash_deref} = 1;
6933 1 $self->_log(" MODERN: Uses postfix hash dereferencing (->%*)");
6934 }
6935  
6936 # Scalar dereference: $ref->$*
6937 774 ▶ if ($code =~ /\$\w+\s*->\s*\$\*/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*->\s*\$\*/) 1 773 774
6938 1 $derefs{scalar_deref} = 1;
6939 1 $self->_log(' MODERN: Uses postfix scalar dereferencing (->$*)');
6940 }
6941  
6942 # Code dereference: $ref->&*
6943 774 ▶ if ($code =~ /\$\w+\s*->\s*\&\*/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*->\s*\&\*/) 0 774 774
6944 0 $derefs{code_deref} = 1;
6945 0 $self->_log(" MODERN: Uses postfix code dereferencing (->&*)");
6946 }
6947  
6948 # Array element: $ref->@[0,2,4]
6949 774 ▶ if ($code =~ /\$\w+\s*->\s*\@\[/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*->\s*\@\[/) 1 773 774
6950 1 $derefs{array_slice} = 1;
6951 1 $self->_log(" MODERN: Uses postfix array slice (->@[...])");
6952 }
6953  
6954 # Hash element: $ref->%{key1,key2}
6955 774 ▶ if ($code =~ /\$\w+\s*->\s*\%\{/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*->\s*\%\{/) 1 773 774
6956 1 $derefs{hash_slice} = 1;
6957 1 $self->_log(" MODERN: Uses postfix hash slice (->%{...})");
6958 }
6959  
6960 774 return \%derefs;
6961 }
6962  
6963 # --------------------------------------------------
6964 # _extract_field_declarations
6965 #
6966 # Purpose: Extract Perl 5.38 field declarations
6967 # from a class body or method source
6968 # string, capturing field names,
6969 # :param attributes, default values,
6970 # and :isa type constraints.
6971 #
6972 # Entry: $code - source string potentially
6973 # containing 'field $name ...'
6974 # declarations.
6975 #
6976 # Exit: Returns a hashref of field name to
6977 # field_info hashref. Returns an empty
6978 # hashref if no field declarations
6979 # are found.
6980 #
6981 # Side effects: Logs detections to stdout when
6982 # verbose is set.
6983 # --------------------------------------------------
6984 773 ▶sub _extract_field_declarations {
Subroutine _extract_field_declarations: called CC=7 SCAR=19.5
6985 773 my ($self, $code) = @_;
6986  
6987 773 my %fields;
6988  
6989 # Pattern: field $name :param;
6990 # Pattern: field $name :param(name);
6991 # Pattern: field $name = default;
6992 # More lenient pattern to catch various formats
6993 773 ▶ while ($code =~ /^\s*field\s+\$(\w+)\s*([^;]*);/gm) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /^\s*field\s+\$(\w+)\s*([^;]*);/gm) 4 773 777
6994 4 my ($name, $modifiers) = ($1, $2);
6995  
6996 4 $self->_log(" FIELD: Found field \$$name with modifiers: [$modifiers]");
6997  
6998 4 my %field_info = (
6999 name => $name,
7000 _source => SOURCE_FIELD
7001 );
7002  
7003 # Check for :param attribute
7004 4 ▶ if ($modifiers =~ /:param(?:\(([^)]+)\))?/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($modifiers =~ /:param(?:\(([^)]+)\))?/) 4 0 4
7005 4 $field_info{is_param} = 1;
7006  
7007 4 ▶ if (defined $1) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $1) { } 1 3 4
7008 # Explicit parameter name
7009 1 $field_info{param_name} = $1;
7010 } else {
7011 # Implicit - field name is param name
7012 3 $field_info{param_name} = $name;
7013 }
7014  
7015 4 $self->_log(" FIELD: $name maps to parameter: $field_info{param_name}");
7016 }
7017  
7018 # Check for default value - must come before type constraint check
7019 4 ▶ if ($modifiers =~ /=\s*([^:;]+)(?::|;|$)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($modifiers =~ /=\s*([^:;]+)(?::|;|$)/) 1 3 4
7020 1 my $default = $1;
7021 1 $default =~ s/\s+$//;
7022 1 $field_info{_default} = $self->_clean_default_value($default, 1);
7023 1 $field_info{optional} = 1;
7024 1 ▶ $self->_log(" FIELD: $name has default: " . (defined $field_info{_default} ? $field_info{_default} : 'undef'));
Branch: 1 branch
BranchTrueFalseTotal
defined $field_info{'_default'} ? : 1 0 1
7025 }
7026  
7027 # Check for type constraints
7028 4 ▶ if ($modifiers =~ /:isa\(([^)]+)\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($modifiers =~ /:isa\(([^)]+)\)/) 1 3 4
7029 1 $field_info{isa} = $1;
7030 1 $field_info{type} = 'object';
7031 1 $self->_log(" FIELD: $name has type constraint: $1");
7032 }
7033  
7034 4 $fields{$name} = \%field_info;
7035 }
7036  
7037 773 return \%fields;
7038 }
7039  
7040 # --------------------------------------------------
7041 # _merge_field_declarations
7042 #
7043 # Purpose: Integrate Perl 5.38 field declarations
7044 # that carry the :param attribute into
7045 # the code parameter hashref, so they
7046 # appear as constructor parameters in
7047 # the generated schema.
7048 #
7049 # Entry: $params - hashref of parameters
7050 # extracted from code analysis
7051 # (modified in place).
7052 # $fields - hashref of field declarations
7053 # as returned by
7054 # _extract_field_declarations.
7055 #
7056 # Exit: Returns nothing. Modifies $params
7057 # in place.
7058 #
7059 # Side effects: Logs merges to stdout when verbose
7060 # is set.
7061 #
7062 # Notes: Only fields with is_param => 1 are
7063 # merged. The param_name key in the
7064 # field (which may differ from the
7065 # field name if :param(name) was used)
7066 # determines the parameter key.
7067 # --------------------------------------------------
7068 0 ▶sub _merge_field_declarations {
Subroutine _merge_field_declarations: not called CC=8 SCAR=42.8
7069 0 my ($self, $params, $fields) = @_;
7070  
7071 0 foreach my $field_name (keys %$fields) {
7072 0 my $field = $fields->{$field_name};
7073  
7074 # Only process fields that are parameters
7075 0 ▶ next unless $field->{is_param};
Branch: 1 branch
BranchTrueFalseTotal
unless $field->{"is_param"} 0 0 0
7076  
7077 0 my $param_name = $field->{param_name};
7078  
7079 # Create or update parameter info
7080 0 ▶ $params->{$param_name} ||= {};
Condition0%0/2
$params->{$param_name} ||= {}
l!l
00
MC/DC0%0/1
$params->{$param_name} ||= {}
$params->{$param_name}
Truth table0%0/2
A
A= $params->{$param_name}
Aresult
11
00
7081 0 my $p = $params->{$param_name};
7082  
7083 # Merge field information into parameter
7084 0 ▶ $p->{_source} = SOURCE_FIELD unless $p->{_source};
Branch: 1 branch
BranchTrueFalseTotal
unless $p->{"_source"} 0 0 0
7085 0 ▶ $p->{field_name} = $field_name if $field_name ne $param_name;
Branch: 1 branch
BranchTrueFalseTotal
if $field_name ne $param_name 0 0 0
7086  
7087 0 ▶ if ($field->{_default}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($field->{"_default"}) 0 0 0
7088 0 $p->{_default} = $field->{_default};
7089 0 $p->{optional} = 1;
7090 }
7091  
7092 0 ▶ if ($field->{isa}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($field->{"isa"}) 0 0 0
7093 0 $p->{isa} = $field->{isa};
7094 0 $p->{type} = 'object';
7095 }
7096  
7097 0 $self->_log(" MERGED: Field $field_name -> parameter $param_name");
7098 }
7099 }
7100  
7101 # --------------------------------------------------
7102 # _extract_defaults_from_code
7103 #
7104 # Purpose: Scan a method body for default value
7105 # assignment patterns and populate the
7106 # optional and _default fields of
7107 # known parameters.
7108 #
7109 # Entry: $params - hashref of parameters
7110 # (modified in place).
7111 # $code - method body source string.
7112 # $method - method hashref, used for
7113 # constructor-specific
7114 # exclusions of $class and
7115 # $self.
7116 #
7117 # Exit: Returns nothing. Modifies $params
7118 # in place.
7119 #
7120 # Side effects: Logs detections to stdout when
7121 # verbose is set.
7122 #
7123 # Notes: Eight default patterns are tried.
7124 # Only parameters already present in
7125 # $params are updated — this method
7126 # does not add new parameters.
7127 # Falls back to extracting all @_
7128 # assignments if $params is empty
7129 # after the main pass.
7130 # --------------------------------------------------
7131 770 ▶sub _extract_defaults_from_code {
Subroutine _extract_defaults_from_code: called CC=35 SCAR=37.5
7132 770 my ($self, $params, $code, $method) = @_;
7133  
7134 # Pattern 1: my $param = value;
7135 770 ▶ while ($code =~ /my\s+\$(\w+)\s*=\s*([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s+\$(\w+)\s*=\s*([^;]+);/g) 949 770 1719
7136 949 my ($param, $value) = ($1, $2);
7137 949 ▶ next unless exists $params->{$param};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 942 7 949
7138 7 ▶ next if $value =~ /->/; # deref/method call, not a default value
Branch: 1 branch
BranchTrueFalseTotal
if $value =~ /->/ 1 6 7
7139  
7140 6 $params->{$param}{_default} = $self->_clean_default_value($value, 1);
7141 6 $params->{$param}{optional} = 1;
7142 6 $self->_log(" CODE: $param has default: " . $self->_format_default($params->{$param}{_default}));
7143 }
7144  
7145 # Pattern 2: $param = value unless defined $param;
7146 770 ▶ while ($code =~ /\$(\w+)\s*=\s*([^;]+?)\s+unless\s+(?:defined\s+)?\$\1/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$(\w+)\s*=\s*([^;]+?)\s+unless\s+(?:defined\s+)?\$\1/g) 3 770 773
7147 3 my ($param, $value) = ($1, $2);
7148 3 ▶ next unless exists $params->{$param};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 0 3 3
7149  
7150 3 $params->{$param}{_default} = $self->_clean_default_value($value, 1);
7151 3 $params->{$param}{optional} = 1;
7152 3 $self->_log(" CODE: $param has default (unless): " . $self->_format_default($params->{$param}{_default}));
7153 }
7154  
7155 # Pattern 3: $param = value unless $param;
7156 770 ▶ while ($code =~ /\$(\w+)\s*=\s*([^;]+?)\s+unless\s+\$\1/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$(\w+)\s*=\s*([^;]+?)\s+unless\s+\$\1/g) 1 770 771
7157 1 my ($param, $value) = ($1, $2);
7158 1 ▶ next unless exists $params->{$param};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 0 1 1
7159  
7160 1 $params->{$param}{_default} = $self->_clean_default_value($value, 1);
7161 1 $params->{$param}{optional} = 1;
7162 1 $self->_log(" CODE: $param has default (unless): " . $self->_format_default($params->{$param}{_default}));
7163 }
7164  
7165 # Pattern 4: $param = $param || 'default';
7166 770 ▶ while ($code =~ /\$(\w+)\s*=\s*\$\1\s*\|\|\s*([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$(\w+)\s*=\s*\$\1\s*\|\|\s*([^;]+);/g) 7 770 777
7167 7 my ($param, $value) = ($1, $2);
7168 7 ▶ next unless exists $params->{$param};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 0 7 7
7169  
7170 7 $params->{$param}{_default} = $self->_clean_default_value($value, 1);
7171 7 $params->{$param}{optional} = 1;
7172 7 $self->_log(" CODE: $param has default (||): " . $self->_format_default($params->{$param}{_default}));
7173 }
7174  
7175 # Pattern 5: $param ||= 'default';
7176 770 ▶ while ($code =~ /\$(\w+)\s*\|\|=\s*([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$(\w+)\s*\|\|=\s*([^;]+);/g) 19 770 789
7177 19 my ($param, $value) = ($1, $2);
7178 19 ▶ next unless exists $params->{$param};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 6 13 19
7179  
7180 13 $params->{$param}{_default} = $self->_clean_default_value($value, 1);
7181 13 $params->{$param}{optional} = 1;
7182 13 $self->_log(" CODE: $param has default (||=): " . $self->_format_default($params->{$param}{_default}));
7183 }
7184  
7185 # Pattern 6: $param //= 'default';
7186 770 ▶ while ($code =~ /\$(\w+)\s*\/\/=\s*([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ m[\$(\w+)\s*//=\s*([^;]+);]g) 8 770 778
7187 8 my ($param, $value) = ($1, $2);
7188 8 ▶ next unless exists $params->{$param}; # Using -> because $params is a reference
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 0 8 8
7189  
7190 8 $params->{$param}{_default} = $self->_clean_default_value($value, 1);
7191  
7192 8 $params->{$param}{optional} = 1;
7193 8 $self->_log(" CODE: $param has default (//=): " . $self->_format_default($params->{$param}{_default}));
7194 }
7195  
7196 # Pattern 7: $param = defined $param ? $param : 'default';
7197 770 ▶ while ($code =~ /\$(\w+)\s*=\s*defined\s+\$\1\s*\?\s*\$\1\s*:\s*([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$(\w+)\s*=\s*defined\s+\$\1\s*\?\s*\$\1\s*:\s*([^;]+);/g) 4 770 774
7198 4 my ($param, $value) = ($1, $2);
7199  
7200 # Create param entry if it doesn't exist
7201 4 ▶ $params->{$param} ||= {};
Condition50%1/2
$params->{$param} ||= {}
l!l
40
MC/DC0%0/1
$params->{$param} ||= {}
$params->{$param}
Truth table50%1/2
A
A= $params->{$param}
Aresult
11
00
7202  
7203 4 my $cleaned = $self->_clean_default_value($value, 1);
7204  
7205 4 $params->{$param}{_default} = $cleaned;
7206 4 $params->{$param}{optional} = 1;
7207 4 $self->_log(" CODE: $param has default (ternary): " . $self->_format_default($params->{$param}{_default}));
7208 }
7209  
7210 # Pattern 8: $param = $args{param} || 'default';
7211 770 ▶ while ($code =~ /\$(\w+)\s*=\s*\$args\{['"]?\w+['"]?\}\s*\|\|\s*([^;]+);/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$(\w+)\s*=\s*\$args\{['"]?\w+['"]?\}\s*\|\|\s*([^;]+);/g) 0 770 770
7212 0 my ($param, $value) = ($1, $2);
7213 0 ▶ next unless exists $params->{$param};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 0 0 0
7214  
7215 0 $params->{$param}{_default} = $self->_clean_default_value($value, 1);
7216 0 $params->{$param}{optional} = 1;
7217 0 $self->_log(" CODE: $param has default (from args): " . $self->_format_default($params->{$param}{_default}));
7218 }
7219  
7220 # Pattern for non-empty hashref
7221 770 ▶ while ($code =~ /\$(\w+)\s*\|\|=\s*\{[^}]+\}/gs) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$(\w+)\s*\|\|=\s*\{[^}]+\}/gs) 1 770 771
7222 1 my $param = $1;
7223 1 ▶ next unless exists $params->{$param};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $params->{$param} 0 1 1
7224  
7225 # Return empty hashref as placeholder (can't evaluate complex hashrefs)
7226 1 $params->{$param}{_default} = {};
7227 1 $params->{$param}{optional} = 1;
7228 1 $self->_log(" CODE: $param has hashref default (||=)");
7229 }
7230  
7231 # Fallback: extract parameters from classic Perl body styles
7232 # Only run if signature extraction found nothing AND the code does not use
7233 # the direct-index ($_[0]) style — that style is used for no-param methods
7234 # whose empty %params would otherwise trigger this fallback and pick up
7235 # my (...) = @_ from inner closures as if they were method params.
7236 # TODO: On constructors, use $class to help to determine the output type
7237 770 ▶ if (!keys %{$params} && $code !~ /my\s+\$(?:self|class|pkg|proto|klass)\s*=\s*\$_\[0\]/) {
Branch: 1 branch
BranchTrueFalseTotal
if (not keys %{$params;} || $code =~ /my\s+\$(?:self|class|pkg|proto|klass)\s*=\s*\$_\[0\]/) 380 390 770
Condition100%3/3
keys %{$params;} || $code =~ /my\s+\$(?:self|class|pkg|proto|klass)\s*=\s*\$_\[0\]/
l!l&&r!l&&!r
32268380
MC/DC100%2/2
keys %{$params;} || $code =~ /my\s+\$(?:self|class|pkg|proto|klass)\s*=\s*\$_\[0\]/
keys %{$params;} $code =~ /my\s+\$(?:self|class|pkg|proto|klass)\s*=\s*\$_\[0\]/
Truth table100%3/3
A || B
A= keys %{$params;}B= $code =~ /my\s+\$(?:self|class|pkg|proto|klass)\s*=\s*\$_\[0\]/
ABresult
1X1
011
000
7238 380 my $position = 0;
7239  
7240 # Style 1: my ($a, $b) = @_;
7241 380 ▶ while ($code =~ /my\s*\(\s*([^)]+)\s*\)\s*=\s*\@_/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s*\(\s*([^)]+)\s*\)\s*=\s*\@_/g) 94 380 474
7242 94 my @vars = $1 =~ /\$(\w+)/g;
7243 94 foreach my $var (@vars) {
7244 94 ▶ if(($position == 0) && ($var =~ /^(self|class|pkg|proto|klass)$/i)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($position == 0 and $var =~ /^(self|class|pkg|proto|klass)$/i) { } 94 0 94
Condition33%1/3
$position == 0 and $var =~ /^(self|class|pkg|proto|klass)$/i
!ll&&!rl&&r
0094
MC/DC0%0/2
$position == 0 and $var =~ /^(self|class|pkg|proto|klass)$/i
$position == 0 $var =~ /^(self|class|pkg|proto|klass)$/i
Truth table33%1/3
A and B
A= $position == 0B= $var =~ /^(self|class|pkg|proto|klass)$/i
ABresult
0X0
100
111
7245 # Invocant — skip it
7246 94 delete $params->{$var};
7247 } else {
7248 0 ▶ $params->{$var} ||= { position => $position++ };
Condition0%0/2
$params->{$var} ||= {"position", $position++}
l!l
00
MC/DC0%0/1
$params->{$var} ||= {"position", $position++}
$params->{$var}
Truth table0%0/2
A
A= $params->{$var}
Aresult
11
00
7249 0 $self->_log(" CODE: $var extracted from \@_ list assignment");
7250 }
7251 }
7252 }
7253  
7254 # Style 2: my $x = shift;
7255 380 ▶ while ($code =~ /my\s+\$(\w+)\s*=\s*shift\b/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s+\$(\w+)\s*=\s*shift\b/g) 66 380 446
7256 66 my $var = $1;
7257 66 ▶ if(($position == 0) && ($var =~ /^(self|class|pkg|proto|klass)$/i)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($position == 0 and $var =~ /^(self|class|pkg|proto|klass)$/i) { } 23 43 66
Condition66%2/3
$position == 0 and $var =~ /^(self|class|pkg|proto|klass)$/i
!ll&&!rl&&r
04323
MC/DC50%1/2
$position == 0 and $var =~ /^(self|class|pkg|proto|klass)$/i
$position == 0 $var =~ /^(self|class|pkg|proto|klass)$/i
Truth table66%2/3
A and B
A= $position == 0B= $var =~ /^(self|class|pkg|proto|klass)$/i
ABresult
0X0
100
111
7258 # Invocant — skip it
7259 23 delete $params->{$var};
7260 } else {
7261 43 ▶ $params->{$var} ||= { position => $position++ };
Condition50%1/2
$params->{$var} ||= {"position", $position++}
l!l
043
MC/DC0%0/1
$params->{$var} ||= {"position", $position++}
$params->{$var}
Truth table50%1/2
A
A= $params->{$var}
Aresult
11
00
7262 43 $self->_log(" CODE: $var is extracted from shift");
7263 }
7264 }
7265  
7266 # Style 3: my $x = $_[0];
7267 380 ▶ while ($code =~ /my\s+\$(\w+)\s*=\s*\$_\[(\d+)\]/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /my\s+\$(\w+)\s*=\s*\$_\[(\d+)\]/g) 24 380 404
7268 24 my ($var, $index) = ($1, $2);
7269 24 ▶ if(($index > 0) || ($var !~ /^(self|class|pkg|proto|klass)$/i)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($index > 0 or not $var =~ /^(self|class|pkg|proto|klass)$/i) 24 0 24
Condition33%1/3
$index > 0 or not $var =~ /^(self|class|pkg|proto|klass)$/i
l!l&&r!l&&!r
0240
MC/DC0%0/2
$index > 0 or not $var =~ /^(self|class|pkg|proto|klass)$/i
$index > 0 not $var =~ /^(self|class|pkg|proto|klass)$/i
Truth table33%1/3
A or not(B)
A= $index > 0B= not $var =~ /^(self|class|pkg|proto|klass)$/i
ABresult
1X1
011
000
7270 24 ▶ $params->{$var} ||= { position => $index };
Condition50%1/2
$params->{$var} ||= {"position", $index}
l!l
024
MC/DC0%0/1
$params->{$var} ||= {"position", $index}
$params->{$var}
Truth table50%1/2
A
A= $params->{$var}
Aresult
11
00
7271 24 $self->_log(" CODE: $var is extracted from \$_\[$index\]");
7272 }
7273 }
7274 }
7275 }
7276  
7277 # --------------------------------------------------
7278 # _format_default
7279 #
7280 # Purpose: Format a default value for display
7281 # in verbose log output.
7282 #
7283 # Entry: $default - the default value to
7284 # format. May be undef,
7285 # a scalar, a hashref, or
7286 # an arrayref.
7287 #
7288 # Exit: Returns a display string: 'undef'
7289 # for undef, 'HASH ref' / 'ARRAY ref'
7290 # for references, or the value itself
7291 # for scalars.
7292 #
7293 # Side effects: None.
7294 # --------------------------------------------------
7295 47 ▶sub _format_default {
Subroutine _format_default: called CC=3 SCAR=11.0
7296 47 my ($self, $default) = @_;
7297 47 ▶ return 'undef' unless defined $default;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $default 6 41 47
7298 41 ▶ return ref($default) . ' ref' if ref($default);
Branch: 1 branch
BranchTrueFalseTotal
if ref $default 10 31 41
7299 31 return $default;
7300 }
7301  
7302 # Resolve the right-hand side of a length comparison: a literal or a
7303 # Readonly/use-constant name.
7304 35 ▶sub _length_constraint_value {
Subroutine _length_constraint_value: called CC=3 SCAR=11.0
7305 35 my ($self, $rhs) = @_;
7306  
7307 35 ▶ return $rhs + 0 if $rhs =~ /^\d+$/;
Branch: 1 branch
BranchTrueFalseTotal
if $rhs =~ /^\d+$/ 17 18 35
7308 18 ▶ return undef unless $rhs =~ /^\$(\w+)$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $rhs =~ /^\$(\w+)$/ 0 18 18
7309 18 return $self->_module_constants()->{$1};
7310 }
7311  
7312 # Record the accepted length range. When the comparison is an error
7313 # condition (an `if` guard), the accepted range is its negation.
7314 35 ▶sub _record_length_constraint {
Subroutine _record_length_constraint: called CC=14 SCAR=37.0
7315 35 my ($self, $p, $op, $val, $invert) = @_;
7316  
7317 35 ▶ if($invert) {
Branch: 1 branch
BranchTrueFalseTotal
if ($invert) 7 28 35
7318 7 my %negated = ('<' => '>=', '<=' => '>', '>' => '<=', '>=' => '<');
7319 7 $op = $negated{$op};
7320 }
7321  
7322 35 ▶ if($op eq '<') {
Branch: 4 branches
BranchTrueFalseTotal
if ($op eq '<') { } 0 35 35
elsif ($op eq '<=') { } 13 22 35
elsif ($op eq '>') { } 0 22 22
elsif ($op eq '>=') { } 22 0 22
7323 0 my $max = $val - 1;
7324 0 ▶ $p->{max} = $max if !defined($p->{max}) || $max < $p->{max};
Branch: 1 branch
BranchTrueFalseTotal
if not defined $p->{"max"} or $max < $p->{"max"} 0 0 0
Condition0%0/3
not defined $p->{"max"} or $max < $p->{"max"}
l!l&&r!l&&!r
000
MC/DC0%0/2
not defined $p->{"max"} or $max < $p->{"max"}
not defined $p->{"max"} $max < $p->{"max"}
Truth table0%0/3
not(A) or B
A= not defined $p->{"max"}B= $max < $p->{"max"}
ABresult
1X1
011
000
7325 } elsif($op eq '<=') {
7326 13 ▶ $p->{max} = $val if !defined($p->{max}) || $val < $p->{max};
Branch: 1 branch
BranchTrueFalseTotal
if not defined $p->{"max"} or $val < $p->{"max"} 13 0 13
Condition33%1/3
not defined $p->{"max"} or $val < $p->{"max"}
l!l&&r!l&&!r
1300
MC/DC0%0/2
not defined $p->{"max"} or $val < $p->{"max"}
not defined $p->{"max"} $val < $p->{"max"}
Truth table33%1/3
not(A) or B
A= not defined $p->{"max"}B= $val < $p->{"max"}
ABresult
1X1
011
000
7327 } elsif($op eq '>') {
7328 0 my $min = $val + 1;
7329 0 ▶ $p->{min} = $min if !defined($p->{min}) || $min > $p->{min};
Branch: 1 branch
BranchTrueFalseTotal
if not defined $p->{"min"} or $min > $p->{"min"} 0 0 0
Condition0%0/3
not defined $p->{"min"} or $min > $p->{"min"}
l!l&&r!l&&!r
000
MC/DC0%0/2
not defined $p->{"min"} or $min > $p->{"min"}
not defined $p->{"min"} $min > $p->{"min"}
Truth table0%0/3
not(A) or B
A= not defined $p->{"min"}B= $min > $p->{"min"}
ABresult
1X1
011
000
7330 } elsif($op eq '>=') {
7331 22 ▶ $p->{min} = $val if !defined($p->{min}) || $val > $p->{min};
Branch: 1 branch
BranchTrueFalseTotal
if not defined $p->{"min"} or $val > $p->{"min"} 21 1 22
Condition66%2/3
not defined $p->{"min"} or $val > $p->{"min"}
l!l&&r!l&&!r
2101
MC/DC50%1/2
not defined $p->{"min"} or $val > $p->{"min"}
not defined $p->{"min"} $val > $p->{"min"}
Truth table66%2/3
not(A) or B
A= not defined $p->{"min"}B= $val > $p->{"min"}
ABresult
1X1
011
000
7332 }
7333 }
7334  
7335 # Return ($op, $value) when a guard condition is exactly one length
7336 # comparison, or an empty list when the comparison is only one operand of a
7337 # compound condition. A compound condition enforces no bound of its own:
7338 # `croak ... if length($t) < 5 || $other` still croaks for long text when
7339 # $other is true, and `... if length($t) < 5 && $other` accepts short text
7340 # when $other is false. Only a condition that is nothing but the comparison
7341 # makes the negation of that comparison a real constraint.
7342 320 ▶sub _whole_condition_length_guard {
Subroutine _whole_condition_length_guard: called CC=10 SCAR=23.5
7343 320 my ($self, $param, $condition) = @_;
7344  
7345 320 $condition =~ s/^\s+//;
7346 320 $condition =~ s/\s+$//;
7347  
7348 # Drop balanced outer parentheses, as in `if (length($t) < 5)`.
7349 320 ▶ while($condition =~ /^\((.*)\)$/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($condition =~ /^\((.*)\)$/s) 1 320 321
7350 1 my $inner = $1;
7351 1 my $depth = 0;
7352 1 my $balanced = 1;
7353 1 foreach my $char (split(//, $inner)) {
7354 15 ▶ if($char eq '(') {
Branch: 2 branches
BranchTrueFalseTotal
if ($char eq '(') { } 1 14 15
elsif ($char eq ')') { } 1 13 14
7355 1 $depth++;
7356 } elsif($char eq ')') {
7357 1 $depth--;
7358 1 ▶ if($depth < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($depth < 0) 0 1 1
7359 0 $balanced = 0;
7360 0 last;
7361 }
7362 }
7363 }
7364 1 ▶ last unless $balanced && ($depth == 0);
Branch: 1 branch
BranchTrueFalseTotal
unless $balanced and $depth == 0 0 1 1
Condition33%1/3
$balanced and $depth == 0
!ll&&!rl&&r
001
MC/DC0%0/2
$balanced and $depth == 0
$balanced $depth == 0
Truth table33%1/3
A and B
A= $balancedB= $depth == 0
ABresult
0X0
100
111
7365 1 $condition = $inner;
7366 1 $condition =~ s/^\s+//;
7367 1 $condition =~ s/\s+$//;
7368 }
7369  
7370 320 ▶ return unless $condition =~ /^length\s*\(\s*\$\Q$param\E\s*\)\s*([<>]=?)\s*(\d+|\$\w+)$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $condition =~ /^length\s*\(\s*\$\Q$param\E\s*\)\s*([<>]=?)\s*(\d+|\$\w+)$/ 285 35 320
7371  
7372 35 my ($op, $rhs) = ($1, $2);
7373 35 my $val = $self->_length_constraint_value($rhs);
7374 35 ▶ return unless defined $val;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $val 0 35 35
7375  
7376 35 return ($op, $val);
7377 }
7378  
7379 # --------------------------------------------------
7380 # _module_constants
7381 #
7382 # Purpose: Build and cache a hash of numeric
7383 # constant values declared in the target
7384 # module source, covering both Readonly
7385 # lexicals and 'use constant' barewords.
7386 # Used by _analyze_parameter_constraints
7387 # to resolve right-hand sides like
7388 # $MIN_NAME_LEN that are not literals.
7389 #
7390 # Entry: None (uses $self->{_document}).
7391 #
7392 # Exit: Returns a hashref { NAME => value }.
7393 # Returns {} if the PPI document is not
7394 # yet loaded.
7395 #
7396 # Side effects: Caches result in $self->{_constants}.
7397 # --------------------------------------------------
7398 18 ▶sub _module_constants {
Subroutine _module_constants: called CC=5 SCAR=16.7
7399 18 my ($self) = @_;
7400 18 ▶ return $self->{_constants} if exists $self->{_constants};
Branch: 1 branch
BranchTrueFalseTotal
if exists $self->{"_constants"} 13 5 18
7401  
7402 5 my %c;
7403 5 my $doc = $self->{_document};
7404 5 ▶ unless ($doc) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($doc) 0 5 5
7405 0 $self->{_constants} = \%c;
7406 0 return \%c;
7407 }
7408  
7409 5 my $src = $doc->serialize();
7410  
7411 # Readonly my $CONST => numeric_value;
7412 5 ▶ while ($src =~ /Readonly\s+(?:my|our)\s+\$(\w+)\s*=>\s*([+-]?\d+(?:\.\d+)?)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($src =~ /Readonly\s+(?:my|our)\s+\$(\w+)\s*=>\s*([+-]?\d+(?:\.\d+)?)/g) 34 5 39
7413 34 $c{$1} = $2;
7414 }
7415  
7416 # use constant CONST => numeric_value;
7417 5 ▶ while ($src =~ /use\s+constant\s+(\w+)\s*=>\s*([+-]?\d+(?:\.\d+)?)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($src =~ /use\s+constant\s+(\w+)\s*=>\s*([+-]?\d+(?:\.\d+)?)/g) 0 5 5
7418 0 $c{$1} = $2;
7419 }
7420  
7421 5 $self->{_constants} = \%c;
7422 5 return \%c;
7423 }
7424  
7425 # --------------------------------------------------
7426 # _analyze_parameter_constraints
7427 #
7428 # Purpose: Infer min, max, and regex match
7429 # constraints for a single parameter
7430 # from length checks, numeric
7431 # comparisons, and regex match
7432 # patterns in the method body.
7433 #
7434 # Entry: $p_ref - reference to the parameter
7435 # hashref (modified in place).
7436 # $param - parameter name string.
7437 # $code - method body source string.
7438 #
7439 # Exit: Returns nothing. Modifies the
7440 # referenced parameter hashref.
7441 #
7442 # Side effects: Logs detections to stdout when
7443 # verbose is set.
7444 #
7445 # Notes: Numeric comparisons that appear
7446 # inside die/croak guard conditions
7447 # are excluded to avoid inferring
7448 # invalid-input ranges as valid
7449 # constraints.
7450 # --------------------------------------------------
7451 510 ▶sub _analyze_parameter_constraints {
Subroutine _analyze_parameter_constraints: called CC=26 SCAR=42.5
7452 510 my ($self, $p_ref, $param, $code) = @_;
7453 510 my $p = $$p_ref;
7454  
7455 # Do not treat comparisons inside die/croak/confess as valid constraints
7456 510 my $guarded = 0;
7457 510 ▶ if ($code =~ /(die|croak|confess)\b[^{;]*\bif\b[^{;]*\$$param\b/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(die|croak|confess)\b[^{;]*\bif\b[^{;]*\$$param\b/s) 56 454 510
7458 56 $guarded = 1;
7459 }
7460  
7461 # Length checks for strings. A comparison only describes the accepted
7462 # range when it guards an error: `croak ... unless length >= 5` accepts
7463 # >= 5, while `croak ... if length < 5` also accepts >= 5. Reading the
7464 # second condition literally would invent a max of 4 and can contradict
7465 # a min inferred from the first form.
7466 510 ▶ $p->{type} ||= 'string' if $code =~ /length\s*\(\s*\$$param\s*\)/;
Branch: 1 branch
BranchTrueFalseTotal
if $code =~ /length\s*\(\s*\$$param\s*\)/ 31 479 510
Condition50%1/2
$p->{"type"} ||= "string"
l!l
031
MC/DC0%0/1
$p->{"type"} ||= "string"
$p->{"type"}
Truth table50%1/2
A
A= $p->{"type"}
Aresult
11
00
7467  
7468 510 my $postfix_guards = $code;
7469 510 ▶ while ($postfix_guards =~ /\b(?:croak|die|confess)\b[^;{}]*?\b(if|unless)\b\s*([^;{}]+)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($postfix_guards =~ /\b(?:croak|die|confess)\b[^;{}]*?\b(if|unless)\b\s*([^;{}]+)/g) 320 510 830
7470 320 my ($guard, $condition) = ($1, $2);
7471 320 my ($op, $val) = $self->_whole_condition_length_guard($param, $condition);
7472 320 ▶ next unless defined $op;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $op 285 35 320
7473 35 $self->_record_length_constraint($p, $op, $val, ($guard eq 'if'));
7474 35 $self->_log(" CODE: $param length constraint from $guard guard: $op $val");
7475 }
7476  
7477 510 my $block_guards = $code;
7478 510 ▶ while ($block_guards =~ /\b(if|unless)\s*\(\s*length\s*\(\s*\$$param\s*\)\s*([<>]=?)\s*(\d+|\$\w+)\s*\)\s*\{([^{}]*)\}/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($block_guards =~ /\b(if|unless)\s*\(\s*length\s*\(\s*\$$param\s*\)\s*([<>]=?)\s*(\d+|\$\w+)\s*\)\s*\{([^{}]*)\}/g) 0 510 510
7479 0 my ($guard, $op, $rhs, $block) = ($1, $2, $3, $4);
7480 0 ▶ next unless $block =~ /\b(?:croak|die|confess)\b/;
Branch: 1 branch
BranchTrueFalseTotal
unless $block =~ /\b(?:croak|die|confess)\b/ 0 0 0
7481 0 my $val = $self->_length_constraint_value($rhs);
7482 0 ▶ next unless defined $val;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $val 0 0 0
7483 0 $self->_record_length_constraint($p, $op, $val, ($guard eq 'if'));
7484 0 $self->_log(" CODE: $param length constraint from $guard block: $op $rhs");
7485 }
7486  
7487 # Numeric range checks (only if NOT part of error guard)
7488 510 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (not $guarded and $code =~ /\$$param\s*([<>]=?)\s*([+-]?(?:\d+\.?\d*|\.\d+))/) 16 494 510
Condition100%3/3
not $guarded and $code =~ /\$$param\s*([<>]=?)\s*([+-]?(?:\d+\.?\d*|\.\d+))/
!ll&&!rl&&r
5643816
MC/DC100%2/2
not $guarded and $code =~ /\$$param\s*([<>]=?)\s*([+-]?(?:\d+\.?\d*|\.\d+))/
not $guarded $code =~ /\$$param\s*([<>]=?)\s*([+-]?(?:\d+\.?\d*|\.\d+))/
Truth table100%3/3
not(A) and B
A= not $guardedB= $code =~ /\$$param\s*([<>]=?)\s*([+-]?(?:\d+\.?\d*|\.\d+))/
ABresult
0X0
100
111
7489 !$guarded
7490 && $code =~ /\$$param\s*([<>]=?)\s*([+-]?(?:\d+\.?\d*|\.\d+))/
7491 ) {
7492 16 my ($op, $val) = ($1, $2);
7493 16 ▶ $p->{type} ||= looks_like_number($val) ? 'number' : 'integer';
Branch: 1 branch
BranchTrueFalseTotal
&looks_like_number($val) ? : 0 0 0
Condition33%1/3
$p->{"type"} ||= &looks_like_number($val) ? "number" : "integer"
l!l&&r!l&&!r
1600
MC/DC0%0/2
$p->{"type"} ||= &looks_like_number($val) ? "number" : "integer"
$p->{"type"} &looks_like_number($val) ? "number" : "integer"
Truth table33%1/3
A ||= B
A= $p->{"type"}B= &looks_like_number($val) ? "number" : "integer"
ABresult
1X1
011
000
7494  
7495 16 ▶ if ($op eq '<' || $op eq '<=') {
Branch: 2 branches
BranchTrueFalseTotal
if ($op eq '<' or $op eq '<=') { } 3 13 16
elsif ($op eq '>' or $op eq '>=') { } 13 0 13
Condition66%2/3
$op eq "<" or $op eq "<="
l!l&&r!l&&!r
3013
MC/DC50%1/2
$op eq "<" or $op eq "<="
$op eq "<" $op eq "<="
Truth table66%2/3
A or B
A= $op eq "<"B= $op eq "<="
ABresult
1X1
011
000
7496 # Only set max if it tightens the range
7497 3 ▶ my $max = ($op eq '<') ? $val - 1 : $val;
Branch: 1 branch
BranchTrueFalseTotal
$op eq '<' ? : 3 0 3
7498 3 ▶ $p->{max} = $max if !defined($p->{max}) || $max < $p->{max};
Branch: 1 branch
BranchTrueFalseTotal
if not defined $p->{"max"} or $max < $p->{"max"} 3 0 3
Condition33%1/3
not defined $p->{"max"} or $max < $p->{"max"}
l!l&&r!l&&!r
300
MC/DC0%0/2
not defined $p->{"max"} or $max < $p->{"max"}
not defined $p->{"max"} $max < $p->{"max"}
Truth table33%1/3
not(A) or B
A= not defined $p->{"max"}B= $max < $p->{"max"}
ABresult
1X1
011
000
7499 ▶ } elsif ($op eq '>' || $op eq '>=') {
Condition66%2/3
$op eq ">" or $op eq ">="
l!l&&r!l&&!r
1120
MC/DC0%0/2
$op eq ">" or $op eq ">="
$op eq ">" $op eq ">="
Truth table66%2/3
A or B
A= $op eq ">"B= $op eq ">="
ABresult
1X1
011
000
7500 13 ▶ my $min = ($op eq '>') ? $val + 1 : $val;
Branch: 1 branch
BranchTrueFalseTotal
$op eq '>' ? : 11 2 13
7501 13 ▶ $p->{min} = $min if !defined($p->{min}) || $min > $p->{min};
Branch: 1 branch
BranchTrueFalseTotal
if not defined $p->{"min"} or $min > $p->{"min"} 13 0 13
Condition33%1/3
not defined $p->{"min"} or $min > $p->{"min"}
l!l&&r!l&&!r
1300
MC/DC0%0/2
not defined $p->{"min"} or $min > $p->{"min"}
not defined $p->{"min"} $min > $p->{"min"}
Truth table33%1/3
not(A) or B
A= not defined $p->{"min"}B= $min > $p->{"min"}
ABresult
1X1
011
000
7502 }
7503 }
7504  
7505 # Regex pattern matching with better capture
7506 510 ▶ if ($code =~ /\$$param\s*=~\s*((?:qr?\/[^\/]+\/|\$[\w:]+|\$\{\w+\}))/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ m[\$$param\s*=~\s*((?:qr?/[^/]+/|\$[\w:]+|\$\{\w+\}))]) 0 510 510
7507 0 my $pattern = $1;
7508 0 ▶ $p->{type} ||= 'string';
Condition0%0/2
$p->{"type"} ||= "string"
l!l
00
MC/DC0%0/1
$p->{"type"} ||= "string"
$p->{"type"}
Truth table0%0/2
A
A= $p->{"type"}
Aresult
11
00
7509  
7510 # Clean up the pattern if it's a straightforward regex
7511 0 ▶ if ($pattern =~ /^qr?\/([^\/]+)\/$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pattern =~ m[^qr?/([^/]+)/$]) { } 0 0 0
7512 0 $p->{matches} = "/$1/";
7513 } else {
7514 0 $p->{matches} = $pattern;
7515 }
7516 0 $self->_log(" CODE: $param matches pattern: $p->{matches}");
7517 }
7518 }
7519  
7520 # --------------------------------------------------
7521 # _analyze_parameter_validation
7522 #
7523 # Purpose: Determine optionality and extract
7524 # default values for a single parameter
7525 # by analysing explicit required checks
7526 # (die/croak unless defined) and default
7527 # assignment patterns in the method body.
7528 #
7529 # Entry: $p_ref - reference to the parameter
7530 # hashref (modified in place).
7531 # $param - parameter name string.
7532 # $code - method body source string.
7533 #
7534 # Exit: Returns nothing. Modifies the
7535 # referenced parameter hashref.
7536 #
7537 # Side effects: Logs detections to stdout when
7538 # verbose is set.
7539 #
7540 # Notes: Explicit required checks take highest
7541 # priority and override any default
7542 # value detected earlier.
7543 # --------------------------------------------------
7544 510 ▶sub _analyze_parameter_validation {
Subroutine _analyze_parameter_validation: called CC=23 SCAR=34.1
7545 510 my ($self, $p_ref, $param, $code) = @_;
7546 510 my $p = $$p_ref;
7547  
7548 # Required/optional checks
7549 510 my $is_required = 0;
7550  
7551 # Die/croak if not defined
7552 510 ▶ if ($code =~ /(?:die|croak|confess)\s+[^;]*unless\s+(?:defined\s+)?\$$param/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)\s+[^;]*unless\s+(?:defined\s+)?\$$param/s) 67 443 510
7553 67 $is_required = 1;
7554 }
7555  
7556 # Extract default values with the new method
7557 510 my $default_value = $self->_extract_default_value($param, $code);
7558 510 ▶ if (defined $default_value && !exists $p->{_default}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $default_value and not exists $p->{"_default"}) 1 509 510
Condition100%3/3
defined $default_value and not exists $p->{"_default"}
!ll&&!rl&&r
479301
MC/DC100%2/2
defined $default_value and not exists $p->{"_default"}
defined $default_value not exists $p->{"_default"}
Truth table100%3/3
A and not(B)
A= defined $default_valueB= not exists $p->{"_default"}
ABresult
0X0
100
111
7559 1 $p->{optional} = 1;
7560 1 $p->{_default} = $default_value;
7561  
7562 # Try to infer type from default value if not already set
7563 1 ▶ unless ($p->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($p->{"type"}) 1 0 1
7564 1 ▶ if (looks_like_number($default_value)) {
Branch: 5 branches
BranchTrueFalseTotal
if (&looks_like_number($default_value)) { } 1 0 1
elsif (ref $default_value eq 'ARRAY') { } 0 0 0
elsif (ref $default_value eq 'HASH') { } 0 0 0
elsif ($default_value eq 'undef') { } 0 0 0
elsif (defined $default_value and not ref $default_value) { } 0 0 0
7565 1 ▶ $p->{type} = $default_value =~ /\./ ? 'number' : 'integer';
Branch: 1 branch
BranchTrueFalseTotal
$default_value =~ /\./ ? : 0 1 1
7566 } elsif (ref($default_value) eq 'ARRAY') {
7567 0 $p->{type} = 'arrayref';
7568 } elsif (ref($default_value) eq 'HASH') {
7569 0 $p->{type} = 'hashref';
7570 } elsif ($default_value eq 'undef') {
7571 0 $p->{type} = 'scalar'; # undef can be any scalar
7572 ▶ } elsif (defined $default_value && !ref($default_value)) {
Condition0%0/3
defined $default_value and not ref $default_value
!ll&&!rl&&r
000
MC/DC0%0/2
defined $default_value and not ref $default_value
defined $default_value not ref $default_value
Truth table0%0/3
A and not(B)
A= defined $default_valueB= not ref $default_value
ABresult
0X0
100
111
7573 0 $p->{type} = 'string';
7574 }
7575 }
7576  
7577 1 ▶ $self->_log(" CODE: $param has default value: " . (ref($default_value) ? ref($default_value) . ' ref' : $default_value));
Branch: 1 branch
BranchTrueFalseTotal
ref $default_value ? : 0 1 1
7578 }
7579  
7580 # Also check for simple default assignment without condition
7581 # Pattern: $param = 'value';
7582 510 ▶ if (!$default_value && !exists $p->{_default} && $code =~ /\$$param\s*=\s*([^;{}]+?)(?:\s*[;}])/s) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $default_value || exists $p->{"_default"} and $code =~ /\$$param\s*=\s*([^;{}]+?)(?:\s*[;}])/s) 97 413 510
Condition100%6/6
not $default_value || exists $p->{"_default"} and $code =~ /\$$param\s*=\s*([^;{}]+?)(?:\s*[;}])/s
!ll&&!rl&&r
4237197
$default_value || exists $p->{'_default'}
l!l&&r!l&&!r
2814468
MC/DC100%3/3
not $default_value || exists $p->{"_default"} and $code =~ /\$$param\s*=\s*([^;{}]+?)(?:\s*[;}])/s
$default_value exists $p->{'_default'} $code =~ /\$$param\s*=\s*([^;{}]+?)(?:\s*[;}])/s
Truth table100%4/4
not(A || B) and C
A= $default_valueB= exists $p->{'_default'}C= $code =~ /\$$param\s*=\s*([^;{}]+?)(?:\s*[;}])/s
ABCresult
1XX0
01X0
0000
0011
7583 97 my $assignment = $1;
7584 # Make sure it's not part of a larger expression
7585 97 ▶ if ($assignment !~ /\$$param/ && $assignment !~ /^shift/) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($assignment =~ /\$$param/ or $assignment =~ /^shift/) 54 43 97
Condition66%2/3
$assignment =~ /\$$param/ or $assignment =~ /^shift/
l!l&&r!l&&!r
04354
MC/DC50%1/2
$assignment =~ /\$$param/ or $assignment =~ /^shift/
$assignment =~ /\$$param/ $assignment =~ /^shift/
Truth table66%2/3
A or B
A= $assignment =~ /\$$param/B= $assignment =~ /^shift/
ABresult
1X1
011
000
7586 54 my $possible_default = $assignment;
7587 54 $possible_default =~ s/\s*;\s*$//;
7588 54 $possible_default = $self->_clean_default_value($possible_default);
7589 54 ▶ if (defined $possible_default) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $possible_default) 21 33 54
7590 21 $p->{_default} = $possible_default;
7591 21 $p->{optional} = 1;
7592 21 $self->_log(" CODE: $param has unconditional default: $possible_default");
7593 }
7594 }
7595 }
7596  
7597 # A bare truthiness test ("if($dir) {...}") is a presence test: the
7598 # routine does something different when nothing was passed, so the
7599 # argument can be omitted. An explicit required check wins over this.
7600 510 ▶ if (!$is_required && ($code =~ /\b(?:if|unless)\s*\(\s*\$$param\s*\)/)) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $is_required and $code =~ /\b(?:if|unless)\s*\(\s*\$$param\s*\)/) 1 509 510
Condition100%3/3
not $is_required and $code =~ /\b(?:if|unless)\s*\(\s*\$$param\s*\)/
!ll&&!rl&&r
674421
MC/DC100%2/2
not $is_required and $code =~ /\b(?:if|unless)\s*\(\s*\$$param\s*\)/
not $is_required $code =~ /\b(?:if|unless)\s*\(\s*\$$param\s*\)/
Truth table100%3/3
not(A) and B
A= not $is_requiredB= $code =~ /\b(?:if|unless)\s*\(\s*\$$param\s*\)/
ABresult
0X0
100
111
7601 1 $p->{optional} = 1;
7602 1 $self->_log(" CODE: $param is optional (only used when truthy)");
7603 }
7604  
7605 # Explicit required check overrides default detection
7606 510 ▶ if ($is_required) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_required) 67 443 510
7607 67 $p->{optional} = 0;
7608 67 ▶ delete $p->{_default} if exists $p->{_default};
Branch: 1 branch
BranchTrueFalseTotal
if exists $p->{"_default"} 16 51 67
7609 67 $self->_log(" CODE: $param is required (validation check)");
7610 }
7611 }
7612  
7613 # --------------------------------------------------
7614 # _positional_pod_input
7615 #
7616 # Purpose: Recognise a lone documented input parameter that is really the
7617 # first positional argument under another name.
7618 #
7619 # Entry: $pod - parameters from _analyze_pod; mutated.
7620 # $code_params - parameters from code analysis; mutated.
7621 # $code - the subroutine body as source text.
7622 #
7623 # Exit: Returns the documented name when it is treated as position 0,
7624 # otherwise undef.
7625 #
7626 # Notes: Two or more documented names describe a hash of arguments, and
7627 # a body that reads an argument hash (my %args = @_, $args->{...},
7628 # $_[0]{...}) keeps the named style even with one name. A body
7629 # that shows no positional use at all -- a wrapper forwarding @_,
7630 # say -- proves nothing either way, so it stays named rather than
7631 # guessing.
7632 #
7633 # Side effects: On success sets position 0, drops stray documented names and
7634 # replaces the code analysis with the one argument, renamed.
7635 # --------------------------------------------------
7636 750 ▶sub _positional_pod_input {
Subroutine _positional_pod_input: called CC=7 SCAR=19.5
7637 750 my ($self, $pod, $code_params, $code) = @_;
7638  
7639 750 ▶ my @documented = grep { ($pod->{$_}{_source} // '') eq SOURCE_INPUT_SPEC } keys %$pod;
Condition100%2/2
$pod->{$_}{"_source"} // ""
l!l
43841
MC/DC100%1/1
$pod->{$_}{"_source"} // ""
$pod->{$_}{"_source"}
Truth table100%2/2
A
A= $pod->{$_}{"_source"}
Aresult
11
00
7640 750 ▶ return undef unless @documented == 1;
Branch: 1 branch
BranchTrueFalseTotal
unless @documented == 1 580 170 750
7641 170 ▶ return undef unless $self->_argument_style($code) eq 'positional';
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_argument_style($code) eq "positional" 49 121 170
7642  
7643 121 my ($name) = @documented;
7644 121 $pod->{$name}{position} = 0;
7645  
7646 # The body names the same argument however it likes, so carry its facts
7647 # (a directory tested with -d, say) to the documented name.
7648 121 my @code_names = keys %$code_params;
7649 121 ▶ my $source = $code_params->{$name} ? $name
Branch: 2 branches
BranchTrueFalseTotal
$code_params->{$name} ? : 117 4 121
@code_names == 1 ? : 0 4 4
7650 : (@code_names == 1 ? $code_names[0] : undef);
7651  
7652 # Empty list, not {}: a hashref here would become a one-element list and
7653 # land in the hash as a "HASH(0x...)" key.
7654 121 ▶ %$code_params = $source ? ($name => $code_params->{$source}) : ();
Branch: 1 branch
BranchTrueFalseTotal
$source ? : 117 4 121
7655 121 %$pod = ($name => $pod->{$name});
7656 121 $self->_log(" POD: single Input spec '$name' describes a positional argument");
7657  
7658 121 return $name;
7659 }
7660  
7661 # --------------------------------------------------
7662 # _argument_style
7663 #
7664 # Purpose: Classify how a subroutine reads its arguments.
7665 #
7666 # Entry: $code - the subroutine body as source text.
7667 #
7668 # Exit: 'named' when the body reads an argument hash, 'positional'
7669 # when it reads an argument by position, '' when neither shows.
7670 #
7671 # Notes: $self->{...} is object state, not an argument, so it is removed
7672 # before looking for hash dereferences. '' is not 'positional':
7673 # a wrapper that only forwards @_ proves nothing, so it keeps the
7674 # named style these heuristics started from. An invocant shift
7675 # is not an argument.
7676 #
7677 # Side effects: None.
7678 # --------------------------------------------------
7679 170 ▶sub _argument_style {
Subroutine _argument_style: called CC=9 SCAR=22.5
7680 170 my ($self, $code) = @_;
7681  
7682 170 ▶ return '' unless defined $code;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $code 0 170 170
7683  
7684 170 my $body = $code;
7685 170 $body =~ s/\$self\s*->\s*\{[^}]*\}//g;
7686  
7687 170 ▶ return 'named' if($body =~ /\bmy\s+%\w+\s*=[^;]*\@_/s);
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\bmy\s+%\w+\s*=[^;]*\@_/s 0 170 170
7688 170 ▶ return 'named' if($body =~ /\bmy\s*\(\s*[^)]*%\w+\s*\)\s*=\s*\@_/s);
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\bmy\s*\(\s*[^)]*%\w+\s*\)\s*=\s*\@_/s 4 166 170
7689 166 ▶ return 'named' if($body =~ /\$_\s*\[\s*\d+\s*\]\s*(?:->\s*)?\{/);
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\$_\s*\[\s*\d+\s*\]\s*(?:->\s*)?\{/ 0 166 166
7690 166 ▶ return 'named' if($body =~ /\$\w+\s*->\s*\{/);
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\$\w+\s*->\s*\{/ 45 121 166
7691  
7692 121 ▶ return 'positional' if($body =~ /\$_\s*\[\s*\d+\s*\]/);
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\$_\s*\[\s*\d+\s*\]/ 22 99 121
7693 99 ▶ return 'positional' if($body =~ /\bmy\s+\$(?!self\b|class\b)\w+\s*=\s*shift\b/);
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\bmy\s+\$(?!self\b|class\b)\w+\s*=\s*shift\b/ 33 66 99
7694 66 ▶ return 'positional' if($body =~ /\bmy\s*\((?!\s*\$(?:self|class)\s*\))[^)]*\)\s*=\s*\@_/s);
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\bmy\s*\((?!\s*\$(?:self|class)\s*\))[^)]*\)\s*=\s*\@_/s 66 0 66
7695  
7696 0 return '';
7697 }
7698  
7699 # --------------------------------------------------
7700 # _merge_parameter_analyses
7701 #
7702 # Purpose: Merge parameter information from POD,
7703 # code, and signature analysis into a
7704 # single authoritative parameter hashref
7705 # for each parameter.
7706 #
7707 # Entry: $pod - hashref of parameters from POD
7708 # analysis.
7709 # $code - hashref of parameters from
7710 # code analysis.
7711 # $sig - hashref of parameters from
7712 # signature analysis (optional,
7713 # defaults to empty hashref).
7714 #
7715 # Exit: Returns a merged hashref of parameter
7716 # name to spec hashref. Each spec has
7717 # all available information combined,
7718 # with POD taking highest priority,
7719 # code second, and signature filling
7720 # remaining gaps.
7721 #
7722 # Side effects: Logs merged parameter details to
7723 # stdout when verbose is set.
7724 #
7725 # Notes: Position is determined by majority
7726 # vote across all sources, with the
7727 # lowest position winning ties. Optional
7728 # status is determined by
7729 # _determine_optional_status. The single
7730 # _source provenance marker is retained on
7731 # each merged parameter.
7732 # --------------------------------------------------
7733 # --------------------------------------------------
7734 # _sanitize_parameter_names
7735 #
7736 # Purpose: Drop keys that cannot be parameter names, and report them.
7737 #
7738 # Entry: $params - hashref keyed by parameter name; modified in place.
7739 # $where - the analysis stage, for the warning text.
7740 #
7741 # Exit: Number of keys dropped.
7742 #
7743 # Notes: A hashref used where a list of key/value pairs was meant
7744 # stringifies to "HASH(0x...)" and silently becomes a parameter.
7745 # Such a key is never a variable the routine can read, so the
7746 # schema would test an argument that does not exist. Perl hash
7747 # keys are always strings, so the string form is what we see.
7748 #
7749 # Side effects: Emits a carp warning for each dropped key.
7750 # --------------------------------------------------
7751 4323 ▶sub _sanitize_parameter_names {
Subroutine _sanitize_parameter_names: called CC=5 SCAR=16.2
7752 4323 my ($self, $params, $where) = @_;
7753  
7754 4323 my $dropped = 0;
7755 4323 for my $name (keys %$params) {
7756 2994 ▶ my $invalid = ref($name)
Condition66%4/6
ref $name || $name =~ /\A(?:HASH|ARRAY|SCALAR|CODE|GLOB|REF|REGEXP|Regexp|LVALUE|VSTRING|FORMAT|IO)\(0x[0-9a-fA-F]+\)\z/ || $name =~ /\s/
l!l&&r!l&&!r
202992
ref $name or $name =~ /\A(?:HASH|ARRAY|SCALAR|CODE|GLOB|REF|REGEXP|Regexp|LVALUE|VSTRING|FORMAT|IO)\(0x[0-9a-fA-F]+\)\z/
l!l&&r!l&&!r
022992
MC/DC33%1/3
ref $name || $name =~ /\A(?:HASH|ARRAY|SCALAR|CODE|GLOB|REF|REGEXP|Regexp|LVALUE|VSTRING|FORMAT|IO)\(0x[0-9a-fA-F]+\)\z/ || $name =~ /\s/
ref $name $name =~ /\A(?:HASH|ARRAY|SCALAR|CODE|GLOB|REF|REGEXP|Regexp|LVALUE|VSTRING|FORMAT|IO)\(0x[0-9a-fA-F]+\)\z/ $name =~ /\s/
Truth table50%2/4
A or B || C
A= ref $nameB= $name =~ /\A(?:HASH|ARRAY|SCALAR|CODE|GLOB|REF|REGEXP|Regexp|LVALUE|VSTRING|FORMAT|IO)\(0x[0-9a-fA-F]+\)\z/C= $name =~ /\s/
ABCresult
1XX1
01X1
0011
0000
7757 || $name =~ /\A(?:HASH|ARRAY|SCALAR|CODE|GLOB|REF|REGEXP|Regexp|LVALUE|VSTRING|FORMAT|IO)\(0x[0-9a-fA-F]+\)\z/
7758 || $name =~ /\s/;
7759 2994 ▶ next unless $invalid;
Branch: 1 branch
BranchTrueFalseTotal
unless $invalid 2992 2 2994
7760  
7761 2 carp(__PACKAGE__ . ": ignoring parameter key '$name' from $where: not a parameter name");
7762 2 delete $params->{$name};
7763 2 $dropped++;
7764 }
7765  
7766 4323 return $dropped;
7767 }
7768  
7769 750 ▶sub _merge_parameter_analyses {
Subroutine _merge_parameter_analyses: called CC=50 SCAR=45.3
7770 750 my ($self, $pod, $code, $sig) = @_;
7771  
7772 # Belt and braces: every analysis should already be clean, but a merge is
7773 # the last point before these keys become schema parameters.
7774 $self->_sanitize_parameter_names($_, 'parameter merge')
7775 750 for grep { ref($_) eq 'HASH' } ($pod, $code, $sig);
7776  
7777 750 my %merged;
7778  
7779 750 my @constraint_keys = qw(min max memberof matches nomatch notmemberof);
7780 750 my %is_constraint = map { $_ => 1 } @constraint_keys;
7781  
7782 # Start with all parameters from all sources
7783 750 my %all_params = map { $_ => 1 } (keys %$pod, keys %$code, keys %$sig);
7784  
7785 750 foreach my $param (keys %all_params) {
7786 652 my $p = $merged{$param} = {};
7787  
7788 # Collect position from all sources
7789 652 my @positions;
7790 652 ▶ push @positions, $pod->{$param}{position} if $pod->{$param} && defined $pod->{$param}{position};
Branch: 1 branch
BranchTrueFalseTotal
if $pod->{$param} and defined $pod->{$param}{"position"} 217 435 652
Condition100%3/3
$pod->{$param} and defined $pod->{$param}{"position"}
!ll&&!rl&&r
173262217
MC/DC100%2/2
$pod->{$param} and defined $pod->{$param}{"position"}
$pod->{$param} defined $pod->{$param}{"position"}
Truth table100%3/3
A and B
A= $pod->{$param}B= defined $pod->{$param}{"position"}
ABresult
0X0
100
111
7791 652 ▶ push @positions, $sig->{$param}{position} if $sig->{$param} && defined $sig->{$param}{position};
Branch: 1 branch
BranchTrueFalseTotal
if $sig->{$param} and defined $sig->{$param}{"position"} 0 652 652
Condition33%1/3
$sig->{$param} and defined $sig->{$param}{"position"}
!ll&&!rl&&r
65200
MC/DC0%0/2
$sig->{$param} and defined $sig->{$param}{"position"}
$sig->{$param} defined $sig->{$param}{"position"}
Truth table33%1/3
A and B
A= $sig->{$param}B= defined $sig->{$param}{"position"}
ABresult
0X0
100
111
7792 652 ▶ push @positions, $code->{$param}{position} if $code->{$param} && defined $code->{$param}{position};
Branch: 1 branch
BranchTrueFalseTotal
if $code->{$param} and defined $code->{$param}{"position"} 485 167 652
Condition66%2/3
$code->{$param} and defined $code->{$param}{"position"}
!ll&&!rl&&r
1670485
MC/DC50%1/2
$code->{$param} and defined $code->{$param}{"position"}
$code->{$param} defined $code->{$param}{"position"}
Truth table66%2/3
A and B
A= $code->{$param}B= defined $code->{$param}{"position"}
ABresult
0X0
100
111
7793  
7794 # Use the most common position, or lowest if tie
7795 652 ▶ if (@positions) {
Branch: 1 branch
BranchTrueFalseTotal
if (@positions) 490 162 652
7796 490 my %pos_count;
7797 490 $pos_count{$_}++ for @positions;
7798 0 ▶ my ($best_pos) = sort { $pos_count{$b} <=> $pos_count{$a} || $a <=> $b } keys %pos_count;
Condition0%0/3
$pos_count{$b} <=> $pos_count{$a} || $a <=> $b
l!l&&r!l&&!r
000
MC/DC0%0/2
$pos_count{$b} <=> $pos_count{$a} || $a <=> $b
$pos_count{$b} <=> $pos_count{$a} $a <=> $b
Truth table0%0/3
A || B
A= $pos_count{$b} <=> $pos_count{$a}B= $a <=> $b
ABresult
1X1
011
000
7799 490 ▶ $p->{position} = $best_pos unless(exists($p->{position}));
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p->{"position"} 490 0 490
7800 }
7801  
7802 # POD has highest priority for type info and explicit declarations
7803 652 ▶ if ($pod->{$param}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod->{$param}) 479 173 652
7804 479 %$p = (%$p, %{$pod->{$param}});
7805 479 ▶ $p->{_source} //= SOURCE_POD;
Condition100%2/2
$p->{"_source"} //= "pod"
l!l
43841
MC/DC100%1/1
$p->{"_source"} //= "pod"
$p->{"_source"}
Truth table100%2/2
A
A= $p->{"_source"}
Aresult
11
00
7806  
7807 # Record which source each constraint came from, so a documented
7808 # minimum does not make a maximum enforced by the code tolerant.
7809 479 ▶ my $source = $pod->{$param}{_source} // SOURCE_POD;
Condition100%2/2
$pod->{$param}{"_source"} // "pod"
l!l
43841
MC/DC100%1/1
$pod->{$param}{"_source"} // "pod"
$pod->{$param}{"_source"}
Truth table100%2/2
A
A= $pod->{$param}{"_source"}
Aresult
11
00
7810 479 for my $key (@constraint_keys) {
7811 2874 ▶ next unless exists($pod->{$param}{$key}) && defined($pod->{$param}{$key});
Branch: 1 branch
BranchTrueFalseTotal
unless exists $pod->{$param}{$key} and defined $pod->{$param}{$key} 2774 100 2874
Condition66%2/3
exists $pod->{$param}{$key} and defined $pod->{$param}{$key}
!ll&&!rl&&r
27740100
MC/DC50%1/2
exists $pod->{$param}{$key} and defined $pod->{$param}{$key}
exists $pod->{$param}{$key} defined $pod->{$param}{$key}
Truth table66%2/3
A and B
A= exists $pod->{$param}{$key}B= defined $pod->{$param}{$key}
ABresult
0X0
100
111
7812 100 ▶ $p->{_constraint_source}{$key} //= $source;
Condition33%1/3
$p->{"_constraint_source"}{$key} //= $source
l!l&&r!l&&!r
01000
MC/DC0%0/2
$p->{"_constraint_source"}{$key} //= $source
$p->{"_constraint_source"}{$key} $source
Truth table33%1/3
A //= B
A= $p->{"_constraint_source"}{$key}B= $source
ABresult
1X1
011
000
7813 }
7814 }
7815  
7816 # Code analysis adds concrete evidence (but doesn't override POD explicit types)
7817 652 ▶ if ($code->{$param}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code->{$param}) 485 167 652
7818 485 foreach my $key (keys %{$code->{$param}}) {
7819 1990 ▶ next if $key eq '_source';
Branch: 1 branch
BranchTrueFalseTotal
if $key eq "_source" 418 1572 1990
7820 1572 ▶ next if $key eq 'position';
Branch: 1 branch
BranchTrueFalseTotal
if $key eq "position" 485 1087 1572
7821 # Formal input-spec declared this param without a type — author
7822 # intentionally left it unconstrained; don't let code heuristics
7823 # silently fill in a type that would cause wrong-type die tests.
7824 1087 ▶ next if $key eq 'type' && $pod->{$param} && ($pod->{$param}{_source} // '') eq SOURCE_INPUT_SPEC && !defined $pod->{$param}{type};
Branch: 1 branch
BranchTrueFalseTotal
if $key eq "type" and $pod->{$param} and ($pod->{$param}{"_source"} // "") eq "input_spec" and not defined $pod->{$param}{"type"} 0 1087 1087
Condition90%10/11
$key eq "type" and $pod->{$param} and ($pod->{$param}{"_source"} // "") eq "input_spec" and not defined $pod->{$param}{"type"}
!ll&&!rl&&r
9671200
$key eq "type" and $pod->{$param} and ($pod->{$param}{"_source"} // "") eq "input_spec"
!ll&&!rl&&r
91255120
$key eq "type" and $pod->{$param}
!ll&&!rl&&r
82092175
$pod->{$param}{"_source"} // ""
l!l
15520
MC/DC0%0/4
$key eq "type" and $pod->{$param} and ($pod->{$param}{"_source"} // "") eq "input_spec" and not defined $pod->{$param}{"type"}
$key eq "type" $pod->{$param} $pod->{$param}{"_source"} not defined $pod->{$param}{"type"}
Truth table80%4/5
A and B and C and not(D)
A= $key eq "type"B= $pod->{$param}C= $pod->{$param}{"_source"}D= not defined $pod->{$param}{"type"}
ABCDresult
0XXX0
10XX0
110X0
11100
11111
7825  
7826 # Only override if POD didn't provide this info or it's a stronger signal
7827 1087 my $from_pod = exists $pod->{$param};
7828 1087 ▶ if (!exists $p->{$key} ||
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $p->{$key} or $key eq "type" and $from_pod and $p->{"type"} eq "string" and $code->{$param}{$key} ne "string") 748 339 1087
Condition91%11/12
not exists $p->{$key} or $key eq "type" and $from_pod and $p->{"type"} eq "string" and $code->{$param}{$key} ne "string"
l!l&&r!l&&!r
7426339
$key eq "type" and $from_pod and $p->{"type"} eq "string" and $code->{$param}{$key} ne "string"
!ll&&!rl&&r
310296
$key eq "type" and $from_pod and $p->{"type"} eq "string"
!ll&&!rl&&r
18412635
$key eq "type" and $from_pod
!ll&&!rl&&r
1840161
MC/DC80%4/5
not exists $p->{$key} or $key eq "type" and $from_pod and $p->{"type"} eq "string" and $code->{$param}{$key} ne "string"
not exists $p->{$key} $key eq "type" $from_pod $p->{"type"} eq "string" $code->{$param}{$key} ne "string"
Truth table83%5/6
not(A) or B and C and D and E
A= not exists $p->{$key}B= $key eq "type"C= $from_podD= $p->{"type"} eq "string"E= $code->{$param}{$key} ne "string"
ABCDEresult
1XXXX1
011111
00XXX0
010XX0
0110X0
011100
7829 ($key eq 'type' && $from_pod && $p->{type} eq 'string' &&
7830 $code->{$param}{$key} ne 'string')) {
7831 748 $p->{$key} = $code->{$param}{$key};
7832 748 ▶ $p->{_constraint_source}{$key} = SOURCE_CODE if $is_constraint{$key};
Branch: 1 branch
BranchTrueFalseTotal
if $is_constraint{$key} 43 705 748
7833 }
7834 }
7835 485 ▶ $p->{_source} //= $code->{$param}{_source};
Condition100%3/3
$p->{"_source"} //= $code->{$param}{"_source"}
l!l&&r!l&&!r
31215617
MC/DC100%2/2
$p->{"_source"} //= $code->{$param}{"_source"}
$p->{"_source"} $code->{$param}{"_source"}
Truth table100%3/3
A //= B
A= $p->{"_source"}B= $code->{$param}{"_source"}
ABresult
1X1
011
000
7836 }
7837  
7838 # Signature fills in remaining gaps
7839 652 ▶ if ($sig->{$param}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($sig->{$param}) 0 652 652
7840 0 foreach my $key (keys %{$sig->{$param}}) {
7841 0 ▶ next if $key eq '_source';
Branch: 1 branch
BranchTrueFalseTotal
if $key eq "_source" 0 0 0
7842 0 ▶ next if $key eq 'position';
Branch: 1 branch
BranchTrueFalseTotal
if $key eq "position" 0 0 0
7843 0 ▶ next if defined($p->{$key});
Branch: 1 branch
BranchTrueFalseTotal
if defined $p->{$key} 0 0 0
7844 0 $p->{$key} = $sig->{$param}{$key};
7845 0 ▶ $p->{_constraint_source}{$key} = SOURCE_SIGNATURE if $is_constraint{$key};
Branch: 1 branch
BranchTrueFalseTotal
if $is_constraint{$key} 0 0 0
7846 }
7847 0 ▶ $p->{_source} //= $sig->{$param}{_source};
Condition0%0/3
$p->{"_source"} //= $sig->{$param}{"_source"}
l!l&&r!l&&!r
000
MC/DC0%0/2
$p->{"_source"} //= $sig->{$param}{"_source"}
$p->{"_source"} $sig->{$param}{"_source"}
Truth table0%0/3
A //= B
A= $p->{"_source"}B= $sig->{$param}{"_source"}
ABresult
1X1
011
000
7848 }
7849  
7850 # The source is the single provenance decision: validator-backed
7851 # parameters are type-checked, POD/input-spec parameters are
7852 # documentation, and code/signature/field parameters are inferred.
7853  
7854 # Handle optional field with better logic
7855 652 $self->_determine_optional_status($p, $pod->{$param}, $code->{$param});
7856 }
7857  
7858 # Debug logging
7859 750 ▶ if ($self->{verbose}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"verbose"}) 2 748 750
7860 2 ▶ foreach my $param (sort { ($merged{$a}{position} || 999) <=> ($merged{$b}{position} || 999) } keys %merged) {
Condition50%2/4
$merged{$a}{'position'} || 999
l!l
01
$merged{$b}{'position'} || 999
l!l
10
MC/DC0%0/1
$merged{$a}{'position'} || 999
$merged{$a}{'position'}
MC/DC0%0/1
$merged{$b}{'position'} || 999
$merged{$b}{'position'}
Truth table50%1/2
A
A= $merged{$a}{'position'}
Aresult
11
00
Truth table50%1/2
A
A= $merged{$b}{'position'}
Aresult
11
00
7861 2 my $p = $merged{$param};
7862 $self->_log(" MERGED $param: " .
7863 'pos=' . (defined($p->{position}) ? $p->{position} : 'none') .
7864 ", type=" . ($p->{type} || 'none') .
7865 2 ▶ ", optional=" . (defined($p->{optional}) ? $p->{optional} : 'undef'));
Branch: 2 branches
BranchTrueFalseTotal
defined $p->{'position'} ? : 2 0 2
defined $p->{'optional'} ? : 2 0 2
Condition50%1/2
$p->{'type'} || 'none'
l!l
20
MC/DC0%0/1
$p->{'type'} || 'none'
$p->{'type'}
Truth table50%1/2
A
A= $p->{'type'}
Aresult
11
00
7866 }
7867 }
7868  
7869 750 return \%merged;
7870 }
7871  
7872 # --------------------------------------------------
7873 # _determine_optional_status
7874 #
7875 # Purpose: Set the optional field on a merged
7876 # parameter spec based on evidence from
7877 # POD and code analysis, with POD taking
7878 # highest priority.
7879 #
7880 # Entry: $merged_param - the merged parameter
7881 # hashref (modified in
7882 # place).
7883 # $pod_param - parameter spec from
7884 # POD analysis, or undef.
7885 # $code_param - parameter spec from
7886 # code analysis, or undef.
7887 #
7888 # Exit: Returns nothing. Sets or leaves
7889 # $merged_param->{optional}.
7890 #
7891 # Side effects: None.
7892 # --------------------------------------------------
7893 656 ▶sub _determine_optional_status {
Subroutine _determine_optional_status: called CC=6 SCAR=17.9
7894 656 my ($self, $merged_param, $pod_param, $code_param) = @_;
7895  
7896 656 ▶ my $pod_optional = $pod_param ? $pod_param->{optional} : undef;
Branch: 1 branch
BranchTrueFalseTotal
$pod_param ? : 483 173 656
7897 656 ▶ my $code_optional = $code_param ? $code_param->{optional} : undef;
Branch: 1 branch
BranchTrueFalseTotal
$code_param ? : 489 167 656
7898  
7899 # Explicit POD declaration wins
7900 656 ▶ if (defined $pod_optional) {
Branch: 3 branches
BranchTrueFalseTotal
if (defined $pod_optional) { } 307 349 656
elsif (defined $code_optional) { } 307 42 349
elsif (keys %$merged_param > 0) { } 42 0 42
7901 307 $merged_param->{optional} = $pod_optional;
7902 }
7903 # Code validation evidence
7904 elsif (defined $code_optional) {
7905 307 $merged_param->{optional} = $code_optional;
7906 }
7907 # Default: if we have any info about the param, assume required
7908 elsif (keys %$merged_param > 0) {
7909 42 $merged_param->{optional} = 0;
7910 }
7911 # Otherwise leave undef (unknown)
7912 }
7913  
7914  
7915 # --------------------------------------------------
7916 # _calculate_input_confidence
7917 #
7918 # Purpose: Calculate a confidence score and level
7919 # for the input parameter analysis,
7920 # based on how much type, constraint,
7921 # and semantic information was inferred
7922 # for each parameter.
7923 #
7924 # Entry: $params - hashref of merged parameter
7925 # specs as produced by
7926 # _merge_parameter_analyses.
7927 #
7928 # Exit: Returns a hashref with keys:
7929 # level - one of: none,
7930 # very_low, low,
7931 # medium, high
7932 # score - numeric average
7933 # across all params
7934 # factors - arrayref of
7935 # human-readable
7936 # factor strings
7937 # per_parameter - hashref of per-
7938 # parameter score
7939 # and factor detail
7940 # Returns { level => 'none', ... } if
7941 # no parameters were found.
7942 #
7943 # Side effects: None.
7944 # --------------------------------------------------
7945 481 ▶sub _calculate_input_confidence {
Subroutine _calculate_input_confidence: called CC=24 SCAR=31.8
7946 481 my ($self, $params) = @_;
7947  
7948 481 my @factors; # Track all confidence factors
7949  
7950 481 ▶ return { level => 'none', factors => ['No parameters found'] } unless keys %$params;
Branch: 1 branch
BranchTrueFalseTotal
unless keys %$params 178 303 481
7951  
7952 303 my $total_score = 0;
7953 303 my $count = 0;
7954 303 my %param_details; # Store per-parameter analysis
7955  
7956 303 foreach my $param (keys %$params) {
7957 455 my $p = $params->{$param};
7958 455 my $score = 0;
7959 455 my @param_factors;
7960  
7961 # Type information
7962 455 ▶ if ($p->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{'type'}) { } 455 0 455
7963 455 ▶ if ($p->{type} eq 'string' && ($p->{min} || $p->{max} || $p->{matches})) {
Branch: 2 branches
BranchTrueFalseTotal
if ($p->{'type'} eq 'string' and $p->{'min'} || $p->{'max'} || $p->{'matches'}) { } 49 406 455
elsif ($p->{'type'} eq 'string') { } 162 244 406
Condition100%9/9
$p->{"type"} eq "string" and $p->{"min"} || $p->{"max"} || $p->{"matches"}
!ll&&!rl&&r
24416249
$p->{"min"} or $p->{"max"} or $p->{"matches"}
l!l&&r!l&&!r
3910162
$p->{"min"} or $p->{"max"}
l!l&&r!l&&!r
318172
MC/DC100%4/4
$p->{"type"} eq "string" and $p->{"min"} || $p->{"max"} || $p->{"matches"}
$p->{"type"} eq "string" $p->{"min"} $p->{"max"} $p->{"matches"}
Truth table100%5/5
A and B or C or D
A= $p->{"type"} eq "string"B= $p->{"min"}C= $p->{"max"}D= $p->{"matches"}
ABCDresult
0XXX0
10000
11XX1
101X1
10011
7964 49 $score += 25;
7965 49 push @param_factors, "Type: constrained string (+25)";
7966 } elsif ($p->{type} eq 'string') {
7967 162 $score += 10;
7968 162 push @param_factors, "Type: plain string (+10)";
7969 } else {
7970 244 $score += 30;
7971 244 push @param_factors, "Type: $p->{type} (+30)";
7972 }
7973 } else {
7974 0 push @param_factors, "No type information (-0)";
7975 }
7976  
7977 # Constraints
7978 455 ▶ if (defined $p->{min}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $p->{"min"}) 62 393 455
7979 62 $score += 15;
7980 62 push @param_factors, 'Has min constraint (+15)';
7981 }
7982 455 ▶ if (defined $p->{max}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $p->{"max"}) 39 416 455
7983 39 $score += 15;
7984 39 push @param_factors, "Has max constraint (+15)";
7985 }
7986 455 ▶ if (defined $p->{optional}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $p->{"optional"}) 450 5 455
7987 450 $score += 20;
7988 450 push @param_factors, "Optional/required explicitly defined (+20)";
7989 }
7990 455 ▶ if ($p->{matches}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"matches"}) 15 440 455
7991 15 $score += 20;
7992 15 push @param_factors, 'Has regex pattern constraint (+20)';
7993 }
7994 455 ▶ if ($p->{isa}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"isa"}) 41 414 455
7995 41 $score += 25;
7996 41 push @param_factors, "Specific class constraint: $p->{isa} (+25)";
7997 }
7998  
7999 # Position information
8000 455 ▶ if (defined $p->{position}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $p->{"position"}) 312 143 455
8001 312 $score += 10;
8002 312 push @param_factors, "Position defined: $p->{position} (+10)";
8003 }
8004  
8005 # Default value
8006 455 ▶ if (exists $p->{_default}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $p->{"_default"}) 32 423 455
8007 32 $score += 10;
8008 32 push @param_factors, "Has default value (+10)";
8009 }
8010  
8011 # Semantic information
8012 455 ▶ if ($p->{semantic}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"semantic"}) 33 422 455
8013 33 $score += 15;
8014 33 push @param_factors, "Semantic type: $p->{semantic} (+15)";
8015 }
8016  
8017 455 $param_details{$param} = {
8018 score => $score,
8019 factors => \@param_factors
8020 };
8021  
8022 455 $total_score += $score;
8023 455 $count++;
8024 }
8025  
8026 303 ▶ my $avg = $count ? ($total_score / $count) : 0;
Branch: 1 branch
BranchTrueFalseTotal
$count ? : 303 0 303
8027  
8028 # Build summary factors
8029 303 ▶ push @factors, sprintf("Analyzed %d parameter%s", $count, $count == 1 ? '' : 's');
Branch: 1 branch
BranchTrueFalseTotal
$count == 1 ? : 230 73 303
8030 303 push @factors, sprintf("Average confidence score: %.1f", $avg);
8031  
8032 # Add top contributing factors
8033 303 my @sorted_params = sort { $param_details{$b}{score} <=> $param_details{$a}{score} } keys %param_details;
8034  
8035 303 ▶ if (@sorted_params) {
Branch: 1 branch
BranchTrueFalseTotal
if (@sorted_params) 303 0 303
8036 303 my $highest = $sorted_params[0];
8037 303 my $highest_score = $param_details{$highest}{score};
8038 303 push @factors, sprintf("Highest scoring parameter: \$$highest (score: %d)", $highest_score);
8039  
8040 303 ▶ if (@sorted_params > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (@sorted_params > 1) 73 230 303
8041 73 my $lowest = $sorted_params[-1];
8042 73 my $lowest_score = $param_details{$lowest}{score};
8043 73 push @factors, sprintf("Lowest scoring parameter: \$$lowest (score: %d)", $lowest_score);
8044 }
8045 }
8046  
8047 # Determine confidence level
8048 303 my $level;
8049 303 ▶ if ($avg >= $CONFIDENCE_HIGH_THRESHOLD) {
Branch: 3 branches
BranchTrueFalseTotal
if ($avg >= $CONFIDENCE_HIGH_THRESHOLD) { } 217 86 303
elsif ($avg >= $CONFIDENCE_MEDIUM_THRESHOLD) { } 66 20 86
elsif ($avg >= $CONFIDENCE_LOW_THRESHOLD) { } 18 2 20
8050 217 $level = $LEVEL_HIGH;
8051 217 push @factors, "High confidence: comprehensive type and constraint information";
8052 } elsif ($avg >= $CONFIDENCE_MEDIUM_THRESHOLD) {
8053 66 $level = $LEVEL_MEDIUM;
8054 66 push @factors, "Medium confidence: some type or constraint information present";
8055 } elsif ($avg >= $CONFIDENCE_LOW_THRESHOLD) {
8056 18 $level = $LEVEL_LOW;
8057 18 push @factors, "Low confidence: minimal type information";
8058 } else {
8059 2 $level = $LEVEL_VERY_LOW;
8060 2 push @factors, "Very low confidence: little to no type information";
8061 }
8062  
8063 return {
8064 303 level => $level,
8065 score => $avg,
8066 factors => \@factors,
8067 per_parameter => \%param_details
8068 };
8069 }
8070  
8071 # --------------------------------------------------
8072 # _calculate_output_confidence
8073 #
8074 # Purpose: Calculate a confidence score and level
8075 # for the output analysis based on how
8076 # much return type, value, class,
8077 # context, and error convention
8078 # information was determined.
8079 #
8080 # Entry: $output - the output hashref as built
8081 # by _analyze_output.
8082 #
8083 # Exit: Returns a hashref with keys:
8084 # level - one of: none, very_low,
8085 # low, medium, high
8086 # score - numeric confidence score
8087 # factors - arrayref of factor strings
8088 # Returns { level => 'none', ... } if
8089 # output is empty.
8090 #
8091 # Side effects: None.
8092 # --------------------------------------------------
8093 778 ▶sub _calculate_output_confidence {
Subroutine _calculate_output_confidence: called CC=17 SCAR=28.3
8094 778 my ($self, $output) = @_;
8095  
8096 778 my @factors;
8097  
8098 778 ▶ return { level => 'none', factors => ['No return information found'] } unless keys %$output;
Branch: 1 branch
BranchTrueFalseTotal
unless keys %$output 27 751 778
8099  
8100 751 my $score = 0;
8101  
8102 # Type information
8103 751 ▶ if ($output->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{'type'}) { } 744 7 751
8104 744 $score += 30;
8105 744 push @factors, "Return type defined: $output->{type} (+30)";
8106 } else {
8107 7 push @factors, 'No return type information (-0)';
8108 }
8109  
8110 # Specific value known
8111 751 ▶ if (defined $output->{value}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $output->{"value"}) 34 717 751
8112 34 $score += 30;
8113 34 push @factors, "Specific return value: $output->{value} (+30)";
8114 }
8115  
8116 # Class information for objects
8117 751 ▶ if ($output->{isa}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"isa"}) 88 663 751
8118 88 $score += 30;
8119 88 push @factors, "Returns specific class: $output->{isa} (+30)";
8120 }
8121  
8122 # Context-aware returns
8123 751 ▶ if ($output->{_context_aware}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_context_aware"}) 7 744 751
8124 7 $score += 20;
8125 7 push @factors, "Context-aware return (wantarray) (+20)";
8126  
8127 7 ▶ if ($output->{_list_context}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_list_context"}) 7 0 7
8128 7 push @factors, " List context: $output->{_list_context}{type}";
8129 }
8130 7 ▶ if ($output->{_scalar_context}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_scalar_context"}) 6 1 7
8131 6 push @factors, " Scalar context: $output->{_scalar_context}{type}";
8132 }
8133 }
8134  
8135 # Error handling information
8136 751 ▶ if ($output->{_error_return}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_error_return"}) 33 718 751
8137 33 $score += 15;
8138 33 push @factors, "Error return convention documented: $output->{_error_return} (+15)";
8139 }
8140  
8141 # Success/failure pattern
8142 751 ▶ if ($output->{_success_failure_pattern}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_success_failure_pattern"}) 5 746 751
8143 5 $score += 10;
8144 5 push @factors, 'Success/failure pattern detected (+10)';
8145 }
8146  
8147 # Chainable methods
8148 751 ▶ if ($output->{_returns_self}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_returns_self"}) 11 740 751
8149 11 $score += 15;
8150 11 push @factors, "Chainable method (fluent interface) (+15)";
8151 }
8152  
8153 # Void context
8154 751 ▶ if ($output->{_void_context}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_void_context"}) 11 740 751
8155 11 $score += 20;
8156 11 push @factors, "Void context method (no meaningful return) (+20)";
8157 }
8158  
8159 # Exception handling
8160 751 ▶ if ($output->{_error_handling} && $output->{_error_handling}{exception_handling}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($output->{"_error_handling"} and $output->{"_error_handling"}{"exception_handling"}) 20 731 751
Condition100%3/3
$output->{"_error_handling"} and $output->{"_error_handling"}{"exception_handling"}
!ll&&!rl&&r
7032820
MC/DC100%2/2
$output->{"_error_handling"} and $output->{"_error_handling"}{"exception_handling"}
$output->{"_error_handling"} $output->{"_error_handling"}{"exception_handling"}
Truth table100%3/3
A and B
A= $output->{"_error_handling"}B= $output->{"_error_handling"}{"exception_handling"}
ABresult
0X0
100
111
8161 20 $score += 10;
8162 20 push @factors, 'Exception handling present (+10)';
8163 }
8164  
8165 751 push @factors, sprintf("Total output confidence score: %d", $score);
8166  
8167 # Determine confidence level
8168 751 my $level;
8169 751 ▶ if ($score >= $CONFIDENCE_HIGH_THRESHOLD) {
Branch: 3 branches
BranchTrueFalseTotal
if ($score >= $CONFIDENCE_HIGH_THRESHOLD) { } 124 627 751
elsif ($score >= $CONFIDENCE_MEDIUM_THRESHOLD) { } 59 568 627
elsif ($score >= $CONFIDENCE_LOW_THRESHOLD) { } 565 3 568
8170 124 $level = $LEVEL_HIGH;
8171 124 push @factors, "High confidence: detailed return type and behavior";
8172 } elsif ($score >= $CONFIDENCE_MEDIUM_THRESHOLD) {
8173 59 $level = $LEVEL_MEDIUM;
8174 59 push @factors, "Medium confidence: return type defined";
8175 } elsif ($score >= $CONFIDENCE_LOW_THRESHOLD) {
8176 565 $level = $LEVEL_LOW;
8177 565 push @factors, "Low confidence: minimal return information";
8178 } else {
8179 3 $level = $LEVEL_VERY_LOW;
8180 3 push @factors, 'Very low confidence: little return information';
8181 }
8182  
8183 return {
8184 751 level => $level,
8185 score => $score,
8186 factors => \@factors
8187 };
8188 }
8189  
8190 # --------------------------------------------------
8191 # _generate_confidence_report
8192 #
8193 # Purpose: Generate a human-readable text report
8194 # of all confidence factors for a
8195 # schema, for debugging and review
8196 # purposes.
8197 #
8198 # Entry: $schema - schema hashref containing
8199 # a populated _analysis key.
8200 #
8201 # Exit: Returns a multi-line string report,
8202 # or nothing if $schema->{_analysis}
8203 # is absent.
8204 #
8205 # Side effects: None.
8206 # --------------------------------------------------
8207 sub _generate_confidence_report
8208 0 ▶{
Subroutine _generate_confidence_report: not called CC=10 SCAR=47.0
8209 0 my ($self, $schema) = @_;
8210  
8211 0 ▶ return unless $schema->{_analysis};
Branch: 1 branch
BranchTrueFalseTotal
unless $schema->{"_analysis"} 0 0 0
8212  
8213 0 my $analysis = $schema->{_analysis};
8214 0 my @report;
8215  
8216 0 ▶ push @report, "Confidence Analysis for " . ($schema->{method_name} || 'method');
Condition0%0/2
$schema->{'method_name'} || 'method'
l!l
00
MC/DC0%0/1
$schema->{'method_name'} || 'method'
$schema->{'method_name'}
Truth table0%0/2
A
A= $schema->{'method_name'}
Aresult
11
00
8217 0 push @report, '=' x 60;
8218 0 push @report, '';
8219  
8220 0 push @report, "Overall Confidence: " . uc($analysis->{overall_confidence});
8221 0 push @report, '';
8222  
8223 0 ▶ if ($analysis->{confidence_factors}{input}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($analysis->{"confidence_factors"}{"input"}) 0 0 0
8224 push @report, (
8225 "Input Parameters:",
8226 " Confidence Level: " . uc($analysis->{input_confidence})
8227 0 );
8228 0 foreach my $factor (@{$analysis->{confidence_factors}{input}}) {
8229 0 push @report, " - $factor";
8230 }
8231 0 push @report, '';
8232 }
8233  
8234 0 ▶ if ($analysis->{confidence_factors}{output}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($analysis->{"confidence_factors"}{"output"}) 0 0 0
8235 push @report, 'Return Value:',
8236 0 " Confidence Level: " . uc($analysis->{output_confidence});
8237 0 foreach my $factor (@{$analysis->{confidence_factors}{output}}) {
8238 0 push @report, " - $factor";
8239 }
8240 0 push @report, '';
8241 }
8242  
8243 0 ▶ if ($analysis->{per_parameter_scores}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($analysis->{"per_parameter_scores"}) 0 0 0
8244 0 push @report, 'Per-Parameter Analysis:';
8245 0 foreach my $param (sort keys %{$analysis->{per_parameter_scores}}) {
8246 0 my $details = $analysis->{per_parameter_scores}{$param};
8247 0 push @report, " \$$param (score: $details->{score}):";
8248 0 foreach my $factor (@{$details->{factors}}) {
8249 0 push @report, " - $factor";
8250 }
8251 }
8252 0 push @report, '';
8253 }
8254  
8255 0 return join("\n", @report);
8256 }
8257  
8258 # --------------------------------------------------
8259 # _generate_notes
8260 #
8261 # Purpose: Generate human-readable advisory notes
8262 # about parameters whose type or
8263 # optionality could not be determined,
8264 # to guide manual schema review.
8265 #
8266 # Entry: $params - hashref of merged parameter
8267 # specs.
8268 #
8269 # Exit: Returns an arrayref of note strings.
8270 # Returns an empty arrayref if all
8271 # parameters have known types and
8272 # optionality.
8273 #
8274 # Side effects: None.
8275 # --------------------------------------------------
8276 767 ▶sub _generate_notes {
Subroutine _generate_notes: called CC=4 SCAR=13.9
8277 767 my ($self, $params) = @_;
8278  
8279 767 my @notes;
8280  
8281 767 foreach my $param (sort keys %$params) {
8282 678 my $p = $params->{$param};
8283  
8284 678 ▶ unless ($p->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($p->{"type"}) 100 578 678
8285 100 push @notes, "$param: type unknown - please review - will set to 'string' as a default";
8286 }
8287  
8288 678 ▶ unless (defined $p->{optional}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $p->{"optional"}) 17 661 678
8289 17 push @notes, "$param: optional status unknown";
8290 # Don't automatically set - let it be undef if we don't know
8291 }
8292 }
8293  
8294 767 return \@notes;
8295 }
8296  
8297 # --------------------------------------------------
8298 # _set_defaults
8299 #
8300 # Purpose: Apply default type values to any
8301 # parameters in a schema mode (input
8302 # or output) whose type was not set
8303 # during analysis, setting them to
8304 # 'string' as a conservative fallback.
8305 #
8306 # Entry: $schema - the schema hashref being
8307 # built by _analyze_method.
8308 # $mode - either 'input' or 'output'.
8309 #
8310 # Exit: Returns nothing. Modifies $schema in
8311 # place by setting type => 'string' on
8312 # any parameter that lacks a type, and
8313 # downgrading input confidence to 'low'.
8314 #
8315 # Side effects: Logs type defaulting to stdout when
8316 # verbose is set.
8317 #
8318 # Notes: Called after all analysis is complete
8319 # so that genuine type unknowns can be
8320 # distinguished from analysis gaps.
8321 # --------------------------------------------------
8322 1528 ▶sub _set_defaults {
Subroutine _set_defaults: called CC=4 SCAR=13.9
8323 1528 my ($self, $schema, $mode) = @_;
8324  
8325 1528 my $params = $schema->{$mode};
8326  
8327 1528 foreach my $param (keys %$params) {
8328 1859 my $p = $params->{$param};
8329  
8330 1859 ▶ next unless(ref($p) eq 'HASH');
Branch: 1 branch
BranchTrueFalseTotal
unless ref $p eq "HASH" 1122 737 1859
8331 737 ▶ unless ($p->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($p->{"type"}) 147 590 737
8332 147 $self->_log(" DEBUG {$mode}{$param}: Setting to 'string' as a default");
8333 147 $p->{'type'} = 'string';
8334 147 $schema->{_confidence}{$mode}->{level} = 'low'; # Setting a default means it's a guess
8335 }
8336 }
8337 }
8338  
8339 # --------------------------------------------------
8340 # _analyze_relationships
8341 #
8342 # Purpose: Detect inter-parameter relationships
8343 # in a method's source code, including
8344 # mutually exclusive parameters, required
8345 # groups, conditional requirements,
8346 # dependencies, and value-based
8347 # constraints.
8348 #
8349 # Entry: $method - method hashref containing
8350 # at minimum a 'body' key
8351 # with the source string.
8352 #
8353 # Exit: Returns an arrayref of relationship
8354 # hashrefs. Returns an empty arrayref
8355 # if no parameters or no relationships
8356 # are found.
8357 #
8358 # Side effects: Logs detections to stdout when
8359 # verbose is set.
8360 #
8361 # Notes: Parameter names are extracted via
8362 # _extract_parameters_from_signature, so
8363 # every style it supports -- my (...) =
8364 # @_, shift-style (my $x = shift), direct-
8365 # index ($_[N]), and modern signatures --
8366 # is analysed for relationships, not just
8367 # the my (...) = @_ list-assignment form.
8368 # --------------------------------------------------
8369 764 ▶sub _analyze_relationships {
Subroutine _analyze_relationships: called CC=2 SCAR=6.9
8370 764 my ($self, $method) = @_;
8371  
8372 764 my $code = $method->{body};
8373 764 my @relationships;
8374  
8375 # Extract all parameter names from the method, using the same
8376 # multi-style detection used for schema population so shift-style
8377 # and modern-signature methods get relationship analysis too
8378 my %params;
8379 764 $self->_extract_parameters_from_signature(\%params, $code);
8380 764 my @param_names = sort { $params{$a}{position} <=> $params{$b}{position} } keys %params;
8381  
8382 764 ▶ return [] unless @param_names;
Branch: 1 branch
BranchTrueFalseTotal
unless @param_names 455 309 764
8383  
8384 # Detect mutually exclusive parameters
8385 309 push @relationships, @{$self->_detect_mutually_exclusive($code, \@param_names)};
8386  
8387 # Detect required groups (OR logic)
8388 309 push @relationships, @{$self->_detect_required_groups($code, \@param_names)};
8389  
8390 # Detect conditional requirements (IF-THEN)
8391 309 push @relationships, @{$self->_detect_conditional_requirements($code, \@param_names)};
8392  
8393 # Detect dependencies
8394 309 push @relationships, @{$self->_detect_dependencies($code, \@param_names)};
8395  
8396 # Detect value-based constraints
8397 309 push @relationships, @{$self->_detect_value_constraints($code, \@param_names)};
8398  
8399 # Deduplicate relationships
8400 309 my @unique = $self->_deduplicate_relationships(\@relationships);
8401  
8402 309 return \@unique;
8403 }
8404  
8405 # --------------------------------------------------
8406 # _deduplicate_relationships
8407 #
8408 # Purpose: Remove duplicate relationship entries
8409 # from the relationships list by
8410 # computing a canonical signature for
8411 # each relationship type.
8412 #
8413 # Entry: $relationships - arrayref of
8414 # relationship hashrefs.
8415 #
8416 # Exit: Returns a deduplicated list of
8417 # relationship hashrefs.
8418 #
8419 # Side effects: None.
8420 # --------------------------------------------------
8421 313 ▶sub _deduplicate_relationships {
Subroutine _deduplicate_relationships: called CC=9 SCAR=22.0
8422 313 my ($self, $relationships) = @_;
8423  
8424 313 my @unique;
8425 my %seen;
8426  
8427 313 foreach my $rel (@$relationships) {
8428 # Create a signature for this relationship
8429 26 my $sig;
8430 26 ▶ if ($rel->{type} eq 'mutually_exclusive') {
Branch: 6 branches
BranchTrueFalseTotal
if ($rel->{'type'} eq 'mutually_exclusive') { } 9 17 26
elsif ($rel->{'type'} eq 'required_group') { } 4 13 17
elsif ($rel->{'type'} eq 'conditional_requirement') { } 7 6 13
elsif ($rel->{'type'} eq 'dependency') { } 3 3 6
elsif ($rel->{'type'} eq 'value_constraint') { } 2 1 3
elsif ($rel->{'type'} eq 'value_conditional') { } 1 0 1
8431 9 $sig = join(':', 'mutex', sort @{$rel->{params}});
8432 } elsif ($rel->{type} eq 'required_group') {
8433 4 $sig = join(':', 'reqgroup', sort @{$rel->{params}});
8434 } elsif ($rel->{type} eq 'conditional_requirement') {
8435 7 $sig = join(':', 'condreq', $rel->{if}, $rel->{then_required});
8436 } elsif ($rel->{type} eq 'dependency') {
8437 3 $sig = join(':', 'dep', $rel->{param}, $rel->{requires});
8438 } elsif ($rel->{type} eq 'value_constraint') {
8439 2 $sig = join(':', 'valcon', $rel->{if}, $rel->{then}, $rel->{operator}, $rel->{value});
8440 } elsif ($rel->{type} eq 'value_conditional') {
8441 1 $sig = join(':', 'valcond', $rel->{if}, $rel->{equals}, $rel->{then_required});
8442 } else {
8443 0 $sig = join(':', $rel->{type}, %$rel);
8444 }
8445  
8446 26 ▶ unless ($seen{$sig}++) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($seen{$sig}++) 20 6 26
8447 20 push @unique, $rel;
8448 }
8449 }
8450  
8451 313 return @unique;
8452 }
8453  
8454 # --------------------------------------------------
8455 # _detect_mutually_exclusive
8456 #
8457 # Purpose: Detect pairs of parameters that cannot
8458 # be specified together, by searching
8459 # for die/croak/confess patterns
8460 # that fire when both are truthy.
8461 #
8462 # Entry: $code - method body source string.
8463 # $param_names - arrayref of parameter
8464 # name strings.
8465 #
8466 # Exit: Returns an arrayref of relationship
8467 # hashrefs of type 'mutually_exclusive'.
8468 # Returns an empty arrayref if none found.
8469 #
8470 # Side effects: Logs detections to stdout when
8471 # verbose is set.
8472 # --------------------------------------------------
8473 312 ▶sub _detect_mutually_exclusive {
Subroutine _detect_mutually_exclusive: called CC=18 SCAR=30.2
8474 312 my ($self, $code, $param_names) = @_;
8475  
8476 312 my @relationships;
8477  
8478 # Pattern 1: die/croak if $x && $y
8479 # Look for: die/croak ... if $param1 && $param2
8480 312 foreach my $param1 (@$param_names) {
8481 430 foreach my $param2 (@$param_names) {
8482 846 ▶ next if $param1 eq $param2;
Branch: 1 branch
BranchTrueFalseTotal
if $param1 eq $param2 430 416 846
8483  
8484 # Check various patterns
8485 416 ▶ if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2/ or $code =~ /(?:die|croak|confess)[^;]*if\s+\$$param2\s+&&\s+\$$param1/) 12 404 416
Condition100%3/3
$code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2/ or $code =~ /(?:die|croak|confess)[^;]*if\s+\$$param2\s+&&\s+\$$param1/
l!l&&r!l&&!r
66404
MC/DC100%2/2
$code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2/ or $code =~ /(?:die|croak|confess)[^;]*if\s+\$$param2\s+&&\s+\$$param1/
$code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2/ $code =~ /(?:die|croak|confess)[^;]*if\s+\$$param2\s+&&\s+\$$param1/
Truth table100%3/3
A or B
A= $code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2/B= $code =~ /(?:die|croak|confess)[^;]*if\s+\$$param2\s+&&\s+\$$param1/
ABresult
1X1
011
000
8486 $code =~ /(?:die|croak|confess)[^;]*if\s+\$$param2\s+&&\s+\$$param1/) {
8487  
8488 # Avoid duplicates (param1,param2 vs param2,param1)
8489 12 my $found_reverse = 0;
8490 12 foreach my $rel (@relationships) {
8491 8 ▶ if ($rel->{type} eq 'mutually_exclusive' &&
Branch: 1 branch
BranchTrueFalseTotal
if ($rel->{"type"} eq "mutually_exclusive" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)) 6 2 8
Condition66%4/6
$rel->{"type"} eq "mutually_exclusive" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
!ll&&!rl&&r
026
$rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1
!ll&&!rl&&r
206
MC/DC33%1/3
$rel->{"type"} eq "mutually_exclusive" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
$rel->{"type"} eq "mutually_exclusive" $rel->{"params"}[0] eq $param2 $rel->{"params"}[1] eq $param1
Truth table50%2/4
A and B and C
A= $rel->{"type"} eq "mutually_exclusive"B= $rel->{"params"}[0] eq $param2C= $rel->{"params"}[1] eq $param1
ABCresult
0XX0
10X0
1100
1111
8492 (($rel->{params}[0] eq $param2 && $rel->{params}[1] eq $param1))) {
8493 6 $found_reverse = 1;
8494 6 last;
8495 }
8496 }
8497  
8498 12 ▶ next if $found_reverse;
Branch: 1 branch
BranchTrueFalseTotal
if $found_reverse 6 6 12
8499  
8500 6 push @relationships, {
8501 type => 'mutually_exclusive',
8502 params => [$param1, $param2],
8503 description => "Cannot specify both $param1 and $param2"
8504 };
8505  
8506 6 $self->_log(" RELATIONSHIP: $param1 and $param2 are mutually exclusive");
8507 }
8508  
8509 # Pattern 2: die "Cannot specify both X and Y"
8510 410 ▶ if ($code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*$param1[^'"]*$param2/i ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param1}[^'"]*$param2/i or $code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param2}[^'"]*$param1/i) 1 409 410
Condition66%2/3
$code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param1}[^'"]*$param2/i or $code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param2}[^'"]*$param1/i
l!l&&r!l&&!r
10409
MC/DC50%1/2
$code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param1}[^'"]*$param2/i or $code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param2}[^'"]*$param1/i
$code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param1}[^'"]*$param2/i $code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param2}[^'"]*$param1/i
Truth table66%2/3
A or B
A= $code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param1}[^'"]*$param2/iB= $code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*${param2}[^'"]*$param1/i
ABresult
1X1
011
000
8511 $code =~ /(?:die|croak|confess)\s+['"](Cannot|Can't)[^'"]*both[^'"]*$param2[^'"]*$param1/i) {
8512  
8513 1 my $found_reverse = 0;
8514 1 foreach my $rel (@relationships) {
8515 1 ▶ if ($rel->{type} eq 'mutually_exclusive' &&
Branch: 1 branch
BranchTrueFalseTotal
if ($rel->{"type"} eq "mutually_exclusive" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)) 0 1 1
Condition33%2/6
$rel->{"type"} eq "mutually_exclusive" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
!ll&&!rl&&r
010
$rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1
!ll&&!rl&&r
100
MC/DC0%0/3
$rel->{"type"} eq "mutually_exclusive" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
$rel->{"type"} eq "mutually_exclusive" $rel->{"params"}[0] eq $param2 $rel->{"params"}[1] eq $param1
Truth table25%1/4
A and B and C
A= $rel->{"type"} eq "mutually_exclusive"B= $rel->{"params"}[0] eq $param2C= $rel->{"params"}[1] eq $param1
ABCresult
0XX0
10X0
1100
1111
8516 (($rel->{params}[0] eq $param2 && $rel->{params}[1] eq $param1))) {
8517 0 $found_reverse = 1;
8518 0 last;
8519 }
8520 }
8521  
8522 1 ▶ next if $found_reverse;
Branch: 1 branch
BranchTrueFalseTotal
if $found_reverse 0 1 1
8523  
8524 1 push @relationships, {
8525 type => 'mutually_exclusive',
8526 params => [$param1, $param2],
8527 description => "Cannot specify both $param1 and $param2"
8528 };
8529  
8530 1 $self->_log(" RELATIONSHIP: $param1 and $param2 are mutually exclusive (from error message)");
8531 }
8532 }
8533 }
8534  
8535 312 return \@relationships;
8536 }
8537  
8538 # --------------------------------------------------
8539 # _detect_required_groups
8540 #
8541 # Purpose: Detect parameter groups where at least
8542 # one parameter must be specified (OR
8543 # logic), by searching for die/croak
8544 # patterns that fire unless any of the
8545 # group is truthy.
8546 #
8547 # Entry: $code - method body source string.
8548 # $param_names - arrayref of parameter
8549 # name strings.
8550 #
8551 # Exit: Returns an arrayref of relationship
8552 # hashrefs of type 'required_group'.
8553 # Returns an empty arrayref if none found.
8554 #
8555 # Side effects: Logs detections to stdout when
8556 # verbose is set.
8557 # --------------------------------------------------
8558 311 ▶sub _detect_required_groups {
Subroutine _detect_required_groups: called CC=18 SCAR=31.4
8559 311 my ($self, $code, $param_names) = @_;
8560  
8561 311 my @relationships;
8562  
8563 # Pattern 1: die/croak unless $x || $y
8564 311 foreach my $param1 (@$param_names) {
8565 428 foreach my $param2 (@$param_names) {
8566 842 ▶ next if $param1 eq $param2;
Branch: 1 branch
BranchTrueFalseTotal
if $param1 eq $param2 428 414 842
8567  
8568 414 ▶ if ($code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param1\s+\|\|\s+\$$param2/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param1\s+\|\|\s+\$$param2/ or $code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param2\s+\|\|\s+\$$param1/) 6 408 414
Condition100%3/3
$code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param1\s+\|\|\s+\$$param2/ or $code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param2\s+\|\|\s+\$$param1/
l!l&&r!l&&!r
33408
MC/DC100%2/2
$code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param1\s+\|\|\s+\$$param2/ or $code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param2\s+\|\|\s+\$$param1/
$code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param1\s+\|\|\s+\$$param2/ $code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param2\s+\|\|\s+\$$param1/
Truth table100%3/3
A or B
A= $code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param1\s+\|\|\s+\$$param2/B= $code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param2\s+\|\|\s+\$$param1/
ABresult
1X1
011
000
8569 $code =~ /(?:die|croak|confess)[^;]*unless\s+\$$param2\s+\|\|\s+\$$param1/) {
8570  
8571 # Avoid duplicates
8572 6 my $found_reverse = 0;
8573 6 foreach my $rel (@relationships) {
8574 3 ▶ if ($rel->{type} eq 'required_group' &&
Branch: 1 branch
BranchTrueFalseTotal
if ($rel->{"type"} eq "required_group" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)) 3 0 3
Condition33%2/6
$rel->{"type"} eq "required_group" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
!ll&&!rl&&r
003
$rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1
!ll&&!rl&&r
003
MC/DC0%0/3
$rel->{"type"} eq "required_group" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
$rel->{"type"} eq "required_group" $rel->{"params"}[0] eq $param2 $rel->{"params"}[1] eq $param1
Truth table25%1/4
A and B and C
A= $rel->{"type"} eq "required_group"B= $rel->{"params"}[0] eq $param2C= $rel->{"params"}[1] eq $param1
ABCresult
0XX0
10X0
1100
1111
8575 (($rel->{params}[0] eq $param2 && $rel->{params}[1] eq $param1))) {
8576 3 $found_reverse = 1;
8577 3 last;
8578 }
8579 }
8580  
8581 6 ▶ next if $found_reverse;
Branch: 1 branch
BranchTrueFalseTotal
if $found_reverse 3 3 6
8582  
8583 3 push @relationships, {
8584 type => 'required_group',
8585 params => [$param1, $param2],
8586 logic => 'or',
8587 description => "Must specify either $param1 or $param2"
8588 };
8589  
8590 3 $self->_log(" RELATIONSHIP: Must specify either $param1 or $param2");
8591 }
8592  
8593 # Pattern 2: die "Must specify either X or Y"
8594 411 ▶ if ($code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*$param1[^'"]*or[^'"]*$param2/i ||
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param1}[^'"]*or[^'"]*$param2/i or $code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param2}[^'"]*or[^'"]*$param1/i) 1 410 411
Condition66%2/3
$code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param1}[^'"]*or[^'"]*$param2/i or $code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param2}[^'"]*or[^'"]*$param1/i
l!l&&r!l&&!r
10410
MC/DC50%1/2
$code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param1}[^'"]*or[^'"]*$param2/i or $code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param2}[^'"]*or[^'"]*$param1/i
$code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param1}[^'"]*or[^'"]*$param2/i $code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param2}[^'"]*or[^'"]*$param1/i
Truth table66%2/3
A or B
A= $code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param1}[^'"]*or[^'"]*$param2/iB= $code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*${param2}[^'"]*or[^'"]*$param1/i
ABresult
1X1
011
000
8595 $code =~ /(?:die|croak|confess)\s+['"]Must\s+specify\s+either[^'"]*$param2[^'"]*or[^'"]*$param1/i) {
8596  
8597 1 my $found_reverse = 0;
8598 1 foreach my $rel (@relationships) {
8599 1 ▶ if ($rel->{type} eq 'required_group' &&
Branch: 1 branch
BranchTrueFalseTotal
if ($rel->{"type"} eq "required_group" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)) 0 1 1
Condition33%2/6
$rel->{"type"} eq "required_group" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
!ll&&!rl&&r
010
$rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1
!ll&&!rl&&r
100
MC/DC0%0/3
$rel->{"type"} eq "required_group" and ($rel->{"params"}[0] eq $param2 and $rel->{"params"}[1] eq $param1)
$rel->{"type"} eq "required_group" $rel->{"params"}[0] eq $param2 $rel->{"params"}[1] eq $param1
Truth table25%1/4
A and B and C
A= $rel->{"type"} eq "required_group"B= $rel->{"params"}[0] eq $param2C= $rel->{"params"}[1] eq $param1
ABCresult
0XX0
10X0
1100
1111
8600 (($rel->{params}[0] eq $param2 && $rel->{params}[1] eq $param1))) {
8601 0 $found_reverse = 1;
8602 0 last;
8603 }
8604 }
8605  
8606 1 ▶ next if $found_reverse;
Branch: 1 branch
BranchTrueFalseTotal
if $found_reverse 0 1 1
8607  
8608 1 push @relationships, {
8609 type => 'required_group',
8610 params => [$param1, $param2],
8611 logic => 'or',
8612 description => "Must specify either $param1 or $param2"
8613 };
8614  
8615 1 $self->_log(" RELATIONSHIP: Must specify either $param1 or $param2 (from error message)");
8616 }
8617 }
8618 }
8619  
8620 311 return \@relationships;
8621 }
8622  
8623 # --------------------------------------------------
8624 # _detect_conditional_requirements
8625 #
8626 # Purpose: Detect IF-THEN parameter relationships
8627 # where one parameter being present
8628 # makes another required, by searching
8629 # for die/croak patterns of the form
8630 # 'die if $x && !$y'.
8631 #
8632 # Entry: $code - method body source string.
8633 # $param_names - arrayref of parameter
8634 # name strings.
8635 #
8636 # Exit: Returns an arrayref of relationship
8637 # hashrefs of type
8638 # 'conditional_requirement'.
8639 # Returns an empty arrayref if none found.
8640 #
8641 # Side effects: Logs detections to stdout when
8642 # verbose is set.
8643 # --------------------------------------------------
8644 311 ▶sub _detect_conditional_requirements {
Subroutine _detect_conditional_requirements: called CC=7 SCAR=19.6
8645 311 my ($self, $code, $param_names) = @_;
8646  
8647 311 my @relationships;
8648  
8649 311 foreach my $param1 (@$param_names) {
8650 428 foreach my $param2 (@$param_names) {
8651 842 ▶ next if $param1 eq $param2;
Branch: 1 branch
BranchTrueFalseTotal
if $param1 eq $param2 428 414 842
8652  
8653 # Pattern 1: die if $x && !$y (if x then y required)
8654 414 ▶ if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+!\$$param2/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+!\$$param2/) 4 410 414
8655 4 push @relationships, {
8656 type => 'conditional_requirement',
8657 if => $param1,
8658 then_required => $param2,
8659 description => "When $param1 is specified, $param2 is required"
8660 };
8661  
8662 4 $self->_log(" RELATIONSHIP: $param1 requires $param2");
8663 }
8664  
8665 # Pattern 2: die if $x && !defined($y)
8666 414 ▶ if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+!defined\s*\(\s*\$$param2\s*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+!defined\s*\(\s*\$$param2\s*\)/) 0 414 414
8667 0 push @relationships, {
8668 type => 'conditional_requirement',
8669 if => $param1,
8670 then_required => $param2,
8671 description => "When $param1 is specified, $param2 is required"
8672 };
8673  
8674 0 $self->_log(" RELATIONSHIP: $param1 requires $param2 (defined check)");
8675 }
8676  
8677 # Pattern 3: Error message "X requires Y"
8678 414 ▶ if ($code =~ /(?:die|croak|confess)\s+['"]\w*$param1[^'"]*requires[^'"]*$param2/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)\s+['"]\w*${param1}[^'"]*requires[^'"]*$param2/i) 4 410 414
8679 4 push @relationships, {
8680 type => 'conditional_requirement',
8681 if => $param1,
8682 then_required => $param2,
8683 description => "When $param1 is specified, $param2 is required"
8684 };
8685  
8686 4 $self->_log(" RELATIONSHIP: $param1 requires $param2 (from error message)");
8687 }
8688 }
8689 }
8690  
8691 311 return \@relationships;
8692 }
8693  
8694 # --------------------------------------------------
8695 # _detect_dependencies
8696 #
8697 # Purpose: Detect simple parameter dependencies
8698 # where one parameter requires another
8699 # to also be present, by combining
8700 # error message pattern matching with
8701 # code condition matching.
8702 #
8703 # Entry: $code - method body source string.
8704 # $param_names - arrayref of parameter
8705 # name strings.
8706 #
8707 # Exit: Returns an arrayref of relationship
8708 # hashrefs of type 'dependency'.
8709 # Returns an empty arrayref if none found.
8710 #
8711 # Side effects: Logs detections to stdout when
8712 # verbose is set.
8713 # --------------------------------------------------
8714 313 ▶sub _detect_dependencies {
Subroutine _detect_dependencies: called CC=6 SCAR=17.9
8715 313 my ($self, $code, $param_names) = @_;
8716  
8717 313 my @relationships;
8718  
8719 313 foreach my $param1 (@$param_names) {
8720 432 foreach my $param2 (@$param_names) {
8721 850 ▶ next if $param1 eq $param2;
Branch: 1 branch
BranchTrueFalseTotal
if $param1 eq $param2 432 418 850
8722  
8723 # Pattern 1: Error message mentions "X requires Y" AND code checks $x && !$y
8724 # Split into two checks to be more flexible
8725 418 ▶ if (($code =~ /(?:die|croak|confess)\s+['"]\w*$param1[^'"]*requires[^'"]*$param2/i) &&
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)\s+['"]\w*${param1}[^'"]*requires[^'"]*$param2/i and $code =~ /if\s+\$$param1\s+&&\s+!\$$param2/) 6 412 418
Condition100%3/3
$code =~ /(?:die|croak|confess)\s+['"]\w*${param1}[^'"]*requires[^'"]*$param2/i and $code =~ /if\s+\$$param1\s+&&\s+!\$$param2/
!ll&&!rl&&r
41026
MC/DC100%2/2
$code =~ /(?:die|croak|confess)\s+['"]\w*${param1}[^'"]*requires[^'"]*$param2/i and $code =~ /if\s+\$$param1\s+&&\s+!\$$param2/
$code =~ /(?:die|croak|confess)\s+['"]\w*${param1}[^'"]*requires[^'"]*$param2/i $code =~ /if\s+\$$param1\s+&&\s+!\$$param2/
Truth table100%3/3
A and B
A= $code =~ /(?:die|croak|confess)\s+['"]\w*${param1}[^'"]*requires[^'"]*$param2/iB= $code =~ /if\s+\$$param1\s+&&\s+!\$$param2/
ABresult
0X0
100
111
8726 ($code =~ /if\s+\$$param1\s+&&\s+!\$$param2/)) {
8727  
8728 6 push @relationships, {
8729 type => 'dependency',
8730 param => $param1,
8731 requires => $param2,
8732 description => "$param1 requires $param2 to be specified"
8733 };
8734  
8735 6 $self->_log(" RELATIONSHIP: $param1 depends on $param2");
8736 }
8737 }
8738 }
8739  
8740 313 return \@relationships;
8741 }
8742  
8743 # --------------------------------------------------
8744 # _detect_value_constraints
8745 #
8746 # Purpose: Detect value-based constraints between
8747 # parameters, such as 'if $ssl then
8748 # $port must equal 443' or 'if $mode
8749 # eq secure then $key is required'.
8750 #
8751 # Entry: $code - method body source string.
8752 # $param_names - arrayref of parameter
8753 # name strings.
8754 #
8755 # Exit: Returns an arrayref of relationship
8756 # hashrefs of type 'value_constraint'
8757 # or 'value_conditional'.
8758 # Returns an empty arrayref if none found.
8759 #
8760 # Side effects: Logs detections to stdout when
8761 # verbose is set.
8762 # --------------------------------------------------
8763 309 ▶sub _detect_value_constraints {
Subroutine _detect_value_constraints: called CC=7 SCAR=19.7
8764 309 my ($self, $code, $param_names) = @_;
8765  
8766 309 my @relationships;
8767  
8768 309 foreach my $param1 (@$param_names) {
8769 424 foreach my $param2 (@$param_names) {
8770 834 ▶ next if $param1 eq $param2;
Branch: 1 branch
BranchTrueFalseTotal
if $param1 eq $param2 424 410 834
8771  
8772 # Pattern 1: die if $x && $y != value
8773 410 ▶ if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2\s*!=\s*(\d+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2\s*!=\s*(\d+)/) 2 408 410
8774 2 my $value = $1;
8775 2 push @relationships, {
8776 type => 'value_constraint',
8777 if => $param1,
8778 then => $param2,
8779 operator => '==',
8780 value => $value,
8781 description => "When $param1 is specified, $param2 must equal $value"
8782 };
8783  
8784 2 $self->_log(" RELATIONSHIP: $param1 requires $param2 == $value");
8785 }
8786  
8787 # Pattern 2: die if $x && $y < value
8788 410 ▶ if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2\s*<\s*(\d+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+&&\s+\$$param2\s*<\s*(\d+)/) 0 410 410
8789 0 my $value = $1;
8790 0 push @relationships, {
8791 type => 'value_constraint',
8792 if => $param1,
8793 then => $param2,
8794 operator => '>=',
8795 value => $value,
8796 description => "When $param1 is specified, $param2 must be >= $value"
8797 };
8798  
8799 0 $self->_log(" RELATIONSHIP: $param1 requires $param2 >= $value");
8800 }
8801  
8802 # Pattern 3: die if $x eq 'value' && !$y
8803 410 ▶ if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+eq\s+['"]([^'"]+)['"]\s+&&\s+!\$$param2/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /(?:die|croak|confess)[^;]*if\s+\$$param1\s+eq\s+['"]([^'"]+)['"]\s+&&\s+!\$$param2/) 1 409 410
8804 1 my $value = $1;
8805 1 push @relationships, {
8806 type => 'value_conditional',
8807 if => $param1,
8808 equals => $value,
8809 then_required => $param2,
8810 description => "When $param1 equals '$value', $param2 is required"
8811 };
8812  
8813 1 $self->_log(" RELATIONSHIP: $param1='$value' requires $param2");
8814 }
8815 }
8816 }
8817  
8818 309 return \@relationships;
8819 }
8820  
8821 # Write a single method schema to a YAML file in output_dir.
8822 #
8823 # Entry: $method_name is a non-empty string; $schema is a hashref.
8824 # Exit: YAML file written to output_dir/$method_name.yml.
8825 # Side effects: Creates output_dir if it does not exist.
8826 # Notes: Croaks if output_dir was not set in new().
8827  
8828 531 ▶sub _write_schema {
Subroutine _write_schema: called CC=34 SCAR=35.4
8829 531 my ($self, $method_name, $schema) = @_;
8830  
8831 # output_dir is required here — croak early with a clear message
8832 # rather than letting make_path fail with a cryptic error
8833 531 ▶ croak(__PACKAGE__, ': output_dir must be provided to new() when writing schema files') unless defined $self->{output_dir};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $self->{"output_dir"} 1 530 531
8834  
8835 530 ▶ make_path($self->{output_dir}) unless -d $self->{output_dir};
Branch: 1 branch
BranchTrueFalseTotal
unless -d $self->{"output_dir"} 6 524 530
8836  
8837 530 my $filename = "$self->{output_dir}/${method_name}.yml";
8838  
8839 530 local $YAML::XS::QuoteNumericStrings = 0;
8840  
8841 # Extract package name for module field
8842 530 my $package_name = '';
8843 530 ▶ if ($self->{_document}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_document"}) 528 2 530
8844 528 my $package_stmt = $self->{_document}->find_first('PPI::Statement::Package');
8845 528 ▶ $package_name = $package_stmt ? $package_stmt->namespace : '';
Branch: 1 branch
BranchTrueFalseTotal
$package_stmt ? : 523 5 528
8846 528 ▶ $self->{_package_name} //= $package_name;
Condition33%1/3
$self->{"_package_name"} //= $package_name
l!l&&r!l&&!r
52800
MC/DC0%0/2
$self->{"_package_name"} //= $package_name
$self->{"_package_name"} $package_name
Truth table33%1/3
A //= B
A= $self->{"_package_name"}B= $package_name
ABresult
1X1
011
000
8847 }
8848  
8849 # Clean up schema for output - use the format expected by App::Test::Generator::Template
8850 530 my $output = {
8851 function => $method_name,
8852 module => $package_name,
8853 config => {
8854 close_stdin => 1,
8855 dedup => 1,
8856 test_nuls => 0,
8857 test_undef => 0,
8858 test_empty => 1,
8859 test_non_ascii => 0,
8860 test_security => 0
8861 }
8862 };
8863  
8864 # A file the POD documents the routine creating or writing is the
8865 # requested result, not a leftover, so turn that destructive check off.
8866 530 ▶ if($schema->{_analysis}{side_effects}{writes_file}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"_analysis"}{"side_effects"}{"writes_file"}) 10 520 530
8867 10 $output->{config}{check_files} = 0;
8868 }
8869  
8870 # The routine has a precondition no generated value can meet, so there is
8871 # nothing meaningful to fuzz; the harness and all-fuzz report it skipped.
8872 530 ▶ $output->{skip} = $schema->{skip} if($schema->{skip});
Branch: 1 branch
BranchTrueFalseTotal
if $schema->{"skip"} 16 514 530
8873  
8874 # Process input parameters with advanced type handling
8875 530 ▶ if($schema->{'input'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"input"}) 513 17 530
8876 513 ▶ if(scalar(keys %{$schema->{'input'}})) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar keys %{$$schema{'input'};}) { } 352 161 513
8877 352 $output->{'input'} = {};
8878  
8879 352 foreach my $param_name (sort keys %{$schema->{'input'}}) {
8880 574 my $param = $schema->{'input'}{$param_name};
8881 574 ▶ if($param->{name}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param->{"name"}) 2 572 574
8882 2 my $name = delete $param->{name};
8883 2 ▶ if($name ne $param_name) {
Branch: 1 branch
BranchTrueFalseTotal
if ($name ne $param_name) 0 2 2
8884 # Sanity check
8885 0 croak("BUG: Parameter name - expected $param_name, got $name");
8886 }
8887 }
8888 574 my $cleaned_param = $self->_serialize_parameter_for_yaml($param);
8889 574 $output->{'input'}{$param_name} = $cleaned_param;
8890 }
8891  
8892 # If some params have positions and others don't, treat the whole
8893 # input as a named (hash) API and strip all positions. Mixed
8894 # position state arises when a named-API method also happens to
8895 # have a Params::Get positional-key call alongside =head4 Input
8896 # named-block params that carry no position.
8897 352 my @with_pos = grep { defined $output->{input}{$_}{position} } sort keys %{$output->{input}};
8898 352 my @without_pos = grep { !defined $output->{input}{$_}{position} } sort keys %{$output->{input}};
8899 352 ▶ if (@with_pos && @without_pos) {
Branch: 1 branch
BranchTrueFalseTotal
if (@with_pos and @without_pos) 4 348 352
Condition100%3/3
@with_pos and @without_pos
!ll&&!rl&&r
522964
MC/DC100%2/2
@with_pos and @without_pos
@with_pos @without_pos
Truth table100%3/3
A and B
A= @with_posB= @without_pos
ABresult
0X0
100
111
8900 4 delete $output->{input}{$_}{position} for @with_pos;
8901 }
8902 } else {
8903 161 delete $output->{input};
8904 }
8905 }
8906  
8907 # Process output
8908 530 ▶ if($schema->{'output'} && (scalar(keys %{$schema->{'output'}}))) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"output"} and scalar keys %{$$schema{"output"};}) 530 0 530
Condition50%1/2
$schema->{"output"} and scalar keys %{$$schema{"output"};}
!ll
0530
MC/DC0%0/1
$schema->{"output"} and scalar keys %{$$schema{"output"};}
$schema->{"output"}
Truth table50%1/2
A
A= $schema->{"output"}
Aresult
00
11
8909 530 ▶ if((ref($schema->{output}{_error_handling}) eq 'HASH') && (scalar(keys %{$schema->{output}{_error_handling}}) == 0)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $schema->{"output"}{"_error_handling"} eq "HASH" and scalar keys %{$$schema{"output"}{"_error_handling"};} == 0) 482 48 530
Condition100%3/3
ref $schema->{"output"}{"_error_handling"} eq "HASH" and scalar keys %{$$schema{"output"}{"_error_handling"};} == 0
!ll&&!rl&&r
444482
MC/DC100%2/2
ref $schema->{"output"}{"_error_handling"} eq "HASH" and scalar keys %{$$schema{"output"}{"_error_handling"};} == 0
ref $schema->{"output"}{"_error_handling"} eq "HASH" scalar keys %{$$schema{"output"}{"_error_handling"};} == 0
Truth table100%3/3
A and B
A= ref $schema->{"output"}{"_error_handling"} eq "HASH"B= scalar keys %{$$schema{"output"}{"_error_handling"};} == 0
ABresult
0X0
100
111
8910 482 delete $schema->{output}{_error_handling};
8911 }
8912 # value/alt_value are inference metadata; Return::Set does not recognise them as validation rules
8913 530 my %out_spec = %{$schema->{'output'}};
8914 530 delete @out_spec{qw(value alt_value)};
8915 530 $output->{'output'} = \%out_spec;
8916 }
8917  
8918 530 ▶ if($schema->{'output'}{'type'} && ($schema->{'output'}{'type'} eq 'scalar')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"output"}{"type"} and $schema->{"output"}{"type"} eq "scalar") 0 530 530
Condition66%2/3
$schema->{"output"}{"type"} and $schema->{"output"}{"type"} eq "scalar"
!ll&&!rl&&r
205100
MC/DC0%0/2
$schema->{"output"}{"type"} and $schema->{"output"}{"type"} eq "scalar"
$schema->{"output"}{"type"} $schema->{"output"}{"type"} eq "scalar"
Truth table66%2/3
A and B
A= $schema->{"output"}{"type"}B= $schema->{"output"}{"type"} eq "scalar"
ABresult
0X0
100
111
8919 0 $schema->{'output'}{'type'} = 'string';
8920 0 $schema->{_confidence}{output}->{level} = 'low'; # A guess
8921 }
8922  
8923 # Add 'new' field if object instantiation is needed
8924 530 ▶ if ($schema->{new}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"new"}) 288 242 530
8925 # TODO: consider allowing parent class packages up the ISA chain
8926 288 ▶ if(ref($schema->{new}) || ($schema->{new} eq $package_name)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $schema->{'new'} or $schema->{'new'} eq $package_name) { } 256 32 288
Condition100%3/3
ref $schema->{"new"} or $schema->{"new"} eq $package_name
l!l&&r!l&&!r
11014632
MC/DC100%2/2
ref $schema->{"new"} or $schema->{"new"} eq $package_name
ref $schema->{"new"} $schema->{"new"} eq $package_name
Truth table100%3/3
A or B
A= ref $schema->{"new"}B= $schema->{"new"} eq $package_name
ABresult
1X1
011
000
8927 256 ▶ $output->{new} = $schema->{new} eq $package_name ? undef : $schema->{'new'};
Branch: 1 branch
BranchTrueFalseTotal
$schema->{'new'} eq $package_name ? : 146 110 256
8928 } else {
8929 32 $self->_log(" NEW: Don't use $schema->{new} for object insantiation");
8930 32 delete $schema->{new};
8931 32 delete $output->{new};
8932 }
8933 }
8934  
8935 530 ▶ if(!defined($schema->{_confidence}{input}->{level})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $schema->{"_confidence"}{"input"}{"level"}) 473 57 530
8936 473 $schema->{_confidence}{input} = $self->_calculate_input_confidence($schema->{input});
8937 }
8938 530 ▶ if(!defined($schema->{_confidence}{output}->{level})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $schema->{"_confidence"}{"output"}{"level"}) 1 529 530
8939 1 $schema->{_confidence}{output} = $self->_calculate_output_confidence($schema->{output});
8940 }
8941  
8942 # Add relationships if detected
8943 530 ▶ if ($schema->{relationships} && @{$schema->{relationships}}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"relationships"} and @{$schema->{"relationships"};}) 7 523 530
Condition66%2/3
$schema->{"relationships"} and @{$schema->{"relationships"};}
!ll&&!rl&&r
52307
MC/DC50%1/2
$schema->{"relationships"} and @{$schema->{"relationships"};}
$schema->{"relationships"} @{$schema->{"relationships"};}
Truth table66%2/3
A and B
A= $schema->{"relationships"}B= @{$schema->{"relationships"};}
ABresult
0X0
100
111
8944 7 $output->{relationships} = $schema->{relationships};
8945 }
8946  
8947 530 ▶ if($schema->{accessor} && scalar(keys %{$schema->{accessor}})) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"accessor"} and scalar keys %{$$schema{"accessor"};}) 20 510 530
Condition100%2/2
$schema->{"accessor"} and scalar keys %{$$schema{"accessor"};}
!ll
51020
MC/DC100%1/1
$schema->{"accessor"} and scalar keys %{$$schema{"accessor"};}
$schema->{"accessor"}
Truth table100%2/2
A
A= $schema->{"accessor"}
Aresult
00
11
8948 20 $output->{accessor} = $schema->{accessor};
8949 }
8950  
8951 530 open my $fh, '>', $filename;
8952 530 print $fh YAML::XS::Dump($output);
8953 530 print $fh $self->_generate_schema_comments($schema, $method_name);
8954 530 close $fh;
8955  
8956 my $rel_info = $schema->{relationships} ?
8957 530 ▶ ' [' . scalar(@{$schema->{relationships}}) . ' relationships]' : '';
Branch: 1 branch
BranchTrueFalseTotal
$schema->{'relationships'} ? : 7 523 530
8958 $self->_log(" Wrote: $filename (input confidence: $schema->{_confidence}{input}->{level})" .
8959 530 ▶ ($schema->{new} ? " [requires: $schema->{new}]" : '') . $rel_info);
Branch: 1 branch
BranchTrueFalseTotal
$schema->{'new'} ? : 256 274 530
8960 }
8961  
8962 # --------------------------------------------------
8963 # _generate_schema_comments
8964 #
8965 # Purpose: Generate the YAML comment block
8966 # appended to the end of each written
8967 # schema file, containing provenance,
8968 # confidence levels, parameter type
8969 # notes, relationship summaries, and
8970 # warnings about types requiring
8971 # special test setup.
8972 #
8973 # Entry: $schema - the schema hashref as
8974 # built by _analyze_method.
8975 # $method_name - the method name string,
8976 # used in the fuzz
8977 # command hint.
8978 #
8979 # Exit: Returns a string of YAML comment lines
8980 # beginning with a blank line and ending
8981 # with a trailing newline.
8982 #
8983 # Side effects: None.
8984 # --------------------------------------------------
8985 530 ▶sub _generate_schema_comments {
Subroutine _generate_schema_comments: called CC=26 SCAR=32.6
8986 530 my ($self, $schema, $method_name) = @_;
8987  
8988 530 my @comments;
8989  
8990 530 push @comments, '';
8991 530 push @comments, '# Generated by ' . ref($self);
8992 530 push @comments, "# Run: fuzz-harness-generator -r $self->{output_dir}/${method_name}.yml";
8993 530 push @comments, '#';
8994 530 push @comments, "# Input confidence: $schema->{_confidence}{input}->{level}";
8995 530 push @comments, "# Output confidence: $schema->{_confidence}{output}->{level}";
8996  
8997 # Add notes about parameters
8998 530 ▶ if ($schema->{input}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"input"}) 513 17 530
8999 513 my @param_notes;
9000 513 foreach my $param_name (sort keys %{$schema->{input}}) {
9001 574 my $p = $schema->{input}{$param_name};
9002  
9003 574 ▶ if ($p->{semantic}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"semantic"}) 34 540 574
9004 34 push @param_notes, "$param_name: $p->{semantic}";
9005 }
9006  
9007 574 ▶ if ($p->{enum}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"enum"}) 8 566 574
9008 8 push @param_notes, "$param_name: enum with " . scalar(@{$p->{enum}}) . " values";
9009 }
9010  
9011 574 ▶ if ($p->{isa}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"isa"}) 41 533 574
9012 41 push @param_notes, "$param_name: requires $p->{isa} object";
9013 }
9014 }
9015  
9016 513 ▶ if (@param_notes) {
Branch: 1 branch
BranchTrueFalseTotal
if (@param_notes) 71 442 513
9017 71 push @comments, '#';
9018 71 push @comments, '# Parameter types detected:';
9019 71 foreach my $note (sort @param_notes) {
9020 83 push @comments, "# - $note";
9021 }
9022 }
9023 }
9024  
9025 # Add relationship notes, sorted so their order does not depend on
9026 # detection order.
9027 530 ▶ if ($schema->{relationships} && @{$schema->{relationships}}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"relationships"} and @{$schema->{"relationships"};}) 7 523 530
Condition66%2/3
$schema->{"relationships"} and @{$schema->{"relationships"};}
!ll&&!rl&&r
52307
MC/DC50%1/2
$schema->{"relationships"} and @{$schema->{"relationships"};}
$schema->{"relationships"} @{$schema->{"relationships"};}
Truth table66%2/3
A and B
A= $schema->{"relationships"}B= @{$schema->{"relationships"};}
ABresult
0X0
100
111
9028 7 push @comments, (
9029 '#',
9030 '# Parameter relationships detected:'
9031 );
9032 my @relationship_notes = map {
9033 16 ▶ $_->{description} || _format_relationship($_)
Condition33%1/3
$_->{'description'} || _format_relationship($_)
l!l&&r!l&&!r
1600
MC/DC0%0/2
$_->{'description'} || _format_relationship($_)
$_->{'description'} _format_relationship($_)
Truth table33%1/3
A || B
A= $_->{'description'}B= _format_relationship($_)
ABresult
1X1
011
000
9034 7 } @{$schema->{relationships}};
9035 7 foreach my $desc (sort @relationship_notes) {
9036 16 push @comments, "# - $desc";
9037 }
9038 }
9039  
9040 # Add general notes
9041 530 ▶ if ($schema->{_notes} && scalar(@{$schema->{_notes}})) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"_notes"} and scalar @{$schema->{"_notes"};}) 50 480 530
Condition100%2/2
$schema->{"_notes"} and scalar @{$schema->{"_notes"};}
!ll
2528
MC/DC100%1/1
$schema->{"_notes"} and scalar @{$schema->{"_notes"};}
$schema->{"_notes"}
Truth table100%2/2
A
A= $schema->{"_notes"}
Aresult
00
11
9042 50 push @comments, '#';
9043 50 push @comments, '# Notes:';
9044 50 foreach my $note (sort @{$schema->{_notes}}) {
9045 82 push @comments, "# - $note";
9046 }
9047 }
9048  
9049 530 ▶ if($schema->{_analysis}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"_analysis"}) 530 0 530
9050 530 push @comments, (
9051 '#',
9052 '# Analysis:',
9053 '# TODO:',
9054 );
9055 # confidence_factors:
9056 # input:
9057 # - No parameters found
9058 # output:
9059 # - 'Return type defined: object (+30)'
9060 # - 'Total output confidence score: 30'
9061 # - 'Medium confidence: return type defined'
9062 # input_confidence: none
9063 # output_confidence: medium
9064 # overall_confidence: none
9065 }
9066  
9067 # Add warnings for complex types
9068 530 my @warnings;
9069 530 ▶ if ($schema->{input}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($schema->{"input"}) 513 17 530
9070 513 foreach my $param_name (sort keys %{$schema->{input}}) {
9071 574 my $p = $schema->{input}{$param_name};
9072  
9073 574 ▶ if ($p->{type} && $p->{type} eq 'coderef') {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"type"} and $p->{"type"} eq "coderef") 12 562 574
Condition66%2/3
$p->{"type"} and $p->{"type"} eq "coderef"
!ll&&!rl&&r
056212
MC/DC50%1/2
$p->{"type"} and $p->{"type"} eq "coderef"
$p->{"type"} $p->{"type"} eq "coderef"
Truth table66%2/3
A and B
A= $p->{"type"}B= $p->{"type"} eq "coderef"
ABresult
0X0
100
111
9074 12 push @warnings, "Parameter '$param_name' is a coderef - you'll need to provide a sub {} in tests";
9075 }
9076  
9077 574 ▶ if ($p->{semantic} && $p->{semantic} eq 'filehandle') {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"semantic"} and $p->{"semantic"} eq "filehandle") 2 572 574
Condition100%3/3
$p->{"semantic"} and $p->{"semantic"} eq "filehandle"
!ll&&!rl&&r
540322
MC/DC100%2/2
$p->{"semantic"} and $p->{"semantic"} eq "filehandle"
$p->{"semantic"} $p->{"semantic"} eq "filehandle"
Truth table100%3/3
A and B
A= $p->{"semantic"}B= $p->{"semantic"} eq "filehandle"
ABresult
0X0
100
111
9078 2 push @warnings, "Parameter '$param_name' is a filehandle - consider using IO::String or mock";
9079 }
9080  
9081 574 ▶ if ($p->{isa} && $p->{isa} =~ /DateTime/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p->{"isa"} and $p->{"isa"} =~ /DateTime/) 2 572 574
Condition100%3/3
$p->{"isa"} and $p->{"isa"} =~ /DateTime/
!ll&&!rl&&r
533392
MC/DC100%2/2
$p->{"isa"} and $p->{"isa"} =~ /DateTime/
$p->{"isa"} $p->{"isa"} =~ /DateTime/
Truth table100%3/3
A and B
A= $p->{"isa"}B= $p->{"isa"} =~ /DateTime/
ABresult
0X0
100
111
9082 2 push @warnings, "Parameter '$param_name' requires DateTime - ensure DateTime is loaded";
9083 }
9084 }
9085 }
9086  
9087 530 ▶ if (@warnings) {
Branch: 1 branch
BranchTrueFalseTotal
if (@warnings) 16 514 530
9088 16 push @comments, '#';
9089 16 push @comments, '# WARNINGS - Manual test setup may be required:';
9090 16 foreach my $warning (sort @warnings) {
9091 16 push @comments, "# ! $warning";
9092 }
9093 }
9094  
9095 530 push @comments, '';
9096  
9097 530 return join("\n", @comments);
9098 }
9099  
9100 # --------------------------------------------------
9101 # _serialize_parameter_for_yaml
9102 #
9103 # Purpose: Convert a parameter spec hashref into
9104 # a cleaned, YAML-serialisable form
9105 # suitable for App::Test::Generator
9106 # consumption, handling semantic type
9107 # mappings, enum values, and object
9108 # class annotations.
9109 #
9110 # Entry: $param - parameter spec hashref as
9111 # produced by the merge and
9112 # analysis pipeline.
9113 #
9114 # Exit: Returns a new hashref containing only
9115 # the fields App::Test::Generator
9116 # understands, with internal _ keys
9117 # and semantic keys removed or converted.
9118 #
9119 # Side effects: None.
9120 #
9121 # Notes: Semantic types are mapped to
9122 # appropriate base types with additional
9123 # constraint and note fields.
9124 # The original $param hashref is not
9125 # modified.
9126 # --------------------------------------------------
9127 583 ▶sub _serialize_parameter_for_yaml {
Subroutine _serialize_parameter_for_yaml: called CC=57 SCAR=43.8
9128 583 my ($self, $param) = @_;
9129  
9130 583 my %cleaned;
9131  
9132 # Copy basic fields that App::Test::Generator expects
9133 583 foreach my $field (qw(type position optional min max matches default)) {
9134 4081 ▶ $cleaned{$field} = $param->{$field} if defined $param->{$field};
Branch: 1 branch
BranchTrueFalseTotal
if defined $param->{$field} 1667 2414 4081
9135 }
9136  
9137 # Provenance drives the harness's tolerance and type-check decisions.
9138 583 ▶ $cleaned{_source} = $param->{_source} if defined($param->{_source}) && length($param->{_source});
Branch: 1 branch
BranchTrueFalseTotal
if defined $param->{"_source"} and length $param->{"_source"} 555 28 583
Condition66%2/3
defined $param->{"_source"} and length $param->{"_source"}
!ll&&!rl&&r
280555
MC/DC50%1/2
defined $param->{"_source"} and length $param->{"_source"}
defined $param->{"_source"} length $param->{"_source"}
Truth table66%2/3
A and B
A= defined $param->{"_source"}B= length $param->{"_source"}
ABresult
0X0
100
111
9139  
9140 # Per-constraint provenance: a documented minimum and a code-enforced
9141 # maximum on the same field are separate decisions.
9142 583 ▶ if(ref($param->{_constraint_source}) eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $param->{"_constraint_source"} eq "HASH") 87 496 583
9143 87 my %provenance;
9144 87 foreach my $key (qw(min max memberof matches nomatch notmemberof)) {
9145 522 my $source = $param->{_constraint_source}{$key};
9146 522 ▶ $provenance{$key} = $source if defined($source) && length($source);
Branch: 1 branch
BranchTrueFalseTotal
if defined $source and length $source 114 408 522
Condition66%2/3
defined $source and length $source
!ll&&!rl&&r
4080114
MC/DC50%1/2
defined $source and length $source
defined $source length $source
Truth table66%2/3
A and B
A= defined $sourceB= length $source
ABresult
0X0
100
111
9147 }
9148 87 ▶ $cleaned{_constraint_source} = \%provenance if keys %provenance;
Branch: 1 branch
BranchTrueFalseTotal
if keys %provenance 87 0 87
9149 }
9150  
9151 # Handle advanced type mappings
9152 583 ▶ if(my $semantic = $param->{semantic}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $semantic = $param->{"semantic"}) 38 545 583
9153 38 ▶ if ($semantic eq 'datetime_object') {
Branch: 12 branches
BranchTrueFalseTotal
if ($semantic eq 'datetime_object') { } 2 36 38
elsif ($semantic eq 'timepiece_object') { } 0 36 36
elsif ($semantic eq 'date_string') { } 1 35 36
elsif ($semantic eq 'iso8601_string') { } 1 34 35
elsif ($semantic eq 'unix_timestamp') { } 2 32 34
elsif ($semantic eq 'datetime_parseable') { } 0 32 32
elsif ($semantic eq 'filehandle') { } 2 30 32
elsif ($semantic eq 'filepath') { } 1 29 30
elsif ($semantic eq 'existing_file') { } 10 19 29
elsif ($semantic eq 'directory') { } 1 18 19
elsif ($semantic eq 'callback') { } 7 11 18
elsif ($semantic eq 'enum') { } 8 3 11
9154 # DateTime objects: test generator needs to know how to create them
9155 2 $cleaned{type} = 'object';
9156 2 ▶ $cleaned{isa} = $param->{isa} || 'DateTime';
Condition50%1/2
$param->{'isa'} || 'DateTime'
l!l
20
MC/DC0%0/1
$param->{'isa'} || 'DateTime'
$param->{'isa'}
Truth table50%1/2
A
A= $param->{'isa'}
Aresult
11
00
9157 2 $cleaned{_note} = 'Requires DateTime object';
9158 } elsif ($semantic eq 'timepiece_object') {
9159 0 $cleaned{type} = 'object';
9160 0 ▶ $cleaned{isa} = $param->{isa} || 'Time::Piece';
Condition0%0/2
$param->{'isa'} || 'Time::Piece'
l!l
00
MC/DC0%0/1
$param->{'isa'} || 'Time::Piece'
$param->{'isa'}
Truth table0%0/2
A
A= $param->{'isa'}
Aresult
11
00
9161 0 $cleaned{_note} = 'Requires Time::Piece object';
9162 } elsif ($semantic eq 'date_string') {
9163 # Date strings: provide regex pattern
9164 1 $cleaned{type} = 'string';
9165 1 ▶ $cleaned{matches} ||= '/^\d{4}-\d{2}-\d{2}$/';
Condition50%1/2
$cleaned{"matches"} ||= "/^\\d{4}-\\d{2}-\\d{2}\$/"
l!l
01
MC/DC0%0/1
$cleaned{"matches"} ||= "/^\\d{4}-\\d{2}-\\d{2}\$/"
$cleaned{"matches"}
Truth table50%1/2
A
A= $cleaned{"matches"}
Aresult
11
00
9166 1 $cleaned{_example} = '2024-12-12';
9167 } elsif ($semantic eq 'iso8601_string') {
9168 1 $cleaned{type} = 'string';
9169 1 ▶ $cleaned{matches} ||= '/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z?$/';
Condition50%1/2
$cleaned{"matches"} ||= "/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z?\$/"
l!l
10
MC/DC0%0/1
$cleaned{"matches"} ||= "/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z?\$/"
$cleaned{"matches"}
Truth table50%1/2
A
A= $cleaned{"matches"}
Aresult
11
00
9170 1 $cleaned{_example} = '2024-12-12T10:30:00Z';
9171 } elsif ($semantic eq 'unix_timestamp') {
9172 2 $cleaned{type} = 'integer';
9173 2 ▶ $cleaned{min} ||= 0;
Condition50%1/2
$cleaned{"min"} ||= 0
l!l
02
MC/DC0%0/1
$cleaned{"min"} ||= 0
$cleaned{"min"}
Truth table50%1/2
A
A= $cleaned{"min"}
Aresult
11
00
9174 2 ▶ $cleaned{max} ||= $INT32_MAX; # 32-bit max
Condition66%2/3
$cleaned{"max"} ||= $INT32_MAX
l!l&&r!l&&!r
110
MC/DC0%0/2
$cleaned{"max"} ||= $INT32_MAX
$cleaned{"max"} $INT32_MAX
Truth table66%2/3
A ||= B
A= $cleaned{"max"}B= $INT32_MAX
ABresult
1X1
011
000
9175 2 $cleaned{_note} = 'UNIX timestamp';
9176 } elsif ($semantic eq 'datetime_parseable') {
9177 0 $cleaned{type} = 'string';
9178 0 $cleaned{_note} = 'Must be parseable as datetime';
9179 } elsif ($semantic eq 'filehandle') {
9180 # File handles: special handling needed
9181 2 $cleaned{type} = 'object';
9182 2 ▶ $cleaned{isa} = $param->{isa} || 'IO::Handle';
Condition50%1/2
$param->{'isa'} || 'IO::Handle'
l!l
20
MC/DC0%0/1
$param->{'isa'} || 'IO::Handle'
$param->{'isa'}
Truth table50%1/2
A
A= $param->{'isa'}
Aresult
11
00
9183 2 $cleaned{_note} = 'File handle - may need mock in tests';
9184 } elsif ($semantic eq 'filepath') {
9185 # File paths: string with path pattern
9186 1 $cleaned{type} = 'string';
9187 1 ▶ $cleaned{matches} ||= '/^[\\w\\/.\\-_]+$/';
Condition50%1/2
$cleaned{"matches"} ||= "/^[\\w\\/.\\-_]+\$/"
l!l
01
MC/DC0%0/1
$cleaned{"matches"} ||= "/^[\\w\\/.\\-_]+\$/"
$cleaned{"matches"}
Truth table50%1/2
A
A= $cleaned{"matches"}
Aresult
11
00
9188 1 $cleaned{_note} = 'File path';
9189 } elsif ($semantic eq 'existing_file') {
9190 # The routine only tests that the file exists. Any existing
9191 # file satisfies that, so keep the semantic for the harness to
9192 # supply a temporary file instead of guessing at a path.
9193 10 $cleaned{type} = 'string';
9194 10 $cleaned{semantic} = 'existing_file';
9195 10 $cleaned{_note} = 'Existing file';
9196 } elsif ($semantic eq 'directory') {
9197 # The value must name an existing directory. No pattern can
9198 # express that and any generated path would fail the -d test,
9199 # so keep the semantic for the harness to act on instead of
9200 # guessing at the spelling.
9201 1 $cleaned{type} = 'string';
9202 1 $cleaned{semantic} = 'directory';
9203 1 $cleaned{_note} = 'Existing directory';
9204 } elsif ($semantic eq 'callback') {
9205 # Coderefs: mark as special type
9206 7 $cleaned{type} = 'coderef';
9207 7 $cleaned{_note} = 'CODE reference - provide sub { } in tests';
9208 } elsif ($semantic eq 'enum') {
9209 # Enum: keep as string but add valid values.
9210 # If the formal input spec explicitly declared a different type, honour
9211 # it — the enum values from code analysis are regex-internal alternates
9212 # (e.g. numeric format variants) that are meaningless as string choices.
9213 8 ▶ if (($param->{_source} // '') eq SOURCE_INPUT_SPEC && defined $param->{type} && $param->{type} ne 'string') {
Branch: 1 branch
BranchTrueFalseTotal
if (($param->{'_source'} // '') eq 'input_spec' and defined $param->{'type'} and $param->{'type'} ne 'string') { } 4 4 8
Condition62%5/8
($param->{"_source"} // "") eq "input_spec" and defined $param->{"type"} and $param->{"type"} ne "string"
!ll&&!rl&&r
404
($param->{"_source"} // "") eq "input_spec" and defined $param->{"type"}
!ll&&!rl&&r
404
$param->{"_source"} // ""
l!l
80
MC/DC0%0/3
($param->{"_source"} // "") eq "input_spec" and defined $param->{"type"} and $param->{"type"} ne "string"
$param->{"_source"} defined $param->{"type"} $param->{"type"} ne "string"
Truth table25%1/4
A and B and C
A= $param->{"_source"}B= defined $param->{"type"}C= $param->{"type"} ne "string"
ABCresult
0XX0
10X0
1100
1111
9214 # Formal spec wins; suppress spurious regex-derived enum.
9215 4 delete $cleaned{enum};
9216 } else {
9217 4 $cleaned{type} = 'string';
9218 4 ▶ if ($param->{enum} && ref($param->{enum}) eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if ($param->{"enum"} and ref $param->{"enum"} eq "ARRAY") 4 0 4
Condition33%1/3
$param->{"enum"} and ref $param->{"enum"} eq "ARRAY"
!ll&&!rl&&r
004
MC/DC0%0/2
$param->{"enum"} and ref $param->{"enum"} eq "ARRAY"
$param->{"enum"} ref $param->{"enum"} eq "ARRAY"
Truth table33%1/3
A and B
A= $param->{"enum"}B= ref $param->{"enum"} eq "ARRAY"
ABresult
0X0
100
111
9219 4 $cleaned{enum} = $param->{enum};
9220 4 $cleaned{_note} = 'Must be one of: ' . join(', ', @{$param->{enum}});
9221 }
9222 }
9223 }
9224 }
9225  
9226 # Handle memberof even if not marked with semantic.
9227 # enum and memberof are mutually exclusive — only set memberof when enum
9228 # is not already being output (avoids the "has both" validation error).
9229 # Also suppress when the formal input spec declared a non-string type —
9230 # the enum values are regex-internal alternates, not valid string members.
9231 583 ▶ my $formal_non_string = (($param->{_source} // '') eq SOURCE_INPUT_SPEC) && defined $param->{type} && $param->{type} ne 'string';
Condition87%7/8
($param->{'_source'} // '') eq 'input_spec' && defined $param->{'type'} && $param->{'type'} ne 'string'
!ll&&!rl&&r
268161154
($param->{"_source"} // "") eq "input_spec" and defined $param->{"type"}
!ll&&!rl&&r
2680315
$param->{"_source"} // ""
l!l
55528
MC/DC66%2/3
($param->{'_source'} // '') eq 'input_spec' && defined $param->{'type'} && $param->{'type'} ne 'string'
$param->{"_source"} defined $param->{"type"} $param->{'type'} ne 'string'
Truth table75%3/4
A and B && C
A= $param->{"_source"}B= defined $param->{"type"}C= $param->{'type'} ne 'string'
ABCresult
0XX0
10X0
1100
1111
9232 583 ▶ if($param->{enum} && ref($param->{enum}) eq 'ARRAY' && !$cleaned{enum} && !$formal_non_string) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param->{"enum"} and ref $param->{"enum"} eq "ARRAY" and not $cleaned{"enum"} and not $formal_non_string) 1 582 583
Condition88%8/9
$param->{"enum"} and ref $param->{"enum"} eq "ARRAY" and not $cleaned{"enum"} and not $formal_non_string
!ll&&!rl&&r
57841
$param->{"enum"} and ref $param->{"enum"} eq "ARRAY" and not $cleaned{"enum"}
!ll&&!rl&&r
57445
$param->{"enum"} and ref $param->{"enum"} eq "ARRAY"
!ll&&!rl&&r
57409
MC/DC75%3/4
$param->{"enum"} and ref $param->{"enum"} eq "ARRAY" and not $cleaned{"enum"} and not $formal_non_string
$param->{"enum"} ref $param->{"enum"} eq "ARRAY" not $cleaned{"enum"} not $formal_non_string
Truth table80%4/5
A and B and not(C) and not(D)
A= $param->{"enum"}B= ref $param->{"enum"} eq "ARRAY"C= not $cleaned{"enum"}D= not $formal_non_string
ABCDresult
0XXX0
10XX0
110X0
11100
11111
9233 1 $cleaned{memberof} = $param->{enum};
9234 }
9235 583 ▶ if($param->{memberof} && ref($param->{memberof}) eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if ($param->{"memberof"} and ref $param->{"memberof"} eq "ARRAY") 13 570 583
Condition66%2/3
$param->{"memberof"} and ref $param->{"memberof"} eq "ARRAY"
!ll&&!rl&&r
570013
MC/DC50%1/2
$param->{"memberof"} and ref $param->{"memberof"} eq "ARRAY"
$param->{"memberof"} ref $param->{"memberof"} eq "ARRAY"
Truth table66%2/3
A and B
A= $param->{"memberof"}B= ref $param->{"memberof"} eq "ARRAY"
ABresult
0X0
100
111
9236 13 $cleaned{memberof} = $param->{memberof};
9237 }
9238  
9239 # Handle object class
9240 583 ▶ if ($param->{isa} && !$cleaned{isa}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param->{"isa"} and not $cleaned{"isa"}) 38 545 583
Condition100%3/3
$param->{"isa"} and not $cleaned{"isa"}
!ll&&!rl&&r
541438
MC/DC100%2/2
$param->{"isa"} and not $cleaned{"isa"}
$param->{"isa"} not $cleaned{"isa"}
Truth table100%3/3
A and not(B)
A= $param->{"isa"}B= not $cleaned{"isa"}
ABresult
0X0
100
111
9241 38 $cleaned{isa} = $param->{isa};
9242 }
9243  
9244 # Add format hints where available
9245 583 ▶ if ($param->{format}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param->{"format"}) 1 582 583
9246 1 $cleaned{_format} = $param->{format};
9247 }
9248  
9249 # Patterns harvested from source or POD arrive as slash-delimited
9250 # literals ('/^abc$/'). Consumers compile what they are given with
9251 # qr//, which would take the delimiters to be part of the pattern, so
9252 # store the pattern body. It stays a plain string: a compiled Regexp
9253 # is written to YAML as a !!perl/regexp object that a YAML consumer
9254 # cannot read back, and the schema is a data file.
9255 583 ▶ if(defined(my $pattern = $cleaned{matches})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $pattern = $cleaned{"matches"})) 19 564 583
9256 19 ▶ if((builtin::reftype($pattern) // '') eq 'REGEXP') {
Branch: 2 branches
BranchTrueFalseTotal
if ((builtin::reftype($pattern) // '') eq 'REGEXP') { } 0 19 19
elsif (not ref $pattern) { } 19 0 19
Condition50%1/2
builtin::reftype($pattern) // ""
l!l
019
MC/DC0%0/1
builtin::reftype($pattern) // ""
builtin::reftype($pattern)
Truth table50%1/2
A
A= builtin::reftype($pattern)
Aresult
11
00
9257 # Some extraction paths hand over a compiled pattern, possibly a
9258 # blessed subclass (e.g. a regexp from a Safe compartment).
9259 0 my ($body) = re::regexp_pattern($pattern);
9260 0 ▶ $cleaned{matches} = $body if defined($body);
Branch: 1 branch
BranchTrueFalseTotal
if defined $body 0 0 0
9261 } elsif(!ref($pattern)) {
9262 19 (my $body = $pattern) =~ s{^/(.+)/$}{$1}s;
9263 19 my $compiled = eval { qr/$body/ };
9264 19 ▶ if($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) { } 0 19 19
9265 0 $self->_log(" invalid matches pattern '$pattern': $@");
9266 } else {
9267 19 $cleaned{matches} = $body;
9268 }
9269 }
9270 }
9271  
9272 # Remove internal fields. The directory and existing-file semantics are
9273 # kept: the harness needs them to supply a path that exists.
9274 delete $cleaned{semantic}
9275 583 ▶ unless(($cleaned{semantic} // '') =~ /^(?:directory|existing_file)$/);
Branch: 1 branch
BranchTrueFalseTotal
unless ($cleaned{"semantic"} // "") =~ /^(?:directory|existing_file)$/ 572 11 583
Condition100%2/2
$cleaned{"semantic"} // ""
l!l
11572
MC/DC100%1/1
$cleaned{"semantic"} // ""
$cleaned{"semantic"}
Truth table100%2/2
A
A= $cleaned{"semantic"}
Aresult
11
00
9276  
9277 583 return \%cleaned;
9278 }
9279  
9280 # --------------------------------------------------
9281 # _format_relationship
9282 #
9283 # Purpose: Format a relationship hashref as a
9284 # short human-readable description
9285 # string for use in YAML comments.
9286 #
9287 # Entry: $rel - relationship hashref as
9288 # produced by the relationship
9289 # detection methods.
9290 #
9291 # Exit: Returns a description string.
9292 # Returns 'Unknown relationship' for
9293 # unrecognised types.
9294 #
9295 # Side effects: None.
9296 # --------------------------------------------------
9297 10 ▶sub _format_relationship {
Subroutine _format_relationship: called CC=7 SCAR=19.5
9298 10 my $rel = $_[0];
9299  
9300 10 ▶ if ($rel->{type} eq 'mutually_exclusive') {
Branch: 6 branches
BranchTrueFalseTotal
if ($rel->{'type'} eq 'mutually_exclusive') { } 2 8 10
elsif ($rel->{'type'} eq 'required_group') { } 1 7 8
elsif ($rel->{'type'} eq 'conditional_requirement') { } 2 5 7
elsif ($rel->{'type'} eq 'dependency') { } 2 3 5
elsif ($rel->{'type'} eq 'value_constraint') { } 1 2 3
elsif ($rel->{'type'} eq 'value_conditional') { } 1 1 2
9301 2 return 'Mutually exclusive: ' . join(', ', @{$rel->{params}});
9302 } elsif ($rel->{type} eq 'required_group') {
9303 1 return "Required group (OR): " . join(', ', @{$rel->{params}});
9304 } elsif ($rel->{type} eq 'conditional_requirement') {
9305 2 return "If $rel->{if} then $rel->{then_required} required";
9306 } elsif ($rel->{type} eq 'dependency') {
9307 2 return "$rel->{param} depends on $rel->{requires}";
9308 } elsif ($rel->{type} eq 'value_constraint') {
9309 1 return "If $rel->{if} then $rel->{then} $rel->{operator} $rel->{value}";
9310 } elsif ($rel->{type} eq 'value_conditional') {
9311 1 return "If $rel->{if}='$rel->{equals}' then $rel->{then_required} required";
9312 }
9313 1 return 'Unknown relationship';
9314 }
9315  
9316 # --------------------------------------------------
9317 # _needs_object_instantiation
9318 #
9319 # Purpose: Determine whether a method requires
9320 # --------------------------------------------------
9321 # _ctor_representative_args
9322 #
9323 # Purpose: Given a new() method schema, return a
9324 # hashref of representative values for its
9325 # required parameters, suitable for use as
9326 # the new: key in an instance-method schema.
9327 # Returns {} for a no-arg constructor.
9328 # Returns undef when any required param is
9329 # of a type that cannot be represented as a
9330 # plain YAML scalar (e.g. coderef, object).
9331 #
9332 # Entry: $ctor_schema - schema hashref for new().
9333 #
9334 # Exit: Hashref of {param => value} or undef.
9335 # --------------------------------------------------
9336  
9337 # A parameter whose value the routine reads from disk is a precondition, not an
9338 # argument the harness can make up. Two cases are distinguishable:
9339 #
9340 # * the routine only tests that the file exists (`-e`/`-f`) and keeps the
9341 # path, as a constructor validating its argument does. Any existing file
9342 # will do, so the parameter is marked semantic => 'existing_file' and the
9343 # harness supplies a real temporary file.
9344 # * the routine parses or slurps the file's contents. No synthesized or
9345 # empty fixture can satisfy that, so the routine is reported as skipped
9346 # rather than failed on a call it could never make correctly.
9347 sub _requires_input_file
9348 764 ▶{
Subroutine _requires_input_file: called CC=15 SCAR=27.2
9349 764 my ($body, $input) = @_;
9350  
9351 764 ▶ return undef unless(ref($input) eq 'HASH');
Branch: 1 branch
BranchTrueFalseTotal
unless ref $input eq "HASH" 35 729 764
9352 729 ▶ return undef unless(defined($body) && length($body));
Branch: 1 branch
BranchTrueFalseTotal
unless defined $body and length $body 0 729 729
Condition33%1/3
defined $body and length $body
!ll&&!rl&&r
00729
MC/DC0%0/2
defined $body and length $body
defined $body length $body
Truth table33%1/3
A and B
A= defined $bodyB= length $body
ABresult
0X0
100
111
9353  
9354 729 foreach my $param (sort keys %{$input}) {
9355 661 my $p = quotemeta($param);
9356  
9357 # The value is often copied out of %args under another name first.
9358 661 my @names = ($p);
9359 661 ▶ while($body =~ /\bmy\s+\$(\w+)\s*=\s*\$args\{\s*['"]?$p['"]?\s*\}\s*;/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /\bmy\s+\$(\w+)\s*=\s*\$args\{\s*['"]?${p}['"]?\s*\}\s*;/g) 7 661 668
9360 7 ▶ push @names, quotemeta($1) if($1 ne $param);
Branch: 1 branch
BranchTrueFalseTotal
if $1 ne $param 5 2 7
9361 }
9362 661 my $v = '(?:' . join('|', @names) . ')';
9363  
9364 # A file whose contents are read, not merely tested for existence.
9365 661 ▶ return 'needs an existing input file whose contents it parses'
Branch: 1 branch
BranchTrueFalseTotal
if $body =~ /\b(?:PPI::Document->new|_load_schema|_slurp|read_file|slurp_file)\s*\(\s*\$$v\b/ or $body =~ /\bopen\b\s*\(?[^;]*['"]<[^;]*\$$v\b/ 18 643 661
Condition100%3/3
$body =~ /\b(?:PPI::Document->new|_load_schema|_slurp|read_file|slurp_file)\s*\(\s*\$$v\b/ or $body =~ /\bopen\b\s*\(?[^;]*['"]<[^;]*\$$v\b/
l!l&&r!l&&!r
99643
MC/DC100%2/2
$body =~ /\b(?:PPI::Document->new|_load_schema|_slurp|read_file|slurp_file)\s*\(\s*\$$v\b/ or $body =~ /\bopen\b\s*\(?[^;]*['"]<[^;]*\$$v\b/
$body =~ /\b(?:PPI::Document->new|_load_schema|_slurp|read_file|slurp_file)\s*\(\s*\$$v\b/ $body =~ /\bopen\b\s*\(?[^;]*['"]<[^;]*\$$v\b/
Truth table100%3/3
A or B
A= $body =~ /\b(?:PPI::Document->new|_load_schema|_slurp|read_file|slurp_file)\s*\(\s*\$$v\b/B= $body =~ /\bopen\b\s*\(?[^;]*['"]<[^;]*\$$v\b/
ABresult
1X1
011
000
9366 if($body =~ /\b(?:PPI::Document->new|_load_schema|_slurp|read_file|slurp_file)\s*\(\s*\$$v\b/
9367 || $body =~ /\bopen\b\s*\(?[^;]*['"]<[^;]*\$$v\b/);
9368  
9369 643 ▶ my $tests_existence = ($body =~ /-[ef]\s+\$args\{\s*['"]?$p['"]?\s*\}/)
Condition100%6/6
$body =~ /-[ef]\s+\$args\{\s*['"]?${p}['"]?\s*\}/ || $body =~ /-[ef]\s+\$$v\b/ || $body =~ /-[ef]\s+\$self->\{\s*['"]?${p}['"]?\s*\}/
l!l&&r!l&&!r
83632
$body =~ /-[ef]\s+\$args\{\s*['"]?${p}['"]?\s*\}/ or $body =~ /-[ef]\s+\$$v\b/
l!l&&r!l&&!r
71635
MC/DC100%3/3
$body =~ /-[ef]\s+\$args\{\s*['"]?${p}['"]?\s*\}/ || $body =~ /-[ef]\s+\$$v\b/ || $body =~ /-[ef]\s+\$self->\{\s*['"]?${p}['"]?\s*\}/
$body =~ /-[ef]\s+\$args\{\s*['"]?${p}['"]?\s*\}/ $body =~ /-[ef]\s+\$$v\b/ $body =~ /-[ef]\s+\$self->\{\s*['"]?${p}['"]?\s*\}/
Truth table100%4/4
A or B || C
A= $body =~ /-[ef]\s+\$args\{\s*['"]?${p}['"]?\s*\}/B= $body =~ /-[ef]\s+\$$v\b/C= $body =~ /-[ef]\s+\$self->\{\s*['"]?${p}['"]?\s*\}/
ABCresult
1XX1
01X1
0011
0000
9370 || ($body =~ /-[ef]\s+\$$v\b/)
9371 || ($body =~ /-[ef]\s+\$self->\{\s*['"]?$p['"]?\s*\}/);
9372 # Object::Configure reads the file its caller's config_file names and
9373 # croaks when it is missing; that test is not in this body to be seen.
9374 643 ▶ $tests_existence ||= ($param eq 'config_file')
Condition83%5/6
$tests_existence ||= $param eq "config_file" && $body =~ /\bObject::Configure::configure\s*\(/
l!l&&r!l&&!r
111631
$param eq 'config_file' && $body =~ /\bObject::Configure::configure\s*\(/
!ll&&!rl&&r
63101
MC/DC0%0/3
$tests_existence ||= $param eq "config_file" && $body =~ /\bObject::Configure::configure\s*\(/
$tests_existence $param eq 'config_file' $body =~ /\bObject::Configure::configure\s*\(/
Truth table0%0/4
A ||= B && C
A= $tests_existenceB= $param eq 'config_file'C= $body =~ /\bObject::Configure::configure\s*\(/
ABCresult
1XX1
0111
00X0
0100
9375 && ($body =~ /\bObject::Configure::configure\s*\(/);
9376 643 ▶ next unless($tests_existence);
Branch: 1 branch
BranchTrueFalseTotal
unless $tests_existence 631 12 643
9377  
9378 12 my $spec = $input->{$param};
9379 12 ▶ $spec->{semantic} = 'existing_file' if(ref($spec) eq 'HASH');
Branch: 1 branch
BranchTrueFalseTotal
if ref $spec eq "HASH" 12 0 12
9380 }
9381  
9382 711 return undef;
9383 }
9384  
9385 # True when the constructor refuses to build the package itself. Two idioms
9386 # are recognised: an explicit abstract-class check (Class::Abstract and
9387 # friends), and a croak over a constructor argument that the schema does not
9388 # describe, which the harness therefore cannot pass.
9389 sub _constructor_refuses_direct_instantiation
9390 93 ▶{
Subroutine _constructor_refuses_direct_instantiation: called CC=10 SCAR=24.6
9391 93 my ($body, $ctor_schema) = @_;
9392  
9393 # _find_methods() keeps the body as source text, but accept a PPI node too.
9394 0 ▶ my $content = ref($body) ? eval { $body->content } : $body;
Branch: 1 branch
BranchTrueFalseTotal
ref $body ? : 0 93 93
9395 93 ▶ return 0 unless(defined($content) && length($content));
Branch: 1 branch
BranchTrueFalseTotal
unless defined $content and length $content 0 93 93
Condition33%1/3
defined $content and length $content
!ll&&!rl&&r
0093
MC/DC0%0/2
defined $content and length $content
defined $content length $content
Truth table33%1/3
A and B
A= defined $contentB= length $content
ABresult
0X0
100
111
9396  
9397 93 ▶ return 1 if($content =~ /\bcheck_abstract\s*\(/);
Branch: 1 branch
BranchTrueFalseTotal
if $content =~ /\bcheck_abstract\s*\(/ 0 93 93
9398 93 ▶ return 1 if(($content =~ /\bcroak\b/) && ($content =~ /\beq\s+__PACKAGE__\b/));
Branch: 1 branch
BranchTrueFalseTotal
if $content =~ /\bcroak\b/ and $content =~ /\beq\s+__PACKAGE__\b/ 1 92 93
Condition100%3/3
$content =~ /\bcroak\b/ and $content =~ /\beq\s+__PACKAGE__\b/
!ll&&!rl&&r
55371
MC/DC100%2/2
$content =~ /\bcroak\b/ and $content =~ /\beq\s+__PACKAGE__\b/
$content =~ /\bcroak\b/ $content =~ /\beq\s+__PACKAGE__\b/
Truth table100%3/3
A and B
A= $content =~ /\bcroak\b/B= $content =~ /\beq\s+__PACKAGE__\b/
ABresult
0X0
100
111
9399  
9400 92 ▶ my %declared = (ref($ctor_schema->{input}) eq 'HASH') ? %{$ctor_schema->{input}} : ();
Branch: 1 branch
BranchTrueFalseTotal
ref $ctor_schema->{'input'} eq 'HASH' ? : 92 0 92
9401 92 ▶ while($content =~ /\$args\{\s*(['"]?)([\w:]+)\1\s*\}\s*or\s+croak\b/sg) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /\$args\{\s*(['"]?)([\w:]+)\1\s*\}\s*or\s+croak\b/gs) 1 91 92
9402 1 ▶ return 1 unless(exists($declared{$2}));
Branch: 1 branch
BranchTrueFalseTotal
unless exists $declared{$2} 1 0 1
9403 }
9404  
9405 91 return 0;
9406 }
9407  
9408 93 ▶sub _ctor_representative_args {
Subroutine _ctor_representative_args: called CC=8 SCAR=20.9
9409 93 my ($self, $ctor_schema) = @_;
9410  
9411 93 my %REP = (
9412 string => 'test',
9413 integer => 42,
9414 float => 3.14,
9415 boolean => 1,
9416 hashref => {},
9417 arrayref => [],
9418 any => 'test',
9419 );
9420  
9421 93 ▶ my $input = $ctor_schema->{input} // {};
Condition50%1/2
$ctor_schema->{"input"} // {}
l!l
930
MC/DC0%0/1
$ctor_schema->{"input"} // {}
$ctor_schema->{"input"}
Truth table50%1/2
A
A= $ctor_schema->{"input"}
Aresult
11
00
9422 93 my %args;
9423 93 for my $param_name (keys %$input) {
9424 102 ▶ my $spec = $input->{$param_name} // {};
Condition50%1/2
$input->{$param_name} // {}
l!l
1020
MC/DC0%0/1
$input->{$param_name} // {}
$input->{$param_name}
Truth table50%1/2
A
A= $input->{$param_name}
Aresult
11
00
9425 102 ▶ next if $spec->{optional};
Branch: 1 branch
BranchTrueFalseTotal
if $spec->{"optional"} 45 57 102
9426 # File-path params require a real file to exist, and object/coderef params
9427 # cannot be represented as plain YAML scalars. Such a constructor cannot
9428 # be built by the harness: calling new() with no arguments leaves a
9429 # required parameter missing, so the harness must skip the routine
9430 # rather than fail on a call it could never have made correctly.
9431 57 ▶ if ($param_name =~ /(?:file|path|dir|filename)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param_name =~ /(?:file|path|dir|filename)/i) 11 46 57
9432 11 return undef;
9433 }
9434 46 ▶ my $type = $spec->{type} // 'string';
Condition50%1/2
$spec->{"type"} // "string"
l!l
460
MC/DC0%0/1
$spec->{"type"} // "string"
$spec->{"type"}
Truth table50%1/2
A
A= $spec->{"type"}
Aresult
11
00
9435 46 ▶ unless (exists $REP{$type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $REP{$type}) 7 39 46
9436 7 return undef;
9437 }
9438 39 $args{$param_name} = $REP{$type};
9439 }
9440 75 return \%args;
9441 }
9442  
9443 # an object to be instantiated before
9444 # it can be called, and if so return
9445 # the package name to instantiate.
9446 #
9447 # Entry: $method_name - name of the method.
9448 # $method_body - method source string.
9449 # $method_info - method hashref from
9450 # _find_methods (optional,
9451 # for backward compat).
9452 #
9453 # Exit: Returns the package name string if
9454 # object instantiation is required.
9455 # Returns undef if the method is a
9456 # constructor, factory, singleton, or
9457 # pure class method.
9458 #
9459 # Side effects: Logs analysis decisions to stdout
9460 # when verbose is set.
9461 #
9462 # Notes: Orchestrates five detection sub-steps:
9463 # factory detection, singleton detection,
9464 # instance method detection, inheritance
9465 # check, and constructor requirements.
9466 # Instance method detection overrides
9467 # factory detection when both fire.
9468 # --------------------------------------------------
9469 769 ▶sub _needs_object_instantiation {
Subroutine _needs_object_instantiation: called CC=24 SCAR=32.0
9470 769 my ($self, $method_name, $method_body, $method_info) = @_;
9471  
9472 # Allow method_info to be optional for backward compatibility
9473 769 ▶ $method_info ||= {};
Condition50%1/2
$method_info ||= {}
l!l
7690
MC/DC0%0/1
$method_info ||= {}
$method_info
Truth table50%1/2
A
A= $method_info
Aresult
11
00
9474  
9475 769 my $doc = $self->{_document};
9476 769 ▶ return undef unless $doc;
Branch: 1 branch
BranchTrueFalseTotal
unless $doc 0 769 769
9477  
9478 # Get the current package name
9479 769 my $package_stmt = $doc->find_first('PPI::Statement::Package');
9480 769 ▶ my $current_package = $package_stmt ? $package_stmt->namespace : 'UNKNOWN';
Branch: 1 branch
BranchTrueFalseTotal
$package_stmt ? : 763 6 769
9481 769 ▶ $self->{_package_name} //= $current_package;
Condition66%2/3
$self->{"_package_name"} //= $current_package
l!l&&r!l&&!r
76720
MC/DC0%0/2
$self->{"_package_name"} //= $current_package
$self->{"_package_name"} $current_package
Truth table66%2/3
A //= B
A= $self->{"_package_name"}B= $current_package
ABresult
1X1
011
000
9482  
9483 # Initialize result structure
9484 769 my $result = {
9485 package => $current_package,
9486 needs_object => 0,
9487 type => 'unknown',
9488 details => {},
9489 constructor_params => undef,
9490 };
9491  
9492 # Track whether we should explicitly skip object instantiation
9493 769 my $skip_object = 0;
9494  
9495 # Skip constructors and destructors
9496 769 ▶ if ($method_name eq 'new') {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name eq "new") 93 676 769
9497 93 $self->_log(" OBJECT: Constructor '$method_name' detected; skipping instantiation analysis");
9498 93 return undef;
9499 }
9500 676 ▶ if($method_name =~ /^(create|build|construct|init|DESTROY)$/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name =~ /^(create|build|construct|init|DESTROY)$/i) 1 675 676
9501 1 $skip_object = 1;
9502 }
9503  
9504 # 1. Check for factory methods that return instances
9505 676 my $is_factory = $self->_detect_factory_method(
9506 $method_name, $method_body, $current_package, $method_info
9507 );
9508  
9509 # 2. Check for singleton patterns
9510 676 my $is_singleton = $self->_detect_singleton_pattern($method_name, $method_body);
9511 676 ▶ if ($is_singleton) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_singleton) 1 675 676
9512 1 $result->{needs_object} = 0; # Singleton methods return the singleton instance
9513 1 $result->{type} = 'singleton_accessor';
9514 1 $result->{details} = $is_singleton;
9515 1 $self->_log(" OBJECT: Detected singleton accessor '$method_name'");
9516 # Singleton accessors typically don't need object creation in tests
9517 # as they're called on the class, not instance
9518 1 $skip_object = 1;
9519 }
9520  
9521 # 3. Check if this is an instance method that needs an object
9522 676 my $is_instance_method = $self->_detect_instance_method($method_name, $method_body);
9523 676 ▶ if ($is_instance_method &&
Branch: 1 branch
BranchTrueFalseTotal
if ($is_instance_method and $is_instance_method->{"explicit_self"} || $is_instance_method->{"shift_self"} || $is_instance_method->{"accesses_object_data"} || $is_instance_method->{"calls_instance_methods"} && scalar @{$is_instance_method->{"calls_instance_methods"};}) 375 301 676
Condition78%11/14
$is_instance_method and $is_instance_method->{"explicit_self"} || $is_instance_method->{"shift_self"} || $is_instance_method->{"accesses_object_data"} || $is_instance_method->{"calls_instance_methods"} && scalar @{$is_instance_method->{"calls_instance_methods"};}
!ll&&!rl&&r
29011375
$is_instance_method->{"explicit_self"} or $is_instance_method->{"shift_self"} or $is_instance_method->{"accesses_object_data"} or $is_instance_method->{"calls_instance_methods"} and scalar @{$is_instance_method->{"calls_instance_methods"};}
l!l&&r!l&&!r
375011
$is_instance_method->{"explicit_self"} or $is_instance_method->{"shift_self"} or $is_instance_method->{"accesses_object_data"}
l!l&&r!l&&!r
375011
$is_instance_method->{"explicit_self"} or $is_instance_method->{"shift_self"}
l!l&&r!l&&!r
3472811
$is_instance_method->{"calls_instance_methods"} and scalar @{$is_instance_method->{"calls_instance_methods"};}
!ll
110
MC/DC60%3/5
$is_instance_method and $is_instance_method->{"explicit_self"} || $is_instance_method->{"shift_self"} || $is_instance_method->{"accesses_object_data"} || $is_instance_method->{"calls_instance_methods"} && scalar @{$is_instance_method->{"calls_instance_methods"};}
$is_instance_method $is_instance_method->{"explicit_self"} $is_instance_method->{"shift_self"} $is_instance_method->{"accesses_object_data"} $is_instance_method->{"calls_instance_methods"}
Truth table66%4/6
A and B or C or D or E
A= $is_instance_methodB= $is_instance_method->{"explicit_self"}C= $is_instance_method->{"shift_self"}D= $is_instance_method->{"accesses_object_data"}E= $is_instance_method->{"calls_instance_methods"}
ABCDEresult
0XXXX0
100000
11XXX1
101XX1
1001X1
100011
9524 ($is_instance_method->{explicit_self} ||
9525 $is_instance_method->{shift_self} ||
9526 $is_instance_method->{accesses_object_data} ||
9527 ($is_instance_method->{calls_instance_methods} &&
9528 0 scalar @{$is_instance_method->{calls_instance_methods}}))) {
9529  
9530 # Instance-only methods override factory detection
9531 375 ▶ if ($is_factory) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_factory) 26 349 375
9532 26 $self->_log(
9533 " OBJECT: Instance-only method '$method_name' overrides factory detection"
9534 );
9535 }
9536  
9537 375 $result->{needs_object} = 1;
9538 375 $result->{type} = 'instance_method';
9539 375 $result->{details} = $is_instance_method;
9540  
9541 # 4. Check for inheritance - if parent class constructor should be used
9542 375 my $inheritance_info = $self->_check_inheritance_for_constructor(
9543 $current_package, $method_body
9544 );
9545 375 ▶ if ($inheritance_info && $inheritance_info->{use_parent_constructor}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($inheritance_info and $inheritance_info->{"use_parent_constructor"}) 24 351 375
Condition100%3/3
$inheritance_info and $inheritance_info->{"use_parent_constructor"}
!ll&&!rl&&r
15419724
MC/DC100%2/2
$inheritance_info and $inheritance_info->{"use_parent_constructor"}
$inheritance_info $inheritance_info->{"use_parent_constructor"}
Truth table100%3/3
A and B
A= $inheritance_infoB= $inheritance_info->{"use_parent_constructor"}
ABresult
0X0
100
111
9546 24 $result->{package} = $inheritance_info->{parent_class};
9547 24 $result->{details}{inheritance} = $inheritance_info;
9548 24 $self->_log(
9549 " OBJECT: Method '$method_name' uses parent class constructor: $inheritance_info->{parent_class}"
9550 );
9551 }
9552  
9553 # 5. Check if constructor needs specific parameters
9554 my $constructor_needs = $self->_detect_constructor_requirements(
9555 $current_package, $result->{package}
9556 375 );
9557 375 ▶ if ($constructor_needs) {
Branch: 1 branch
BranchTrueFalseTotal
if ($constructor_needs) 109 266 375
9558 109 $result->{constructor_params} = $constructor_needs;
9559 109 $result->{details}{constructor_requirements} = $constructor_needs;
9560 109 $self->_log(
9561 " OBJECT: Constructor for $result->{package} requires parameters"
9562 );
9563 }
9564  
9565 # Return the package name (or parent package) that needs instantiation
9566 375 return $result->{package};
9567 }
9568  
9569 # 6. Check for class methods that might need objects from other classes
9570 301 my $needs_other_object = $self->_detect_external_object_dependency($method_body);
9571 301 ▶ if ($needs_other_object) {
Branch: 1 branch
BranchTrueFalseTotal
if ($needs_other_object) 6 295 301
9572 6 $result->{needs_object} = 1;
9573 6 $result->{type} = 'external_dependency';
9574 $result->{package} = $needs_other_object->{package}
9575 6 ▶ if $needs_other_object->{package};
Branch: 1 branch
BranchTrueFalseTotal
if $needs_other_object->{"package"} 6 0 6
9576 6 $result->{details} = $needs_other_object;
9577  
9578 6 $self->_log(
9579 " OBJECT: Method '$method_name' depends on external object: $needs_other_object->{package}"
9580 );
9581 6 ▶ return $result->{package} if $result->{package};
Branch: 1 branch
BranchTrueFalseTotal
if $result->{"package"} 6 0 6
9582 }
9583  
9584 # Factory method only if NOT instance-based
9585 295 ▶ if ($is_factory && !$skip_object) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_factory and not $skip_object) 2 293 295
Condition100%3/3
$is_factory and not $skip_object
!ll&&!rl&&r
29122
MC/DC100%2/2
$is_factory and not $skip_object
$is_factory not $skip_object
Truth table100%3/3
A and not(B)
A= $is_factoryB= not $skip_object
ABresult
0X0
100
111
9586 2 $result->{needs_object} = 0;
9587 2 $result->{type} = 'factory';
9588 2 $result->{details} = $is_factory;
9589 $self->_log(
9590 " OBJECT: Detected factory method '$method_name' returns $is_factory->{returns_class} objects"
9591 2 ▶ ) if $is_factory->{returns_class};
Branch: 1 branch
BranchTrueFalseTotal
if $is_factory->{"returns_class"} 2 0 2
9592 }
9593  
9594 295 return undef;
9595 }
9596  
9597 # --------------------------------------------------
9598 # _detect_factory_method
9599 #
9600 # Purpose: Detect whether a method is a factory
9601 # that creates and returns object
9602 # instances rather than operating on
9603 # an existing instance.
9604 #
9605 # Entry: $method_name - method name string.
9606 # $method_body - method source string.
9607 # $current_package - current package name.
9608 # $method_info - method hashref
9609 # (optional).
9610 #
9611 # Exit: Returns a factory_info hashref on
9612 # detection, or undef if the method
9613 # is not a factory.
9614 # The hashref includes: returns_class,
9615 # confidence, and one of:
9616 # returns_blessed, returns_new,
9617 # returns_factory_result, pod_hint.
9618 #
9619 # Side effects: None.
9620 # --------------------------------------------------
9621 679 ▶sub _detect_factory_method {
Subroutine _detect_factory_method: called CC=19 SCAR=32.9
9622 679 my ($self, $method_name, $method_body, $current_package, $method_info) = @_;
9623  
9624 679 my %factory_info;
9625  
9626 # Check method name patterns
9627 679 ▶ if ($method_name =~ /^(create_|make_|build_|get_)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name =~ /^(create_|make_|build_|get_)/i) 21 658 679
9628 21 $factory_info{name_pattern} = 1;
9629 }
9630  
9631 # Look for object creation patterns in the method body
9632 679 ▶ if ($method_body) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body) 679 0 679
9633 # Pattern 1: Returns a blessed reference
9634 679 ▶ if ($method_body =~ /return\s+bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?/s ||
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /return\s+bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?/s or $method_body =~ /bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?.*return/s) 6 673 679
Condition66%2/3
$method_body =~ /return\s+bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?/s or $method_body =~ /bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?.*return/s
l!l&&r!l&&!r
60673
MC/DC50%1/2
$method_body =~ /return\s+bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?/s or $method_body =~ /bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?.*return/s
$method_body =~ /return\s+bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?/s $method_body =~ /bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?.*return/s
Truth table66%2/3
A or B
A= $method_body =~ /return\s+bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?/sB= $method_body =~ /bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?.*return/s
ABresult
1X1
011
000
9635 $method_body =~ /bless\s*\{[^}]*\},\s*['"]?(\w+(?:::\w+)*|\$\w+)['"]?.*return/s) {
9636 6 my $class_name = $1;
9637  
9638 # Handle variable class names
9639 6 ▶ if ($class_name =~ /^\$(class|self|package)$/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($class_name =~ /^\$(class|self|package)$/) { } 3 3 6
elsif ($class_name =~ /^\$/) { } 1 2 3
9640 3 $factory_info{returns_class} = $current_package;
9641 } elsif ($class_name =~ /^\$/) {
9642 1 $factory_info{returns_class} = 'VARIABLE'; # Unknown variable
9643 } else {
9644 2 $factory_info{returns_class} = $class_name;
9645 }
9646  
9647 6 $factory_info{returns_blessed} = 1;
9648 6 $factory_info{confidence} = 'high';
9649 6 return \%factory_info;
9650 }
9651  
9652 # Pattern 2: Returns ->new() call on class or $self
9653 673 ▶ if ($method_body =~ /return\s+([\$\w:]+)->new\(/s ||
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /return\s+([\$\w:]+)->new\(/s or $method_body =~ /([\$\w:]+)->new\(.*return/s) 33 640 673
Condition100%3/3
$method_body =~ /return\s+([\$\w:]+)->new\(/s or $method_body =~ /([\$\w:]+)->new\(.*return/s
l!l&&r!l&&!r
231640
MC/DC100%2/2
$method_body =~ /return\s+([\$\w:]+)->new\(/s or $method_body =~ /([\$\w:]+)->new\(.*return/s
$method_body =~ /return\s+([\$\w:]+)->new\(/s $method_body =~ /([\$\w:]+)->new\(.*return/s
Truth table100%3/3
A or B
A= $method_body =~ /return\s+([\$\w:]+)->new\(/sB= $method_body =~ /([\$\w:]+)->new\(.*return/s
ABresult
1X1
011
000
9654 $method_body =~ /([\$\w:]+)->new\(.*return/s) {
9655 33 my $target = $1;
9656  
9657 # Determine what class is being instantiated
9658 33 ▶ if ($target eq '$self' || $target eq 'shift' || $target =~ /^\$/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($target eq '$self' or $target eq 'shift' or $target =~ /^\$/) { } 0 33 33
elsif ($target =~ /::/) { } 28 5 33
Condition33%2/6
$target eq "\$self" or $target eq "shift" or $target =~ /^\$/
l!l&&r!l&&!r
0033
$target eq "\$self" or $target eq "shift"
l!l&&r!l&&!r
0033
MC/DC0%0/3
$target eq "\$self" or $target eq "shift" or $target =~ /^\$/
$target eq "\$self" $target eq "shift" $target =~ /^\$/
Truth table25%1/4
A or B or C
A= $target eq "\$self"B= $target eq "shift"C= $target =~ /^\$/
ABCresult
1XX1
01X1
0011
0000
9659 0 $factory_info{returns_class} = $current_package;
9660 0 $factory_info{self_new} = 1;
9661 } elsif ($target =~ /::/) {
9662 28 $factory_info{returns_class} = $target;
9663 28 $factory_info{external_class} = 1;
9664 } else {
9665 5 $factory_info{returns_class} = $target;
9666 }
9667  
9668 33 $factory_info{returns_new} = 1;
9669 33 $factory_info{confidence} = 'medium';
9670 33 return \%factory_info;
9671 }
9672  
9673 # Pattern 3: Returns an object from another factory method
9674 640 ▶ if ($method_body =~ /return\s+([\$\w:]+)->(create_|make_|build_|get_)/i ||
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /return\s+([\$\w:]+)->(create_|make_|build_|get_)/i or $method_body =~ /([\$\w:]+)->(create_|make_|build_|get_).*return/is) 0 640 640
Condition33%1/3
$method_body =~ /return\s+([\$\w:]+)->(create_|make_|build_|get_)/i or $method_body =~ /([\$\w:]+)->(create_|make_|build_|get_).*return/is
l!l&&r!l&&!r
00640
MC/DC0%0/2
$method_body =~ /return\s+([\$\w:]+)->(create_|make_|build_|get_)/i or $method_body =~ /([\$\w:]+)->(create_|make_|build_|get_).*return/is
$method_body =~ /return\s+([\$\w:]+)->(create_|make_|build_|get_)/i $method_body =~ /([\$\w:]+)->(create_|make_|build_|get_).*return/is
Truth table33%1/3
A or B
A= $method_body =~ /return\s+([\$\w:]+)->(create_|make_|build_|get_)/iB= $method_body =~ /([\$\w:]+)->(create_|make_|build_|get_).*return/is
ABresult
1X1
011
000
9675 $method_body =~ /([\$\w:]+)->(create_|make_|build_|get_).*return/si) {
9676 0 $factory_info{returns_factory_result} = 1;
9677 0 $factory_info{confidence} = 'low';
9678 0 return \%factory_info;
9679 }
9680 }
9681  
9682 # Check for return type hints in POD if available
9683 640 ▶ if ($method_info && ref($method_info) eq 'HASH' && $method_info->{pod}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_info and ref $method_info eq "HASH" and $method_info->{"pod"}) 397 243 640
Condition50%3/6
$method_info and ref $method_info eq "HASH" and $method_info->{"pod"}
!ll&&!rl&&r
0243397
$method_info and ref $method_info eq "HASH"
!ll&&!rl&&r
00640
MC/DC33%1/3
$method_info and ref $method_info eq "HASH" and $method_info->{"pod"}
$method_info ref $method_info eq "HASH" $method_info->{"pod"}
Truth table50%2/4
A and B and C
A= $method_infoB= ref $method_info eq "HASH"C= $method_info->{"pod"}
ABCresult
0XX0
10X0
1100
1111
9684 397 my $pod = $method_info->{pod};
9685 397 ▶ if ($pod =~ /returns?\s+(?:an?\s+)?(object|instance|new\s+\w+)/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /returns?\s+(?:an?\s+)?(object|instance|new\s+\w+)/i) 0 397 397
9686 0 $factory_info{pod_hint} = 1;
9687 0 $factory_info{confidence} = 'low';
9688 0 return \%factory_info;
9689 }
9690 }
9691  
9692 640 return undef;
9693 }
9694  
9695 # --------------------------------------------------
9696 # _detect_singleton_pattern
9697 #
9698 # Purpose: Detect singleton accessor methods
9699 # that return a shared instance rather
9700 # than creating a new object, by
9701 # checking the method name and body
9702 # for singleton patterns.
9703 #
9704 # Entry: $method_name - method name string.
9705 # $method_body - method source string.
9706 #
9707 # Exit: Returns a singleton_info hashref on
9708 # detection (always contains at least
9709 # name_pattern => 1), or undef if the
9710 # method name does not match the
9711 # singleton accessor pattern.
9712 #
9713 # Side effects: None.
9714 #
9715 # Notes: Only fires for methods named
9716 # instance, get_instance, singleton,
9717 # or shared_instance. Methods not
9718 # matching these names always return
9719 # undef regardless of body content.
9720 # --------------------------------------------------
9721 682 ▶sub _detect_singleton_pattern {
Subroutine _detect_singleton_pattern: called CC=12 SCAR=25.4
9722 682 my ($self, $method_name, $method_body) = @_;
9723  
9724 # Check method name patterns
9725 682 ▶ return undef unless $method_name =~ /^(instance|get_instance|singleton|shared_instance)$/i;
Branch: 1 branch
BranchTrueFalseTotal
unless $method_name =~ /^(instance|get_instance|singleton|shared_instance)$/i 677 5 682
9726  
9727 5 my %singleton_info = (
9728 name_pattern => 1,
9729 );
9730  
9731 # Look for singleton patterns in code
9732 5 ▶ if ($method_body) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body) 5 0 5
9733 # Pattern 1: Static/state variable holding instance
9734 5 ▶ if ($method_body =~ /(?:my\s+)?(?:our\s+)?\$(?:instance|_instance|singleton)\b/s ||
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /(?:my\s+)?(?:our\s+)?\$(?:instance|_instance|singleton)\b/s or $method_body =~ /state\s+\$(?:instance|_instance|singleton)\b/s) 4 1 5
Condition66%2/3
$method_body =~ /(?:my\s+)?(?:our\s+)?\$(?:instance|_instance|singleton)\b/s or $method_body =~ /state\s+\$(?:instance|_instance|singleton)\b/s
l!l&&r!l&&!r
401
MC/DC50%1/2
$method_body =~ /(?:my\s+)?(?:our\s+)?\$(?:instance|_instance|singleton)\b/s or $method_body =~ /state\s+\$(?:instance|_instance|singleton)\b/s
$method_body =~ /(?:my\s+)?(?:our\s+)?\$(?:instance|_instance|singleton)\b/s $method_body =~ /state\s+\$(?:instance|_instance|singleton)\b/s
Truth table66%2/3
A or B
A= $method_body =~ /(?:my\s+)?(?:our\s+)?\$(?:instance|_instance|singleton)\b/sB= $method_body =~ /state\s+\$(?:instance|_instance|singleton)\b/s
ABresult
1X1
011
000
9735 $method_body =~ /state\s+\$(?:instance|_instance|singleton)\b/s) {
9736 4 $singleton_info{static_variable} = 1;
9737 4 $singleton_info{confidence} = 'high';
9738 }
9739  
9740 # Pattern 2: Returns $instance if defined (with better regex)
9741 5 ▶ if ($method_body =~ /return\s+\$instance\s+if\s+(?:defined\s+)?\$instance/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /return\s+\$instance\s+if\s+(?:defined\s+)?\$instance/ or $method_body =~ /unless\s+\$instance.*?=\s*.*?new/) 1 4 5
Condition66%2/3
$method_body =~ /return\s+\$instance\s+if\s+(?:defined\s+)?\$instance/ or $method_body =~ /unless\s+\$instance.*?=\s*.*?new/
l!l&&r!l&&!r
104
MC/DC50%1/2
$method_body =~ /return\s+\$instance\s+if\s+(?:defined\s+)?\$instance/ or $method_body =~ /unless\s+\$instance.*?=\s*.*?new/
$method_body =~ /return\s+\$instance\s+if\s+(?:defined\s+)?\$instance/ $method_body =~ /unless\s+\$instance.*?=\s*.*?new/
Truth table66%2/3
A or B
A= $method_body =~ /return\s+\$instance\s+if\s+(?:defined\s+)?\$instance/B= $method_body =~ /unless\s+\$instance.*?=\s*.*?new/
ABresult
1X1
011
000
9742 $method_body =~ /unless\s+\$instance.*?=\s*.*?new/) {
9743 1 $singleton_info{returns_instance} = 1;
9744 1 $singleton_info{confidence} = 'high';
9745 }
9746  
9747 # Pattern 3: ||= new() pattern (with better regex)
9748 5 ▶ if ($method_body =~ /\$instance\s*\|\|=\s*.*?new/ ||
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /\$instance\s*\|\|=\s*.*?new/ or $method_body =~ /\$instance\s*=\s*.*?new\s+unless\s+(?:defined\s+)?\$instance/) 2 3 5
Condition66%2/3
$method_body =~ /\$instance\s*\|\|=\s*.*?new/ or $method_body =~ /\$instance\s*=\s*.*?new\s+unless\s+(?:defined\s+)?\$instance/
l!l&&r!l&&!r
203
MC/DC50%1/2
$method_body =~ /\$instance\s*\|\|=\s*.*?new/ or $method_body =~ /\$instance\s*=\s*.*?new\s+unless\s+(?:defined\s+)?\$instance/
$method_body =~ /\$instance\s*\|\|=\s*.*?new/ $method_body =~ /\$instance\s*=\s*.*?new\s+unless\s+(?:defined\s+)?\$instance/
Truth table66%2/3
A or B
A= $method_body =~ /\$instance\s*\|\|=\s*.*?new/B= $method_body =~ /\$instance\s*=\s*.*?new\s+unless\s+(?:defined\s+)?\$instance/
ABresult
1X1
011
000
9749 $method_body =~ /\$instance\s*=\s*.*?new\s+unless\s+(?:defined\s+)?\$instance/) {
9750 2 $singleton_info{lazy_initialization} = 1;
9751 2 $singleton_info{confidence} = 'medium';
9752 }
9753  
9754 # Pattern 4: Direct return of $instance variable
9755 5 ▶ if ($method_body =~ /return\s+\$instance;/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /return\s+\$instance;/) 3 2 5
9756 3 $singleton_info{returns_instance} = 1;
9757 3 ▶ $singleton_info{confidence} = 'high' unless $singleton_info{confidence};
Branch: 1 branch
BranchTrueFalseTotal
unless $singleton_info{"confidence"} 0 3 3
9758 }
9759 }
9760  
9761 5 ▶ return \%singleton_info if keys %singleton_info > 0; # Need at least name pattern
Branch: 1 branch
BranchTrueFalseTotal
if keys %singleton_info > 0 5 0 5
9762  
9763 0 return undef;
9764 }
9765  
9766 # --------------------------------------------------
9767 # _detect_instance_method
9768 #
9769 # Purpose: Detect whether a method is an
9770 # instance method that requires a
9771 # blessed object ($self) to be called,
9772 # through multiple detection patterns
9773 # of varying confidence.
9774 #
9775 # Entry: $method_name - method name string.
9776 # $method_body - method source string.
9777 #
9778 # Exit: Returns an instance_info hashref if
9779 # any instance method signal is found.
9780 # Returns undef if no signals are
9781 # detected.
9782 # The hashref may contain: explicit_self,
9783 # shift_self, uses_self,
9784 # accesses_object_data,
9785 # calls_instance_methods,
9786 # private_method, and confidence.
9787 #
9788 # Side effects: None.
9789 # --------------------------------------------------
9790 681 ▶sub _detect_instance_method {
Subroutine _detect_instance_method: called CC=14 SCAR=26.4
9791 681 my ($self, $method_name, $method_body) = @_;
9792  
9793 681 my %instance_info;
9794  
9795 # Pattern 1: my ($self, ...) = @_;
9796 681 ▶ if ($method_body =~ /my\s*\(\s*\$self\s*[,)]/) {
Branch: 4 branches
BranchTrueFalseTotal
if ($method_body =~ /my\s*\(\s*\$self\s*[,)]/) { } 292 389 681
elsif ($method_body =~ /my\s+\$self\s*=\s*\$_\[0\]/) { } 55 334 389
elsif ($method_body =~ /my\s+\$self\s*=\s*shift/) { } 30 304 334
elsif ($method_body =~ /\$self\s*->\s*(\w+|[\{\[])/) { } 2 302 304
9797 292 $instance_info{explicit_self} = 1;
9798 292 $instance_info{confidence} = 'high';
9799 }
9800  
9801 # Pattern 1b: my $self = $_[0]; (direct-index style)
9802 elsif ($method_body =~ /my\s+\$self\s*=\s*\$_\[0\]/) {
9803 55 $instance_info{explicit_self} = 1;
9804 55 $instance_info{confidence} = 'high';
9805 }
9806  
9807 # Pattern 2: my $self = shift;
9808 elsif ($method_body =~ /my\s+\$self\s*=\s*shift/) {
9809 30 $instance_info{shift_self} = 1;
9810 30 $instance_info{confidence} = 'high';
9811 }
9812  
9813 # Pattern 3: Uses $self->something (including hash/array access)
9814 # This catches $self->{value} and $self->[0] as well as $self->method()
9815 elsif ($method_body =~ /\$self\s*->\s*(\w+|[\{\[])/) {
9816 2 $instance_info{uses_self} = 1;
9817 2 $instance_info{confidence} = 'medium';
9818 }
9819  
9820 # Pattern 4: Accesses object data: $self->{...}, $self->[...]
9821 681 ▶ if ($method_body =~ /\$self\s*->\s*[\{\[]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /\$self\s*->\s*[\{\[]/) 161 520 681
9822 161 $instance_info{accesses_object_data} = 1;
9823 161 ▶ $instance_info{confidence} = 'high' unless $instance_info{confidence} eq 'high';
Branch: 1 branch
BranchTrueFalseTotal
unless $instance_info{"confidence"} eq "high" 2 159 161
9824 }
9825  
9826 # Pattern 5: Calls other instance methods on $self
9827 681 ▶ if ($method_body =~ /\$self\s*->\s*(\w+)\s*\(/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /\$self\s*->\s*(\w+)\s*\(/s) 44 637 681
9828 44 $instance_info{calls_instance_methods} = [];
9829 44 ▶ while ($method_body =~ /\$self\s*->\s*(\w+)\s*\(/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /\$self\s*->\s*(\w+)\s*\(/g) 122 44 166
9830 122 push @{$instance_info{calls_instance_methods}}, $1;
9831 }
9832 44 ▶ $instance_info{confidence} = 'high' if @{$instance_info{calls_instance_methods}};
Branch: 1 branch
BranchTrueFalseTotal
if @{$instance_info{"calls_instance_methods"};} 44 0 44
9833 }
9834  
9835 # Pattern 6: Method name suggests instance method (not perfect but helpful)
9836 681 ▶ if ($method_name =~ /^_/ && $method_name !~ /^_new/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_name =~ /^_/ and not $method_name =~ /^_new/) 17 664 681
Condition100%3/3
$method_name =~ /^_/ and not $method_name =~ /^_new/
!ll&&!rl&&r
661317
MC/DC100%2/2
$method_name =~ /^_/ and not $method_name =~ /^_new/
$method_name =~ /^_/ not $method_name =~ /^_new/
Truth table100%3/3
A and not(B)
A= $method_name =~ /^_/B= not $method_name =~ /^_new/
ABresult
0X0
100
111
9837 # Private methods are usually instance methods
9838 17 $instance_info{private_method} = 1;
9839 17 ▶ $instance_info{confidence} = 'low' unless exists $instance_info{confidence};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $instance_info{"confidence"} 11 6 17
9840 }
9841  
9842 681 ▶ return \%instance_info if keys %instance_info;
Branch: 1 branch
BranchTrueFalseTotal
if keys %instance_info 390 291 681
9843 291 return undef;
9844 }
9845  
9846 # --------------------------------------------------
9847 # _check_inheritance_for_constructor
9848 #
9849 # Purpose: Determine whether the current package
9850 # uses an inherited constructor from a
9851 # parent class, by examining use parent,
9852 # use base, and @ISA declarations.
9853 #
9854 # Entry: $current_package - current package
9855 # name string.
9856 # $method_body - method source string
9857 # (checked for SUPER::
9858 # calls).
9859 #
9860 # Exit: Returns an inheritance_info hashref
9861 # if any inheritance information is
9862 # found, or undef otherwise.
9863 # The hashref may contain:
9864 # parent_statements, isa_array,
9865 # uses_super, calls_super_new,
9866 # has_own_constructor,
9867 # use_parent_constructor, parent_class.
9868 #
9869 # Side effects: None.
9870 # --------------------------------------------------
9871 378 ▶sub _check_inheritance_for_constructor {
Subroutine _check_inheritance_for_constructor: called CC=18 SCAR=29.8
9872 378 my ($self, $current_package, $method_body) = @_;
9873  
9874 378 my $doc = $self->{_document};
9875 378 ▶ return undef unless $doc;
Branch: 1 branch
BranchTrueFalseTotal
unless $doc 1 377 378
9876  
9877 377 my %inheritance_info;
9878  
9879 # 1. Look for parent/base statements
9880 my @parent_classes;
9881  
9882 # Find all 'use parent' or 'use base' statements
9883 377 ▶ my $includes = $doc->find('PPI::Statement::Include') || [];
Condition100%2/2
$doc->find('PPI::Statement::Include') || []
l!l
31562
MC/DC100%1/1
$doc->find('PPI::Statement::Include') || []
$doc->find('PPI::Statement::Include')
Truth table100%2/2
A
A= $doc->find('PPI::Statement::Include')
Aresult
11
00
9884 377 foreach my $inc (@$includes) {
9885 1500 my $content = $inc->content;
9886 1500 ▶ if ($content =~ /use\s+(parent|base)\s+['"]?([\w:]+)['"]?/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /use\s+(parent|base)\s+['"]?([\w:]+)['"]?/) 28 1472 1500
9887 28 push @parent_classes, $2;
9888 28 $inheritance_info{parent_statements} = \@parent_classes;
9889 }
9890 # Also check for multiple parents: use parent qw(Class1 Class2)
9891 1500 ▶ if ($content =~ /use\s+(parent|base)\s+qw?[\(\[]?(.+?)[\)\]]?;/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /use\s+(parent|base)\s+qw?[\(\[]?(.+?)[\)\]]?;/) 0 1500 1500
9892 0 my $parents = $2;
9893 0 my @multi_parents = split /\s+/, $parents;
9894 0 push @parent_classes, @multi_parents;
9895 0 $inheritance_info{parent_statements} = \@parent_classes;
9896 }
9897 }
9898  
9899 # 2. Look for @ISA assignments (with or without 'our')
9900 377 ▶ my $isas = $doc->find('PPI::Statement::Variable') || [];
Condition100%2/2
$doc->find('PPI::Statement::Variable') || []
l!l
3752
MC/DC100%1/1
$doc->find('PPI::Statement::Variable') || []
$doc->find('PPI::Statement::Variable')
Truth table100%2/2
A
A= $doc->find('PPI::Statement::Variable')
Aresult
11
00
9901 377 foreach my $isa (@$isas) {
9902 12234 my $content = $isa->content();
9903 # Match both "our @ISA = qw(...)" and "@ISA = qw(...)"
9904 12234 ▶ if ($content =~ /(?:our\s+)?\@ISA\s*=\s*qw?[\(\[]?(.+?)[\)\]]?/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /(?:our\s+)?\@ISA\s*=\s*qw?[\(\[]?(.+?)[\)\]]?/) 0 12234 12234
9905 0 my $parents = $1;
9906 0 my @isa_parents = split(/\s+/, $parents);
9907 0 push @parent_classes, @isa_parents;
9908 0 $inheritance_info{isa_array} = \@isa_parents;
9909 }
9910 }
9911  
9912 # Also look for @ISA in regular statements
9913 377 ▶ my $statements = $doc->find('PPI::Statement') || [];
Condition50%1/2
$doc->find('PPI::Statement') || []
l!l
3770
MC/DC0%0/1
$doc->find('PPI::Statement') || []
$doc->find('PPI::Statement')
Truth table50%1/2
A
A= $doc->find('PPI::Statement')
Aresult
11
00
9914 377 foreach my $stmt (@$statements) {
9915 105940 my $content = $stmt->content;
9916 105940 ▶ if ($content =~ /\@ISA\s*=\s*qw?[\(\[]?(.+?)[\)\]]?/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content =~ /\@ISA\s*=\s*qw?[\(\[]?(.+?)[\)\]]?/) 19 105921 105940
9917 19 my $parents = $1;
9918 19 my @isa_parents = split(/\s+/, $parents);
9919 19 push @parent_classes, @isa_parents;
9920 19 $inheritance_info{isa_array} = \@isa_parents;
9921 }
9922 }
9923  
9924 # 3. Check if method uses SUPER:: calls
9925 377 ▶ if ($method_body && $method_body =~ /SUPER::/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body and $method_body =~ /SUPER::/) 2 375 377
Condition100%3/3
$method_body and $method_body =~ /SUPER::/
!ll&&!rl&&r
23732
MC/DC100%2/2
$method_body and $method_body =~ /SUPER::/
$method_body $method_body =~ /SUPER::/
Truth table100%3/3
A and B
A= $method_bodyB= $method_body =~ /SUPER::/
ABresult
0X0
100
111
9926 2 $inheritance_info{uses_super} = 1;
9927 2 ▶ if ($method_body =~ /SUPER::new/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /SUPER::new/) 0 2 2
9928 0 $inheritance_info{calls_super_new} = 1;
9929 }
9930 }
9931  
9932 # 4. Check if current package has its own new method
9933 1043774 ▶ my $has_own_new = $doc->find(sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
9934 1043774 ▶ $_[1]->isa('PPI::Statement::Sub') &&
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Statement::Sub") and $_[1]->name eq "new" 3529 1040245 1043774
9935 $_[1]->name eq 'new'
9936 377 });
9937  
9938 377 ▶ if ($has_own_new) {
Branch: 2 branches
BranchTrueFalseTotal
if ($has_own_new) { } 198 179 377
elsif (@parent_classes) { } 25 154 179
9939 198 $inheritance_info{has_own_constructor} = 1;
9940 } elsif (@parent_classes) {
9941 # No own constructor, but has parents - might need parent constructor
9942 25 $inheritance_info{use_parent_constructor} = 1;
9943 25 $inheritance_info{parent_class} = $parent_classes[0]; # Use first parent
9944 }
9945  
9946 377 ▶ return \%inheritance_info if keys %inheritance_info;
Branch: 1 branch
BranchTrueFalseTotal
if keys %inheritance_info 223 154 377
9947 154 return undef;
9948 }
9949  
9950 # --------------------------------------------------
9951 # _detect_constructor_requirements
9952 #
9953 # Purpose: Analyse the new() method of the
9954 # current or target package to determine
9955 # what parameters the constructor
9956 # requires, including required and
9957 # optional parameters and their defaults.
9958 #
9959 # Entry: $current_package - the package being
9960 # analysed.
9961 # $target_package - the package whose
9962 # constructor will
9963 # be called (may
9964 # differ from current
9965 # for inherited
9966 # constructors).
9967 #
9968 # Exit: Returns a requirements hashref on
9969 # success, or undef if no new() method
9970 # is found. For external classes,
9971 # returns a minimal hashref with
9972 # external_class => 1.
9973 #
9974 # Side effects: None.
9975 # --------------------------------------------------
9976 379 ▶sub _detect_constructor_requirements {
Subroutine _detect_constructor_requirements: called CC=16 SCAR=27.8
9977 379 my ($self, $current_package, $target_package) = @_;
9978  
9979 379 my $doc = $self->{_document};
9980 379 ▶ return undef unless $doc;
Branch: 1 branch
BranchTrueFalseTotal
unless $doc 0 379 379
9981  
9982 # If target is different from current, we can't analyze it
9983 # (external class, parent class in different file)
9984 379 ▶ if ($target_package ne $current_package) {
Branch: 1 branch
BranchTrueFalseTotal
if ($target_package ne $current_package) 25 354 379
9985 return {
9986 25 external_class => 1,
9987 package => $target_package,
9988 note => "Constructor for external class $target_package - parameters unknown"
9989 };
9990 }
9991  
9992 # Find the new method in current package
9993 83540 ▶ my $new_method = $doc->find_first(sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
9994 83540 ▶ $_[1]->isa('PPI::Statement::Sub') &&
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Statement::Sub") and $_[1]->name eq "new" 927 82613 83540
9995 $_[1]->name eq 'new'
9996 354 });
9997  
9998 354 ▶ return undef unless $new_method;
Branch: 1 branch
BranchTrueFalseTotal
unless $new_method 155 199 354
9999  
10000 199 my %requirements;
10001  
10002 # Get method body
10003 199 my $body = $new_method->content;
10004  
10005 # Look for parameter extraction patterns - handle both $self and $class
10006 199 ▶ if ($body =~ /my\s*\(\s*\$(self|class)\s*,\s*(.+?)\)\s*=\s*\@_/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /my\s*\(\s*\$(self|class)\s*,\s*(.+?)\)\s*=\s*\@_/s) 126 73 199
10007 126 my $params = $2;
10008 126 my @param_names = $params =~ /\$(\w+)/g;
10009  
10010 126 ▶ if (@param_names) {
Branch: 1 branch
BranchTrueFalseTotal
if (@param_names) 3 123 126
10011 3 $requirements{parameters} = \@param_names;
10012 3 $requirements{parameter_count} = scalar @param_names;
10013 }
10014 }
10015  
10016 # Look for shift patterns
10017 199 my @shift_params;
10018 199 ▶ while ($body =~ /my\s+\$(\w+)\s*=\s*shift/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /my\s+\$(\w+)\s*=\s*shift/g) 9 199 208
10019 9 push @shift_params, $1;
10020 }
10021 # Remove $self or $class if present
10022 199 @shift_params = grep { $_ !~ /^(self|class|pkg|proto|klass)$/i } @shift_params;
10023  
10024 199 ▶ if (@shift_params) {
Branch: 1 branch
BranchTrueFalseTotal
if (@shift_params) 0 199 199
10025 0 $requirements{parameters} = \@shift_params;
10026 0 $requirements{parameter_count} = scalar @shift_params;
10027 0 $requirements{shift_pattern} = 1;
10028 }
10029  
10030 # Look for validation of parameters (more flexible pattern)
10031 199 my @required_params;
10032 199 ▶ if ($body =~ /croak.*unless.*(?:defined\s+)?\$(\w+)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /croak.*unless.*(?:defined\s+)?\$(\w+)/g) 86 113 199
10033 86 push @required_params, $1;
10034 }
10035 199 ▶ if ($body =~ /die.*unless.*(?:defined\s+)?\$(\w+)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($body =~ /die.*unless.*(?:defined\s+)?\$(\w+)/g) 1 198 199
10036 1 push @required_params, $1;
10037 }
10038  
10039 199 ▶ if (@required_params) {
Branch: 1 branch
BranchTrueFalseTotal
if (@required_params) 87 112 199
10040 87 $requirements{required_parameters} = \@required_params;
10041 }
10042  
10043 # Look for default values (optional parameters)
10044 199 my @optional_params;
10045 my %default_values;
10046  
10047 # Use the new _extract_default_value method
10048 # Check for each parameter in the constructor body
10049 199 ▶ if ($requirements{parameters}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($requirements{"parameters"}) 3 196 199
10050 3 foreach my $param (@{$requirements{parameters}}) {
10051 5 my $default = $self->_extract_default_value($param, $body);
10052 5 ▶ if (defined $default) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $default) 2 3 5
10053 2 push @optional_params, $param;
10054 2 $default_values{$param} = $default;
10055 }
10056 }
10057 }
10058  
10059 199 ▶ if (@optional_params) {
Branch: 1 branch
BranchTrueFalseTotal
if (@optional_params) 2 197 199
10060 2 $requirements{optional_parameters} = \@optional_params;
10061 2 $requirements{default_values} = \%default_values;
10062 }
10063  
10064 199 ▶ return \%requirements if keys %requirements;
Branch: 1 branch
BranchTrueFalseTotal
if keys %requirements 87 112 199
10065 112 return undef;
10066 }
10067  
10068  
10069 # --------------------------------------------------
10070 # _detect_external_object_dependency
10071 #
10072 # Purpose: Detect whether a method creates or
10073 # depends on objects from classes other
10074 # than the current package, by scanning
10075 # for ->new() calls on named classes
10076 # and method calls on typed variables.
10077 #
10078 # Entry: $method_body - method source string.
10079 # May be undef.
10080 #
10081 # Exit: Returns a dependency_info hashref if
10082 # external object usage is found, or
10083 # undef otherwise.
10084 # The hashref may contain:
10085 # creates_objects (arrayref of class
10086 # names), uses_objects (arrayref of
10087 # class names), and package (the primary
10088 # dependency class).
10089 #
10090 # Side effects: None.
10091 # --------------------------------------------------
10092 307 ▶sub _detect_external_object_dependency {
Subroutine _detect_external_object_dependency: called CC=15 SCAR=27.1
10093 307 my ($self, $method_body) = @_;
10094  
10095 307 ▶ return undef unless $method_body;
Branch: 1 branch
BranchTrueFalseTotal
unless $method_body 1 306 307
10096  
10097 306 my %dependency_info;
10098  
10099 # Pattern 1: Creates objects of other classes with ->new() or ->create()
10100 # Reset pos for global match
10101 306 pos($method_body) = 0;
10102 306 ▶ while ($method_body =~ /(\w+(?:::\w+)*)->(?:new|create)\(/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /(\w+(?:::\w+)*)->(?:new|create)\(/g) 14 306 320
10103 14 my $class = $1;
10104 14 ▶ next if $class eq 'main' || $class eq '__PACKAGE__' || $class =~ /^\$/;
Branch: 1 branch
BranchTrueFalseTotal
if $class eq "main" or $class eq "__PACKAGE__" or $class =~ /^\$/ 1 13 14
Condition66%4/6
$class eq "main" or $class eq "__PACKAGE__" or $class =~ /^\$/
l!l&&r!l&&!r
1013
$class eq "main" or $class eq "__PACKAGE__"
l!l&&r!l&&!r
0113
MC/DC33%1/3
$class eq "main" or $class eq "__PACKAGE__" or $class =~ /^\$/
$class eq "main" $class eq "__PACKAGE__" $class =~ /^\$/
Truth table50%2/4
A or B or C
A= $class eq "main"B= $class eq "__PACKAGE__"C= $class =~ /^\$/
ABCresult
1XX1
01X1
0011
0000
10105 13 push @{$dependency_info{creates_objects}}, $class;
10106 }
10107  
10108 306 ▶ if ($dependency_info{creates_objects}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($dependency_info{"creates_objects"}) 9 297 306
10109 # Remove duplicates
10110 9 my %seen;
10111 9 $dependency_info{creates_objects} = [grep { !$seen{$_}++ } @{$dependency_info{creates_objects}}];
10112 9 $dependency_info{package} = $dependency_info{creates_objects}[0];
10113 }
10114  
10115 # Pattern 2: Calls methods on objects from other classes
10116 306 ▶ if ($method_body =~ /\$(\w+)->\w+\(/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /\$(\w+)->\w+\(/) 12 294 306
10117 12 my %object_vars;
10118 # Reset pos for global match — the if check above used a
10119 # non-/g match so it cannot have advanced pos, but the while
10120 # loop's own /g matches still need to start from the beginning.
10121 12 pos($method_body) = 0;
10122 12 ▶ while ($method_body =~ /\$(\w+)->\w+\(/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_body =~ /\$(\w+)->\w+\(/g) 25 12 37
10123 25 $object_vars{$1}++;
10124 }
10125  
10126 # Try to determine type of object variables
10127 12 my @object_classes;
10128 12 foreach my $var (keys %object_vars) {
10129 # Look for type declarations or assignments
10130 22 ▶ if ($method_body =~ /my\s+\$$var\s*=\s*(\w+(?:::\w+)+)->(?:new|create)/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($method_body =~ /my\s+\$$var\s*=\s*(\w+(?:::\w+)+)->(?:new|create)/) { } 9 13 22
elsif ($method_body =~ /my\s+\$$var\s*=\s*(\w+(?:::\w+)+)->/) { } 0 13 13
10131 9 push @object_classes, $1;
10132 } elsif ($method_body =~ /my\s+\$$var\s*=\s*(\w+(?:::\w+)+)->/) {
10133 0 push @object_classes, $1;
10134 }
10135 }
10136  
10137 12 ▶ if (@object_classes) {
Branch: 1 branch
BranchTrueFalseTotal
if (@object_classes) 9 3 12
10138 9 $dependency_info{uses_objects} = \@object_classes;
10139 9 ▶ $dependency_info{package} = $object_classes[0] unless $dependency_info{package};
Branch: 1 branch
BranchTrueFalseTotal
unless $dependency_info{"package"} 1 8 9
10140 }
10141 }
10142  
10143 # Pattern 3: Receives objects as parameters (type hints in comments/POD)
10144 # This would need integration with parameter analysis
10145  
10146 306 ▶ return \%dependency_info if keys %dependency_info;
Branch: 1 branch
BranchTrueFalseTotal
if keys %dependency_info 10 296 306
10147 296 return undef;
10148 }
10149  
10150 # --------------------------------------------------
10151 # _get_parent_class
10152 #
10153 # Purpose: Find the first parent class of the
10154 # current package by searching the
10155 # PPI document for use parent, use base,
10156 # or our @ISA declarations.
10157 #
10158 # Entry: None (operates on $self->{_document}).
10159 #
10160 # Exit: Returns the parent class name string,
10161 # or undef if no parent is found.
10162 #
10163 # Side effects: None.
10164 # --------------------------------------------------
10165 0 ▶sub _get_parent_class {
Subroutine _get_parent_class: not called CC=5 SCAR=34.0
10166 0 my $self = $_[0];
10167  
10168 0 my $doc = $self->{_document};
10169 0 ▶ return unless $doc;
Branch: 1 branch
BranchTrueFalseTotal
unless $doc 0 0 0
10170  
10171 # Look for use parent statements
10172 0 ▶ my $parent_stmt = $doc->find_first(sub {
Subroutine __ANON__: not called CC=4 SCAR=30.0
10173 0 ▶ $_[1]->isa('PPI::Statement::Include') &&
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Statement::Include") and $_[1]->type eq "use" and $_[1]->module =~ /^(parent|base)$/ and $_[1]->arguments =~ /['"](\w+(?:::\w+)*)['"]/ 0 0 0
Condition0%0/6
$_[1]->isa("PPI::Statement::Include") and $_[1]->type eq "use" and $_[1]->module =~ /^(parent|base)$/
!ll&&!rl&&r
000
$_[1]->isa("PPI::Statement::Include") and $_[1]->type eq "use"
!ll&&!rl&&r
000
MC/DC0%0/3
$_[1]->isa("PPI::Statement::Include") and $_[1]->type eq "use" and $_[1]->module =~ /^(parent|base)$/
$_[1]->isa("PPI::Statement::Include") $_[1]->type eq "use" $_[1]->module =~ /^(parent|base)$/
Truth table0%0/4
A and B and C
A= $_[1]->isa("PPI::Statement::Include")B= $_[1]->type eq "use"C= $_[1]->module =~ /^(parent|base)$/
ABCresult
0XX0
10X0
1100
1111
10174 $_[1]->type eq 'use' &&
10175 $_[1]->module =~ /^(parent|base)$/ &&
10176 $_[1]->arguments =~ /['"](\w+(?:::\w+)*)['"]/
10177 0 });
10178 0 ▶ if ($parent_stmt) {
Branch: 1 branch
BranchTrueFalseTotal
if ($parent_stmt) 0 0 0
10179 0 my $parent = $1;
10180 0 return $parent;
10181 }
10182  
10183 # Look for @ISA assignment
10184 0 ▶ my $isa_stmt = $doc->find_first(sub {
Subroutine __ANON__: not called CC=2 SCAR=17.9
10185 0 ▶ $_[1]->isa('PPI::Statement') &&
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Statement") and $_[1]->content =~ /our\s+\@ISA\s*=\s*\(\s*['"](\w+(?:::\w+)*)['"]\s*\)/ 0 0 0
10186 $_[1]->content =~ /our\s+\@ISA\s*=\s*\(\s*['"](\w+(?:::\w+)*)['"]\s*\)/
10187 0 });
10188 0 ▶ if ($isa_stmt && $isa_stmt->content =~ /['"](\w+(?:::\w+)*)['"]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($isa_stmt and $isa_stmt->content =~ /['"](\w+(?:::\w+)*)['"]/) 0 0 0
Condition0%0/3
$isa_stmt and $isa_stmt->content =~ /['"](\w+(?:::\w+)*)['"]/
!ll&&!rl&&r
000
MC/DC0%0/2
$isa_stmt and $isa_stmt->content =~ /['"](\w+(?:::\w+)*)['"]/
$isa_stmt $isa_stmt->content =~ /['"](\w+(?:::\w+)*)['"]/
Truth table0%0/3
A and B
A= $isa_stmtB= $isa_stmt->content =~ /['"](\w+(?:::\w+)*)['"]/
ABresult
0X0
100
111
10189 0 return $1;
10190 }
10191  
10192 0 return;
10193 }
10194  
10195 # --------------------------------------------------
10196 # _get_class_for_instance_method
10197 #
10198 # Purpose: Determine which class should be used
10199 # for object instantiation when testing
10200 # an instance method, preferring the
10201 # current package if it has a new()
10202 # method, falling back to the parent
10203 # class otherwise.
10204 #
10205 # Entry: None (operates on $self->{_document}).
10206 #
10207 # Exit: Returns the package name string to
10208 # use for instantiation. Returns
10209 # 'UNKNOWN_PACKAGE' if no package
10210 # statement is found.
10211 #
10212 # Side effects: Stores the package name in
10213 # $self->{_package_name} if not
10214 # already set.
10215 # --------------------------------------------------
10216 0 ▶sub _get_class_for_instance_method {
Subroutine _get_class_for_instance_method: not called CC=5 SCAR=34.0
10217 0 my $self = $_[0];
10218  
10219 # Get the current package
10220 0 my $doc = $self->{_document};
10221 0 my $package_stmt = $doc->find_first('PPI::Statement::Package');
10222 0 ▶ return 'UNKNOWN_PACKAGE' unless $package_stmt;
Branch: 1 branch
BranchTrueFalseTotal
unless $package_stmt 0 0 0
10223 0 my $package_name = $package_stmt->namespace;
10224 0 ▶ $self->{_package_name} //= $package_name;
Condition0%0/3
$self->{"_package_name"} //= $package_name
l!l&&r!l&&!r
000
MC/DC0%0/2
$self->{"_package_name"} //= $package_name
$self->{"_package_name"} $package_name
Truth table0%0/3
A //= B
A= $self->{"_package_name"}B= $package_name
ABresult
1X1
011
000
10225  
10226 # Check if the current package has a 'new' method
10227 0 ▶ my $has_new = $doc->find(sub {
Subroutine __ANON__: not called CC=2 SCAR=17.9
10228 0 ▶ $_[1]->isa('PPI::Statement::Sub') && $_[1]->name eq 'new'
Branch: 1 branch
BranchTrueFalseTotal
$_[1]->isa("PPI::Statement::Sub") and $_[1]->name eq "new" 0 0 0
10229 0 });
10230  
10231 0 ▶ if ($has_new) {
Branch: 1 branch
BranchTrueFalseTotal
if ($has_new) 0 0 0
10232 0 return $package_name;
10233 }
10234  
10235 # Otherwise, try to get the parent class
10236 0 my $parent = $self->_get_parent_class();
10237 0 ▶ return $parent if $parent;
Branch: 1 branch
BranchTrueFalseTotal
if $parent 0 0 0
10238  
10239 # Fallback to current package
10240 0 return $package_name;
10241 }
10242  
10243 # --------------------------------------------------
10244 # _extract_default_value
10245 #
10246 # Purpose: Extract a default value for a named
10247 # parameter from a method body by
10248 # matching multiple common Perl default
10249 # assignment idioms.
10250 #
10251 # Entry: $param - parameter name string.
10252 # $code - method body source string.
10253 #
10254 # Exit: Returns the cleaned default value
10255 # scalar on success, or undef if no
10256 # default assignment pattern is found.
10257 #
10258 # Side effects: None.
10259 #
10260 # Notes: Eight patterns are tried in order:
10261 # ||, //=, defined ternary, unless
10262 # defined, ||=, //, multi-line if
10263 # !defined, unless defined block.
10264 # Comment lines are stripped from the
10265 # code before matching to avoid false
10266 # positives. Delegates to
10267 # _clean_default_value for value
10268 # normalisation.
10269 # --------------------------------------------------
10270 533 ▶sub _extract_default_value {
Subroutine _extract_default_value: called CC=19 SCAR=29.5
10271 533 my ($self, $param, $code) = @_;
10272  
10273 533 ▶ return undef unless $param && $code;
Branch: 1 branch
BranchTrueFalseTotal
unless $param and $code 3 530 533
Condition100%3/3
$param and $code
!ll&&!rl&&r
12530
MC/DC100%2/2
$param and $code
$param $code
Truth table100%3/3
A and B
A= $paramB= $code
ABresult
0X0
100
111
10274  
10275 # Clean up the code for easier pattern matching
10276 # Remove comments to avoid false positives
10277 530 my $clean_code = $code;
10278 530 $clean_code =~ s/#.*$//gm;
10279 530 $clean_code =~ s/^\s+|\s+$//g;
10280  
10281 # Pattern 1: $param = $param || 'default_value'
10282 # Also handles: $param = $arg || 'default'
10283 530 ▶ if ($clean_code =~ /\$$param\s*=\s*(?:\$$param|\$[a-zA-Z_]\w*)\s*\|\|\s*([^;]+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ /\$$param\s*=\s*(?:\$$param|\$[a-zA-Z_]\w*)\s*\|\|\s*([^;]+)/) 12 518 530
10284 12 my $default = $1;
10285 12 $default =~ s/\s*;\s*$//;
10286 12 $default = $self->_clean_default_value($default);
10287 12 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 12 0 12
10288 }
10289  
10290 # Pattern 2: $param //= 'default_value'
10291 518 ▶ if ($clean_code =~ /\$$param\s*\/\/=\s*([^;]+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ m[\$$param\s*//=\s*([^;]+)]) 10 508 518
10292 10 my $default = $1;
10293 10 $default =~ s/\s*;\s*$//;
10294 10 $default = $self->_clean_default_value($default);
10295 10 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 6 4 10
10296 }
10297  
10298 # Pattern 3: $param = defined $param ? $param : 'default'
10299 # Also handles: $param = defined $arg ? $arg : 'default'
10300 512 ▶ if ($clean_code =~ /\$$param\s*=\s*defined\s+(?:\$$param|\$[a-zA-Z_]\w*)\s*\?\s*(?:\$$param|\$[a-zA-Z_]\w*)\s*:\s*([^;]+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ /\$$param\s*=\s*defined\s+(?:\$$param|\$[a-zA-Z_]\w*)\s*\?\s*(?:\$$param|\$[a-zA-Z_]\w*)\s*:\s*([^;]+)/) 6 506 512
10301 6 my $default = $1;
10302 6 $default =~ s/\s*;\s*$//;
10303 6 $default = $self->_clean_default_value($default);
10304 6 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 6 0 6
10305 }
10306  
10307 # Pattern 4: $param = 'default' unless defined $param;
10308 506 ▶ if ($clean_code =~ /\$$param\s*=\s*([^;]+?)\s+unless\s+defined\s+(?:\$$param|\$[a-zA-Z_]\w*)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ /\$$param\s*=\s*([^;]+?)\s+unless\s+defined\s+(?:\$$param|\$[a-zA-Z_]\w*)/) 3 503 506
10309 3 my $default = $1;
10310 3 $default = $self->_clean_default_value($default);
10311 3 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 3 0 3
10312 }
10313  
10314 # Pattern 5: $param ||= 'default'
10315 503 ▶ if ($clean_code =~ /\$$param\s*\|\|=\s*([^;]+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ /\$$param\s*\|\|=\s*([^;]+)/) 16 487 503
10316 16 my $default = $1;
10317 16 $default =~ s/\s*;\s*$//;
10318 16 $default = $self->_clean_default_value($default);
10319 16 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 16 0 16
10320 }
10321  
10322 # Pattern 6: $param = $arg // 'default'
10323 487 ▶ if ($clean_code =~ /\$$param\s*=\s*(?:\$$param|\$[a-zA-Z_]\w*)\s*\/\/\s*([^;]+)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ m[\$$param\s*=\s*(?:\$$param|\$[a-zA-Z_]\w*)\s*//\s*([^;]+)]) 2 485 487
10324 2 my $default = $1;
10325 2 $default =~ s/\s*;\s*$//;
10326 2 $default = $self->_clean_default_value($default);
10327 2 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 1 1 2
10328 }
10329  
10330 # Pattern 7: Multi-line: if (!defined $param) { $param = 'default'; }
10331 486 ▶ if ($clean_code =~ /if\s*\(\s*!defined\s+\$$param\s*\)\s*\{[^}]*\$$param\s*=\s*([^;]+)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ /if\s*\(\s*!defined\s+\$$param\s*\)\s*\{[^}]*\$$param\s*=\s*([^;]+)/s) 1 485 486
10332 1 my $default = $1;
10333 1 $default =~ s/\s*;\s*$//;
10334 1 $default = $self->_clean_default_value($default);
10335 1 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 1 0 1
10336 }
10337  
10338 # Pattern 8: unless (defined $param) { $param = 'default'; }
10339 485 ▶ if ($clean_code =~ /unless\s*\(\s*defined\s+\$$param\s*\)\s*\{[^}]*\$$param\s*=\s*([^;]+)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($clean_code =~ /unless\s*\(\s*defined\s+\$$param\s*\)\s*\{[^}]*\$$param\s*=\s*([^;]+)/s) 1 484 485
10340 1 my $default = $1;
10341 1 $default =~ s/\s*;\s*$//;
10342 1 $default = $self->_clean_default_value($default);
10343 1 ▶ return $default if defined $default;
Branch: 1 branch
BranchTrueFalseTotal
if defined $default 1 0 1
10344 }
10345  
10346 484 return undef;
10347 }
10348  
10349 # --------------------------------------------------
10350 # _extract_test_hints
10351 #
10352 # Purpose: Extract structured test hints from
10353 # a method's code and schema, including
10354 # boundary values, invalid inputs, and
10355 # valid input examples from POD.
10356 #
10357 # Entry: $method - method hashref.
10358 # $schema - schema hashref as built so
10359 # far by _analyze_method.
10360 #
10361 # Exit: Returns a hints hashref with keys:
10362 # boundary_values, invalid_inputs,
10363 # equivalence_classes, valid_inputs.
10364 # Keys with empty arrays are deleted
10365 # before returning.
10366 #
10367 # Side effects: None.
10368 # --------------------------------------------------
10369 764 ▶sub _extract_test_hints {
Subroutine _extract_test_hints: called CC=4 SCAR=13.9
10370 764 my ($self, $method, $schema) = @_;
10371  
10372 764 my %hints = (
10373 boundary_values => [],
10374 invalid_inputs => [],
10375 equivalence_classes => [],
10376 valid_inputs => [],
10377 );
10378  
10379 764 my $code = $method->{body};
10380 764 ▶ return {} unless $code;
Branch: 1 branch
BranchTrueFalseTotal
unless $code 0 764 764
10381  
10382 764 $self->_extract_invalid_input_hints($code, \%hints);
10383 764 $self->_extract_boundary_value_hints($code, \%hints);
10384  
10385 # prune empties
10386 764 for my $k (keys %hints) {
10387 3056 ▶ delete $hints{$k} unless @{$hints{$k}};
Branch: 1 branch
BranchTrueFalseTotal
unless @{$hints{$k};} 2929 127 3056
10388 }
10389  
10390 764 return \%hints;
10391 }
10392  
10393 # --------------------------------------------------
10394 # _extract_invalid_input_hints
10395 #
10396 # Purpose: Detect likely invalid input values
10397 # from a method body by looking for
10398 # defined checks, empty string checks,
10399 # and negative number checks.
10400 #
10401 # Entry: $code - method body source string.
10402 # $hints - hints hashref (modified in
10403 # place via invalid_inputs key).
10404 #
10405 # Exit: Returns nothing. Appends to
10406 # $hints->{invalid_inputs}.
10407 #
10408 # Side effects: None.
10409 # --------------------------------------------------
10410 768 ▶sub _extract_invalid_input_hints {
Subroutine _extract_invalid_input_hints: called CC=5 SCAR=16.1
10411 768 my ($self, $code, $hints) = @_;
10412  
10413 # undef invalid
10414 768 ▶ if ($code =~ /defined\s*\(\s*\$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /defined\s*\(\s*\$/) 63 705 768
10415 63 push @{ $hints->{invalid_inputs} }, 'undef';
10416 }
10417  
10418 # empty string invalid
10419 768 ▶ if ($code =~ /\beq\s*''/ || $code =~ /\blength\s*\(/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\beq\s*''/ or $code =~ /\blength\s*\(/) 41 727 768
Condition100%3/3
$code =~ /\beq\s*''/ or $code =~ /\blength\s*\(/
l!l&&r!l&&!r
437727
MC/DC100%2/2
$code =~ /\beq\s*''/ or $code =~ /\blength\s*\(/
$code =~ /\beq\s*''/ $code =~ /\blength\s*\(/
Truth table100%3/3
A or B
A= $code =~ /\beq\s*''/B= $code =~ /\blength\s*\(/
ABresult
1X1
011
000
10420 41 push @{ $hints->{invalid_inputs} }, '';
10421 }
10422  
10423 # negative number invalid
10424 768 ▶ if ($code =~ /\$\w+\s*<\s*0/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*<\s*0/) 10 758 768
10425 10 push @{ $hints->{invalid_inputs} }, -1;
10426 }
10427 }
10428  
10429 # --------------------------------------------------
10430 # _extract_boundary_value_hints
10431 #
10432 # Purpose: Extract numeric boundary values from
10433 # comparison operators in a method body,
10434 # adding both the boundary value and
10435 # the value one step either side.
10436 #
10437 # Entry: $code - method body source string.
10438 # $hints - hints hashref (modified in
10439 # place via boundary_values key).
10440 #
10441 # Exit: Returns nothing. Appends to and
10442 # deduplicates $hints->{boundary_values}.
10443 #
10444 # Side effects: None.
10445 # --------------------------------------------------
10446 767 ▶sub _extract_boundary_value_hints {
Subroutine _extract_boundary_value_hints: called CC=6 SCAR=17.9
10447 767 my ($self, $code, $hints) = @_;
10448  
10449 767 ▶ while ($code =~ /\$\w+\s*(<=|<|>=|>)\s*(\d+)/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($code =~ /\$\w+\s*(<=|<|>=|>)\s*(\d+)/g) 49 767 816
10450 49 my ($op, $n) = ($1, $2);
10451  
10452 49 ▶ if ($op eq '<') {
Branch: 4 branches
BranchTrueFalseTotal
if ($op eq '<') { } 15 34 49
elsif ($op eq '<=') { } 3 31 34
elsif ($op eq '>') { } 28 3 31
elsif ($op eq '>=') { } 3 0 3
10453 15 push @{ $hints->{boundary_values} }, $n, $n+1;
10454 } elsif ($op eq '<=') {
10455 3 push @{ $hints->{boundary_values} }, $n, $n+1;
10456 } elsif ($op eq '>') {
10457 28 push @{ $hints->{boundary_values} }, $n, $n-1;
10458 } elsif ($op eq '>=') {
10459 3 push @{ $hints->{boundary_values} }, $n, $n-1;
10460 }
10461 }
10462  
10463 # Remove duplicates
10464 767 my %seen;
10465 767 $hints->{boundary_values} = [ grep { !$seen{$_}++ } @{ $hints->{boundary_values} } ];
10466 }
10467  
10468 # --------------------------------------------------
10469 # _extract_pod_examples
10470 #
10471 # Purpose: Extract example method call patterns from a method's
10472 # SYNOPSIS section (=head1 or =head2) and from any
10473 # =for example begin/end blocks, and add them as
10474 # valid_inputs hints for fuzzing.
10475 #
10476 # Entry: $pod - POD string for the method. May be undef.
10477 # $hints - hints hashref (modified in place via the
10478 # valid_inputs key).
10479 #
10480 # Exit: Returns $hints. Appends to $hints->{valid_inputs}.
10481 #
10482 # Side effects: Logs the number of examples found to stdout when
10483 # verbose is set.
10484 #
10485 # Notes: For standalone runnable round-trip tests (not just
10486 # fuzzing hints) use App::Test::Generator::PodExampleExtractor
10487 # and bin/pod-example-tester instead.
10488 # --------------------------------------------------
10489 764 ▶sub _extract_pod_examples {
Subroutine _extract_pod_examples: called CC=17 SCAR=28.5
10490 764 my ($self, $pod, $hints) = @_;
10491  
10492 764 ▶ return $hints unless $pod;
Branch: 1 branch
BranchTrueFalseTotal
unless $pod 252 512 764
10493  
10494 512 my @examples;
10495  
10496 # Accept both =head1 SYNOPSIS (module-level) and =head2 SYNOPSIS (method-level)
10497 512 my $synopsis = '';
10498 512 ▶ if($pod =~ /=head[12]\s+SYNOPSIS\s*(.+?)(?=\n=head|\z)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /=head[12]\s+SYNOPSIS\s*(.+?)(?=\n=head|\z)/s) 3 509 512
10499 3 $synopsis = $1;
10500 }
10501  
10502 # Also collect =for example begin ... =for example end blocks
10503 512 my @for_blocks;
10504 512 ▶ while($pod =~ /=for\s+example\s+begin(.+?)=for\s+example\s+end/sg) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod =~ /=for\s+example\s+begin(.+?)=for\s+example\s+end/gs) 0 512 512
10505 0 push @for_blocks, $1;
10506 }
10507 512 $synopsis .= join('', @for_blocks);
10508  
10509 512 ▶ return $hints unless length($synopsis);
Branch: 1 branch
BranchTrueFalseTotal
unless length $synopsis 509 3 512
10510  
10511 # Constructor examples: ->wilma(foo => 'bar', count => 5)
10512 3 ▶ while ($synopsis =~ /->([a-z_0-9A-Z]+)\s*\(\s*(.*?)\s*\)/sg) {
Branch: 1 branch
BranchTrueFalseTotal
if ($synopsis =~ /->([a-z_0-9A-Z]+)\s*\(\s*(.*?)\s*\)/gs) 3 3 6
10513 3 my ($method, $args) = ($1, $2);
10514 3 my %kv;
10515  
10516 3 ▶ while ($args =~ /(\w+)\s*=>\s*(?:'([^']*)'|"([^"]*)"|(\d+))/g) {
Branch: 1 branch
BranchTrueFalseTotal
if ($args =~ /(\w+)\s*=>\s*(?:'([^']*)'|"([^"]*)"|(\d+))/g) 5 3 8
10517 5 my $key = $1;
10518 5 ▶ my $val = defined $2 ? $2 : defined $3 ? $3 : $4;
Branch: 2 branches
BranchTrueFalseTotal
defined $2 ? : 2 3 5
defined $3 ? : 0 3 3
10519 5 $kv{$key} = $val;
10520 }
10521  
10522 3 ▶ push @examples, {
Branch: 1 branch
BranchTrueFalseTotal
if %kv 2 1 3
10523 style => 'named',
10524 source => 'pod',
10525 args => \%kv,
10526 function => $method, # TODO: add a sanity check this is what we expect
10527 } if %kv;
10528 }
10529  
10530 3 ▶ unless(scalar(@examples)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (scalar @examples) 1 2 3
10531 # Positional calls: func($a, $b)
10532 1 ▶ while ($synopsis =~ /\b(\w+)\s*\(\s*(.*?)\s*\)/sg) {
Branch: 1 branch
BranchTrueFalseTotal
if ($synopsis =~ /\b(\w+)\s*\(\s*(.*?)\s*\)/gs) 1 1 2
10533 1 my ($func, $argstr) = ($1, $2);
10534  
10535 # next if $func eq 'new'; # already handled
10536  
10537 1 my @args = map { s/^\s+|\s+$//gr } split /\s*,\s*/, $argstr;
10538  
10539 1 ▶ next unless @args;
Branch: 1 branch
BranchTrueFalseTotal
unless @args 0 1 1
10540  
10541 1 push @examples, {
10542 style => 'positional',
10543 source => 'pod',
10544 function => $func,
10545 args => \@args,
10546 };
10547 }
10548 }
10549  
10550 3 ▶ if (scalar(@examples)) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @examples) 3 0 3
10551 3 ▶ $hints->{valid_inputs} ||= [];
Condition50%1/2
$hints->{"valid_inputs"} ||= []
l!l
03
MC/DC0%0/1
$hints->{"valid_inputs"} ||= []
$hints->{"valid_inputs"}
Truth table50%1/2
A
A= $hints->{"valid_inputs"}
Aresult
11
00
10552 3 push @{ $hints->{valid_inputs} }, @examples;
10553  
10554 3 $self->_log(" POD: extracted " . scalar(@examples) . " example call(s)");
10555 }
10556  
10557 3 for my $k (qw(boundary_values invalid_inputs valid_inputs equivalence_classes)) {
10558 12 ▶ $hints->{$k} //= [];
Condition100%2/2
$hints->{$k} //= []
l!l
39
MC/DC100%1/1
$hints->{$k} //= []
$hints->{$k}
Truth table100%2/2
A
A= $hints->{$k}
Aresult
11
00
10559 }
10560  
10561 3 return $hints;
10562 }
10563  
10564 # --------------------------------------------------
10565 # _clean_default_value
10566 #
10567 # Purpose: Normalise a raw default value string
10568 # extracted from code or POD into a
10569 # clean Perl scalar, handling quoted
10570 # strings, numeric literals, boolean
10571 # keywords, empty containers, and
10572 # undef.
10573 #
10574 # Entry: $value - raw value string.
10575 # May be undef.
10576 # $from_code - true if the value was
10577 # extracted from source
10578 # code (affects escape
10579 # sequence handling).
10580 #
10581 # Exit: Returns the cleaned value:
10582 # undef for undef or unparseable
10583 # {} for empty hashrefs
10584 # [] for empty arrayrefs
10585 # integer for whole numbers
10586 # float for decimal numbers
10587 # 1 or 0 for boolean keywords
10588 # string for everything else
10589 #
10590 # Side effects: None.
10591 # --------------------------------------------------
10592 252 ▶sub _clean_default_value {
Subroutine _clean_default_value: called CC=23 SCAR=31.5
10593 252 my ($self, $value, $from_code) = @_;
10594  
10595 252 ▶ return unless defined $value;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $value 1 251 252
10596  
10597 # Remove leading/trailing whitespace
10598 251 $value =~ s/^\s+|\s+$//g;
10599  
10600 # Remove parenthetical notes like "(no password)" only if there's content before them
10601 251 $value =~ s/(\S+)\s*\([^)]+\)\s*$/$1/;
10602 251 $value =~ s/^\s+|\s+$//g;
10603  
10604 # Handle chained || or // operators - extract the rightmost value
10605 251 ▶ if ($value =~ /\|\||\/{2}/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ m[\|\||/{2}]) 6 245 251
10606 6 my @parts = split(/\s*(?:\|\||\/{2})\s*/, $value);
10607 6 $value = $parts[-1];
10608 6 $value =~ s/^\s+|\s+$//g;
10609 }
10610  
10611 # Remove trailing semicolon if present
10612 251 $value =~ s/;\s*$//;
10613  
10614 # Handle q{}, qq{}, qw{} quotes
10615 251 ▶ if ($value =~ /^qq?\{(.*?)\}$/s) {
Branch: 3 branches
BranchTrueFalseTotal
if ($value =~ /^qq?\{(.*?)\}$/s) { } 2 249 251
elsif ($value =~ /^qw\{(.*?)\}$/s) { } 0 249 249
elsif ($value =~ /^q[qwx]?\s*([^a-zA-Z0-9\{\[])(.*?)\1$/s) { } 0 249 249
10616 2 $value = $1;
10617 } elsif ($value =~ /^qw\{(.*?)\}$/s) {
10618 0 $value = $1;
10619 } elsif ($value =~ /^q[qwx]?\s*([^a-zA-Z0-9\{\[])(.*?)\1$/s) {
10620 0 $value = $2;
10621 }
10622  
10623 # Handle quoted strings
10624 251 ▶ if ($value =~ /^(['"])(.*)\1$/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /^(['"])(.*)\1$/s) 52 199 251
10625 52 $value = $2;
10626  
10627 52 ▶ if ($from_code) {
Branch: 1 branch
BranchTrueFalseTotal
if ($from_code) 16 36 52
10628 # In regex captures from source code, escape sequences are doubled
10629 # \\n in capture needs to become \n for the test
10630 16 $value =~ s/\\\\/\\/g;
10631 }
10632  
10633 # Only unescape the quote characters themselves
10634 52 $value =~ s/\\"/"/g;
10635 52 $value =~ s/\\'/'/g;
10636  
10637 # If NOT from code (i.e., from POD), interpret escape sequences
10638 52 ▶ unless ($from_code) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($from_code) 36 16 52
10639 36 $value =~ s/\\n/\n/g;
10640 36 $value =~ s/\\r/\r/g;
10641 36 $value =~ s/\\t/\t/g;
10642 36 $value =~ s/\\\\/\\/g;
10643 }
10644 }
10645  
10646 # Sometimes trailing ) is left on
10647 251 ▶ if($value !~ /^\(/) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($value =~ /^\(/) 249 2 251
10648 249 $value =~ s/\)$//;
10649 }
10650  
10651 # Handle Perl empty hash (must be before numeric/boolean checks)
10652 251 ▶ if ($value =~ /^\{\s*\}$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /^\{\s*\}$/) 13 238 251
10653 13 return {};
10654 }
10655  
10656 # Handle Perl empty list/array
10657 238 ▶ if ($value =~ /^\[\s*\]$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /^\[\s*\]$/) 7 231 238
10658 7 return [];
10659 }
10660  
10661 # Handle numeric values
10662 231 ▶ if ($value =~ /^-?\d+(?:\.\d+)?$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /^-?\d+(?:\.\d+)?$/) 66 165 231
10663 66 ▶ if ($value =~ /\./) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /\./) { } 13 53 66
10664 13 return $value + 0;
10665 } else {
10666 53 return int($value);
10667 }
10668 }
10669  
10670 # Handle boolean keywords
10671 165 ▶ if ($value =~ /^(true|false)$/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /^(true|false)$/i) 7 158 165
10672 7 ▶ return lc($1) eq 'true' ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
lc $1 eq 'true' ? : 3 4 7
10673 }
10674  
10675 # Handle Perl boolean constants
10676 158 ▶ if ($value eq '1') {
Branch: 2 branches
BranchTrueFalseTotal
if ($value eq '1') { } 0 158 158
elsif ($value eq '0') { } 0 158 158
10677 0 return 1;
10678 } elsif ($value eq '0') {
10679 0 return 0;
10680 }
10681  
10682 # Handle undef
10683 158 ▶ if ($value eq 'undef') {
Branch: 1 branch
BranchTrueFalseTotal
if ($value eq "undef") 7 151 158
10684 7 return undef;
10685 }
10686  
10687 # Handle __PACKAGE__ and similar constants
10688 151 ▶ if ($value eq '__PACKAGE__') {
Branch: 1 branch
BranchTrueFalseTotal
if ($value eq "__PACKAGE__") 1 150 151
10689 1 return '__PACKAGE__';
10690 }
10691  
10692 # Remove surrounding parentheses
10693 150 $value =~ s/^\((.+)\)$/$1/;
10694  
10695 # Handle expressions we can't evaluate
10696 150 ▶ if ($value =~ /^\$[a-zA-Z_]/ || $value =~ /\(.*\)/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /^\$[a-zA-Z_]/ or $value =~ /\(.*\)/) 46 104 150
Condition100%3/3
$value =~ /^\$[a-zA-Z_]/ or $value =~ /\(.*\)/
l!l&&r!l&&!r
406104
MC/DC100%2/2
$value =~ /^\$[a-zA-Z_]/ or $value =~ /\(.*\)/
$value =~ /^\$[a-zA-Z_]/ $value =~ /\(.*\)/
Truth table100%3/3
A or B
A= $value =~ /^\$[a-zA-Z_]/B= $value =~ /\(.*\)/
ABresult
1X1
011
000
10697 46 ▶ return if($value =~ /^\$|\@|\%/); # The default is a value, so who knows its type?
Branch: 1 branch
BranchTrueFalseTotal
if $value =~ /^\$|\@|\%/ 40 6 46
10698 # return $value;
10699 }
10700  
10701 110 return $value;
10702 }
10703  
10704 # --------------------------------------------------
10705 # _validate_pod_code_agreement
10706 #
10707 # Purpose: Compare POD parameter documentation
10708 # against code-inferred parameters and
10709 # return a list of disagreements when
10710 # strict_pod mode is enabled.
10711 #
10712 # Entry: $pod_params - hashref of parameters
10713 # from POD analysis.
10714 # $code_params - hashref of parameters
10715 # from code analysis.
10716 # $method_name - method name string,
10717 # used for context in
10718 # error messages.
10719 #
10720 # Exit: Returns a list of disagreement
10721 # strings. Returns an empty list if
10722 # all parameters agree.
10723 #
10724 # Side effects: None.
10725 #
10726 # Notes: Type mismatches are classified as
10727 # either 'compatible' (e.g. integer vs
10728 # number) or 'incompatible' via
10729 # _types_are_compatible. $self and
10730 # $class are excluded from undocumented
10731 # parameter warnings in appropriate
10732 # context.
10733 # --------------------------------------------------
10734 379 ▶sub _validate_pod_code_agreement {
Subroutine _validate_pod_code_agreement: called CC=36 SCAR=36.3
10735 379 my ($self, $pod_params, $code_params, $method_name) = @_;
10736  
10737 379 my @errors;
10738  
10739 # Get all parameter names from both sources
10740 379 my %all_params = map { $_ => 1 } (keys %$pod_params, keys %$code_params);
10741  
10742 379 foreach my $param (sort keys %all_params) {
10743 411 ▶ my $pod = $pod_params->{$param} || {};
Condition100%2/2
$pod_params->{$param} || {}
l!l
39021
MC/DC100%1/1
$pod_params->{$param} || {}
$pod_params->{$param}
Truth table100%2/2
A
A= $pod_params->{$param}
Aresult
11
00
10744 411 ▶ my $code = $code_params->{$param} || {};
Condition100%2/2
$code_params->{$param} || {}
l!l
253158
MC/DC100%1/1
$code_params->{$param} || {}
$code_params->{$param}
Truth table100%2/2
A
A= $code_params->{$param}
Aresult
11
00
10745  
10746 # A =head3|4 Input formal spec is authoritative for the parameter's
10747 # existence, type, optionality and pattern: heuristic code analysis may
10748 # legitimately disagree. Its bounds are still checked below, because a
10749 # formal minimum and a code maximum that do not overlap leave the merged
10750 # schema with no valid value.
10751 411 ▶ unless(($pod->{_source} // '') eq SOURCE_INPUT_SPEC) {
Branch: 1 branch
BranchTrueFalseTotal
unless (($pod->{"_source"} // "") eq "input_spec") 69 342 411
Condition100%2/2
$pod->{"_source"} // ""
l!l
38526
MC/DC100%1/1
$pod->{"_source"} // ""
$pod->{"_source"}
Truth table100%2/2
A
A= $pod->{"_source"}
Aresult
11
00
10752 # Check if parameter exists in both
10753 69 ▶ if (exists $pod_params->{$param} && !exists $code_params->{$param}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $pod_params->{$param} and not exists $code_params->{$param}) 4 65 69
Condition100%3/3
exists $pod_params->{$param} and not exists $code_params->{$param}
!ll&&!rl&&r
21444
MC/DC100%2/2
exists $pod_params->{$param} and not exists $code_params->{$param}
exists $pod_params->{$param} not exists $code_params->{$param}
Truth table100%3/3
A and not(B)
A= exists $pod_params->{$param}B= not exists $code_params->{$param}
ABresult
0X0
100
111
10754 4 push @errors, "Parameter '\$$param' documented in POD but not found in code signature";
10755 4 next;
10756 }
10757  
10758 65 ▶ if(!exists $pod_params->{$param} && exists $code_params->{$param}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $pod_params->{$param} and exists $code_params->{$param}) 21 44 65
Condition66%2/3
not exists $pod_params->{$param} and exists $code_params->{$param}
!ll&&!rl&&r
44021
MC/DC50%1/2
not exists $pod_params->{$param} and exists $code_params->{$param}
not exists $pod_params->{$param} exists $code_params->{$param}
Truth table66%2/3
not(A) and B
A= not exists $pod_params->{$param}B= exists $code_params->{$param}
ABresult
0X0
100
111
10759 21 ▶ if($param =~ /^(class|pkg|proto|klass)$/i) {
Branch: 1 branch
BranchTrueFalseTotal
if ($param =~ /^(class|pkg|proto|klass)$/i) 0 21 21
10760 # class invocant, not a user-facing parameter
10761 0 next;
10762 }
10763 21 ▶ if($param eq 'self') {
Branch: 1 branch
BranchTrueFalseTotal
if ($param eq "self") 0 21 21
10764 # instance invocant, not a user-facing parameter
10765 0 next;
10766 }
10767 21 push @errors, "Parameter '\$$param' found in code but not documented in POD";
10768 21 next;
10769 }
10770  
10771 # Compare types if both exist
10772 44 ▶ if ($pod->{type} && $code->{type} && $pod->{type} ne $code->{type}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod->{"type"} and $code->{"type"} and $pod->{"type"} ne $code->{"type"}) 9 35 44
Condition100%6/6
$pod->{"type"} and $code->{"type"} and $pod->{"type"} ne $code->{"type"}
!ll&&!rl&&r
18179
$pod->{"type"} and $code->{"type"}
!ll&&!rl&&r
21626
MC/DC100%3/3
$pod->{"type"} and $code->{"type"} and $pod->{"type"} ne $code->{"type"}
$pod->{"type"} $code->{"type"} $pod->{"type"} ne $code->{"type"}
Truth table100%4/4
A and B and C
A= $pod->{"type"}B= $code->{"type"}C= $pod->{"type"} ne $code->{"type"}
ABCresult
0XX0
10X0
1100
1111
10773 9 ▶ if (!$self->_types_are_compatible($pod->{type}, $code->{type})) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $self->_types_are_compatible($pod->{'type'}, $code->{'type'})) { } 5 4 9
10774 5 push @errors, "Type mismatch for '\$$param': POD says '$pod->{type}', code suggests '$code->{type}' (incompatible)";
10775 } else {
10776 4 push @errors, "Type difference for '\$$param': POD says '$pod->{type}', code suggests '$code->{type}' (compatible)";
10777 }
10778 }
10779  
10780 # Compare optional status if both exist
10781 44 ▶ if (exists $pod->{optional} && exists $code->{optional} &&
Branch: 1 branch
BranchTrueFalseTotal
if (exists $pod->{"optional"} and exists $code->{"optional"} and $pod->{"optional"} != $code->{"optional"}) 3 41 44
Condition100%6/6
exists $pod->{"optional"} and exists $code->{"optional"} and $pod->{"optional"} != $code->{"optional"}
!ll&&!rl&&r
3293
exists $pod->{"optional"} and exists $code->{"optional"}
!ll&&!rl&&r
31112
MC/DC100%3/3
exists $pod->{"optional"} and exists $code->{"optional"} and $pod->{"optional"} != $code->{"optional"}
exists $pod->{"optional"} exists $code->{"optional"} $pod->{"optional"} != $code->{"optional"}
Truth table100%4/4
A and B and C
A= exists $pod->{"optional"}B= exists $code->{"optional"}C= $pod->{"optional"} != $code->{"optional"}
ABCresult
0XX0
10X0
1100
1111
10782 $pod->{optional} != $code->{optional}) {
10783 3 ▶ my $pod_status = $pod->{optional} ? 'optional' : 'required';
Branch: 1 branch
BranchTrueFalseTotal
$pod->{'optional'} ? : 1 2 3
10784 3 ▶ my $code_status = $code->{optional} ? 'optional' : 'required';
Branch: 1 branch
BranchTrueFalseTotal
$code->{'optional'} ? : 2 1 3
10785 3 push @errors, "Optional status mismatch for '\$$param': POD says '$pod_status', code suggests '$code_status'";
10786 }
10787  
10788 # Check regex patterns
10789 44 ▶ if ($pod->{matches} && $code->{matches} && $pod->{matches} ne $code->{matches}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pod->{"matches"} and $code->{"matches"} and $pod->{"matches"} ne $code->{"matches"}) 0 44 44
Condition50%3/6
$pod->{"matches"} and $code->{"matches"} and $pod->{"matches"} ne $code->{"matches"}
!ll&&!rl&&r
4400
$pod->{"matches"} and $code->{"matches"}
!ll&&!rl&&r
3950
MC/DC0%0/3
$pod->{"matches"} and $code->{"matches"} and $pod->{"matches"} ne $code->{"matches"}
$pod->{"matches"} $code->{"matches"} $pod->{"matches"} ne $code->{"matches"}
Truth table50%2/4
A and B and C
A= $pod->{"matches"}B= $code->{"matches"}C= $pod->{"matches"} ne $code->{"matches"}
ABCresult
0XX0
10X0
1100
1111
10790 0 push @errors, "Pattern mismatch for '\$$param': POD says '$pod->{matches}', code suggests '$code->{matches}'";
10791 }
10792 }
10793  
10794 # Check constraints (min/max), including a formal spec's bounds.
10795 386 ▶ if (defined $pod->{min} && defined $code->{min} && $pod->{min} != $code->{min}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $pod->{"min"} and defined $code->{"min"} and $pod->{"min"} != $code->{"min"}) 2 384 386
Condition100%6/6
defined $pod->{"min"} and defined $code->{"min"} and $pod->{"min"} != $code->{"min"}
!ll&&!rl&&r
37592
defined $pod->{"min"} and defined $code->{"min"}
!ll&&!rl&&r
3423311
MC/DC100%3/3
defined $pod->{"min"} and defined $code->{"min"} and $pod->{"min"} != $code->{"min"}
defined $pod->{"min"} defined $code->{"min"} $pod->{"min"} != $code->{"min"}
Truth table100%4/4
A and B and C
A= defined $pod->{"min"}B= defined $code->{"min"}C= $pod->{"min"} != $code->{"min"}
ABCresult
0XX0
10X0
1100
1111
10796 2 push @errors, "Min constraint mismatch for '\$$param': POD says '$pod->{min}', code suggests '$code->{min}'";
10797 }
10798  
10799 386 ▶ if (defined $pod->{max} && defined $code->{max} && $pod->{max} != $code->{max}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $pod->{"max"} and defined $code->{"max"} and $pod->{"max"} != $code->{"max"}) 1 385 386
Condition100%6/6
defined $pod->{"max"} and defined $code->{"max"} and $pod->{"max"} != $code->{"max"}
!ll&&!rl&&r
37691
defined $pod->{"max"} and defined $code->{"max"}
!ll&&!rl&&r
3581810
MC/DC100%3/3
defined $pod->{"max"} and defined $code->{"max"} and $pod->{"max"} != $code->{"max"}
defined $pod->{"max"} defined $code->{"max"} $pod->{"max"} != $code->{"max"}
Truth table100%4/4
A and B and C
A= defined $pod->{"max"}B= defined $code->{"max"}C= $pod->{"max"} != $code->{"max"}
ABCresult
0XX0
10X0
1100
1111
10800 1 push @errors, "Max constraint mismatch for '\$$param': POD says '$pod->{max}', code suggests '$code->{max}'";
10801 }
10802  
10803 386 ▶ if (defined $pod->{min} && defined $code->{max} && $pod->{min} > $code->{max}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $pod->{"min"} and defined $code->{"max"} and $pod->{"min"} > $code->{"max"}) 2 384 386
Condition100%6/6
defined $pod->{"min"} and defined $code->{"max"} and $pod->{"min"} > $code->{"max"}
!ll&&!rl&&r
37772
defined $pod->{"min"} and defined $code->{"max"}
!ll&&!rl&&r
342359
MC/DC100%3/3
defined $pod->{"min"} and defined $code->{"max"} and $pod->{"min"} > $code->{"max"}
defined $pod->{"min"} defined $code->{"max"} $pod->{"min"} > $code->{"max"}
Truth table100%4/4
A and B and C
A= defined $pod->{"min"}B= defined $code->{"max"}C= $pod->{"min"} > $code->{"max"}
ABCresult
0XX0
10X0
1100
1111
10804 2 push @errors, "Constraint contradiction for '\$$param': POD says min '$pod->{min}', code suggests max '$code->{max}' (no valid value)";
10805 }
10806  
10807 386 ▶ if (defined $code->{min} && defined $pod->{max} && $code->{min} > $pod->{max}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $code->{"min"} and defined $pod->{"max"} and $code->{"min"} > $pod->{"max"}) 0 386 386
Condition83%5/6
defined $code->{"min"} and defined $pod->{"max"} and $code->{"min"} > $pod->{"max"}
!ll&&!rl&&r
37880
defined $code->{"min"} and defined $pod->{"max"}
!ll&&!rl&&r
37358
MC/DC0%0/3
defined $code->{"min"} and defined $pod->{"max"} and $code->{"min"} > $pod->{"max"}
defined $code->{"min"} defined $pod->{"max"} $code->{"min"} > $pod->{"max"}
Truth table75%3/4
A and B and C
A= defined $code->{"min"}B= defined $pod->{"max"}C= $code->{"min"} > $pod->{"max"}
ABCresult
0XX0
10X0
1100
1111
10808 0 push @errors, "Constraint contradiction for '\$$param': code suggests min '$code->{min}', POD says max '$pod->{max}' (no valid value)";
10809 }
10810 }
10811  
10812 # Return errors (empty array if no errors)
10813 379 return @errors;
10814 }
10815  
10816 # --------------------------------------------------
10817 # _validate_strictness_level
10818 #
10819 # Purpose: Validate and normalise the strict_pod
10820 # option value accepted by new() into
10821 # an integer level: 0 (off), 1 (warn),
10822 # or 2 (fatal).
10823 #
10824 # Entry: $val - the raw value passed to
10825 # strict_pod in new(). May be
10826 # undef, a number, or a string.
10827 #
10828 # Exit: Returns 0, 1, or 2.
10829 # Croaks if the value is not recognised.
10830 #
10831 # Side effects: None.
10832 # --------------------------------------------------
10833 1150 ▶sub _validate_strictness_level {
Subroutine _validate_strictness_level: called CC=5 SCAR=16.1
10834 1150 my $val = $_[0];
10835  
10836 1150 ▶ return 0 unless defined $val;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $val 945 205 1150
10837  
10838 # Numeric
10839 205 ▶ return 0 if $val =~ /^(0|off|none)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $val =~ /^(0|off|none)$/i 10 195 205
10840 195 ▶ return 1 if $val =~ /^(1|warn|warning)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $val =~ /^(1|warn|warning)$/i 146 49 195
10841 49 ▶ return 2 if $val =~ /^(2|fatal|die|error)$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $val =~ /^(2|fatal|die|error)$/i 47 2 49
10842  
10843 2 croak("Invalid value for --strict-pod: '$val' (use off|warn|fatal)");
10844 }
10845  
10846 # --------------------------------------------------
10847 # _types_are_compatible
10848 #
10849 # Purpose: Determine whether two type strings
10850 # are compatible for POD/code agreement
10851 # checking, allowing semantically
10852 # equivalent types (e.g. 'integer' and
10853 # 'number') to coexist without
10854 # triggering a strict POD warning.
10855 #
10856 # Entry: $pod_type - type string from POD.
10857 # $code_type - type string from code.
10858 #
10859 # Exit: Returns 1 if compatible, 0 otherwise.
10860 #
10861 # Side effects: None.
10862 # --------------------------------------------------
10863 21 ▶sub _types_are_compatible {
Subroutine _types_are_compatible: called CC=4 SCAR=13.9
10864 21 my ($self, $pod_type, $code_type) = @_;
10865  
10866 # Exact match is always compatible
10867 21 ▶ return 1 if $pod_type eq $code_type;
Branch: 1 branch
BranchTrueFalseTotal
if $pod_type eq $code_type 3 18 21
10868  
10869 # Define compatibility matrix
10870 18 my %compatible_types = (
10871 'integer' => ['number', 'scalar'],
10872 'number' => ['scalar'],
10873 'string' => ['scalar'],
10874 'scalar' => ['string', 'integer', 'number'],
10875 'arrayref' => ['array'],
10876 'hashref' => ['hash'],
10877 );
10878  
10879 # Check if code_type is compatible with pod_type
10880 18 ▶ if (my $allowed = $compatible_types{$pod_type}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $allowed = $compatible_types{$pod_type}) 17 1 18
10881 17 return grep { $_ eq $code_type } @$allowed;
10882 }
10883  
10884 # Check if pod_type is compatible with code_type
10885 1 ▶ if (my $allowed = $compatible_types{$code_type}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $allowed = $compatible_types{$code_type}) 1 0 1
10886 1 return grep { $_ eq $pod_type } @$allowed;
10887 }
10888  
10889 0 return 0; # Not compatible
10890 }
10891  
10892 =head2 generate_pod_validation_report
10893  
10894 Generate a human-readable report of all POD/code disagreements found
10895 across a set of extracted schemas.
10896  
10897 my $schemas = $extractor->extract_all(no_write => 1);
10898 my $report = $extractor->generate_pod_validation_report($schemas);
10899 print $report;
10900  
10901 =head3 Arguments
10902  
10903 =over 4
10904  
10905 =item * C<$schemas>
10906  
10907 A hashref of method name to schema hashref as returned by
10908 C<extract_all>. Required.
10909  
10910 =back
10911  
10912 =head3 Returns
10913  
10914 A string containing the full validation report, or a single line
10915 confirming all methods passed if no disagreements were found.
10916  
10917 =head3 Side effects
10918  
10919 None.
10920  
10921 =head3 Notes
10922  
10923 Only methods whose schemas contain a C<_pod_validation_errors> key
10924 (populated when C<strict_pod> is 1 or 2) appear in the report. If
10925 C<strict_pod> was 0 when C<extract_all> was called, this method will
10926 always return the all-passed message.
10927  
10928 =head3 API specification
10929  
10930 =head4 input
10931  
10932 {
10933 self => { type => OBJECT, isa => 'App::Test::Generator::SchemaExtractor' },
10934 schemas => { type => HASHREF },
10935 }
10936  
10937 =head4 output
10938  
10939 { type => SCALAR }
10940  
10941 =cut
10942  
10943 17 ▶sub generate_pod_validation_report {
Subroutine generate_pod_validation_report: called CC=5 SCAR=16.1
Pod documented
10944 17 my ($self, $schemas) = @_;
10945  
10946 17 my @reports;
10947 17 foreach my $method_name (sort keys %$schemas) {
10948 26 my $schema = $schemas->{$method_name};
10949  
10950 26 ▶ if (my $errors = $schema->{_pod_validation_errors}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $errors = $schema->{"_pod_validation_errors"}) 16 10 26
10951 16 push @reports, "Method: $method_name";
10952 16 ▶ push @reports, " Severity: " . ($schema->{_pod_disagreement} ? 'warning' : 'fatal');
Branch: 1 branch
BranchTrueFalseTotal
$schema->{'_pod_disagreement'} ? : 13 3 16
10953 16 push @reports, " Errors:";
10954 16 push @reports, map { " - $_" } @$errors;
10955 16 push @reports, '';
10956 }
10957 }
10958  
10959 17 ▶ if (@reports) {
Branch: 1 branch
BranchTrueFalseTotal
if (@reports) { } 11 6 17
10960 11 return join("\n", "POD/Code Validation Report:", '=' x 40, '', @reports);
10961 } else {
10962 6 return 'POD/Code Validation: All methods passed consistency checks.';
10963 }
10964 }
10965  
10966 =head2 _log
10967  
10968 Log a message if verbose mode is on.
10969  
10970 =cut
10971  
10972 12949 ▶sub _log {
Subroutine _log: called CC=2 SCAR=6.9
10973 12949 my($self, $msg) = @_;
10974  
10975 12949 ▶ print "$msg\n" if $self->{verbose};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"verbose"} 38 12911 12949
10976 }
10977  
10978 =head1 NOTES
10979  
10980 C<SchemaExtractor> uses heuristic analysis of Perl source and POD to infer
10981 parameter types and constraints. Inference accuracy improves with
10982 well-documented modules; C<=head3 Input> / C<=head4 Input> formal specs are
10983 parsed at highest priority and override all heuristics.
10984  
10985 A lone name in a C<=head4 input> block is treated as the first positional
10986 argument when the body reads a positional argument (C<< $_[0] >>, a list
10987 assignment from C<@_>, or a C<shift>) and does not read an argument hash
10988 (C<my %args = @_>, a hashref dereference, or C<< $_[0]{...} >>); the
10989 documented name is then a label for that argument, as C<name> is for
10990 C<$_[0]> in L<Lingua::EN::NameCase/nc>. Two or more names, and a body that
10991 only forwards C<@_>, remain named arguments.
10992  
10993 The output is always a best-effort schema suitable as a starting template;
10994 review and augment the generated YAML before using it as a definitive
10995 specification. Pass it to L<App::Test::Generator> to generate fuzz harnesses.
10996  
10997 =head1 TODO
10998  
10999 Extend C<=head4 Input> parsing to cover the C<enum>/C<memberof> constraint
11000 synonym (union types, e.g. C<scalar | scalarref>, are already handled by
11001 C<_map_formal_input_type>).
11002  
11003 =head1 SEE ALSO
11004  
11005 =over 4
11006  
11007 =item * L<App::Test::Generator> - Generate fuzz and corpus-driven test harnesses
11008  
11009 Output from this module serves as input to that module.
11010 So with well-documented code, you can automatically create your tests.
11011  
11012 =item * L<App::Test::Generator::Template> - Template of the file of tests created by C<App::Test::Generator>
11013  
11014 =back
11015  
11016 =head1 AUTHOR
11017  
11018 Nigel Horne, C<< <njh at nigelhorne.com> >>
11019  
11020 =head1 LICENCE AND COPYRIGHT
11021  
11022 Copyright 2025-2026 Nigel Horne.
11023  
11024 Usage is subject to GPL2 licence terms.
11025 If you use it,
11026 please let me know.
11027  
11028 =cut
11029  
11030 157 1;
« bin/fuzz-harness-generator ↑ Summary lib/App/Test/Generator/TestStrategy.pm »