File Coverage

blib/lib/Function/Parameters/Info.pm
Criterion Covered Total %
statement 127 127 100.0
branch 48 90 53.3
condition 7 12 58.3
subroutine 21 21 100.0
pod 9 12 75.0
total 212 262 80.9


line stmt bran cond sub pod time code
1             package Function::Parameters::Info;
2              
3 4     4   54 use v5.14.0;
  4         14  
4 4     4   23 use warnings;
  4         8  
  4         108  
5              
6 4     4   25 use Function::Parameters;
  4         8  
  4         23  
7 4     4   25 use Carp ();
  4         8  
  4         414  
8              
9             our $VERSION = '2.002003';
10              
11             {
12             package Function::Parameters::Param;
13              
14             use overload
15 40 50   40   7968 fallback => 1,
16 4         33 '""' => method (@) { $self->{name} },
  40         68  
  40         46  
  40         815  
17 4     4   37 ;
  4         16  
18              
19 42 50 33 42   90 method new($class: :$name, :$type) {
  42 50       170  
  42 50       66  
  42 50       127  
  42 50       107  
  42         81  
  42         106  
  42         61  
20 42         241 bless { @_ }, $class
21             }
22              
23 8 50   8   923 method name() { $self->{name} }
  8 50       19  
  8         12  
  8         12  
  8         61  
24 8 50   8   24 method type() { $self->{type} }
  8 50       17  
  8         13  
  8         9  
  8         34  
25             }
26              
27             method new($class:
28             :$keyword,
29             :$nshift,
30             :$_positional_required,
31             :$_positional_optional,
32             :$_named_required,
33             :$_named_optional,
34             :$slurpy,
35 16 50 33 16 0 62 ) {
  16 50       63  
  16 50       32  
  16 50       63  
  16 50       41  
  16 50       36  
  16 50       38  
  16 50       31  
  16 50       37  
  16 50       32  
  16         45  
  16         38  
  16         22  
36 16         99 bless {@_}, $class
37             }
38              
39 11 50   11 0 92 method keyword() { $self->{keyword} }
  11 50       20  
  11         18  
  11         15  
  11         56  
40 55 50   55 0 122 method nshift () { $self->{nshift} }
  55 50       116  
  55         79  
  55         76  
  55         106  
41 21 50   21 1 52 method slurpy () { $self->{slurpy} }
  21 50       43  
  21         35  
  21         28  
  21         82  
42 22 50   22 1 63 method positional_optional() { @{$self->{_positional_optional}} }
  22 50       46  
  22         49  
  22         27  
  22         35  
  22         89  
43 38 50   38 1 101 method named_required () { @{$self->{_named_required}} }
  38 50       82  
  38         62  
  38         52  
  38         54  
  38         159  
44 22 50   22 1 63 method named_optional () { @{$self->{_named_optional}} }
  22 50       49  
  22         33  
  22         31  
  22         33  
  22         89  
45              
46 22 50   22 1 74 method positional_required() {
  22 50       50  
  22         38  
  22         29  
47 22         30 my @p = @{$self->{_positional_required}};
  22         59  
48 22         56 splice @p, 0, $self->nshift;
49             @p
50 22         113 }
51              
52 12 50   12 1 38 method args_min() {
  12 50       27  
  12         16  
  12         19  
53 12         30 my $r = 0;
54 12         20 $r += @{$self->{_positional_required}};
  12         24  
55 12         28 $r += $self->named_required * 2;
56 12         50 $r
57             }
58              
59 12 50   12 1 37 method args_max() {
  12 50       28  
  12         19  
  12         15  
60 12 100 100     26 return 0 + 'Inf' if defined $self->slurpy || $self->named_required || $self->named_optional;
      66        
61 4         8 my $r = 0;
62 4         6 $r += @{$self->{_positional_required}};
  4         7  
63 4         21 $r += $self->positional_optional;
64 4         16 $r
65             }
66              
67 12 50   12 1 231 method invocant() {
  12 50       28  
  12         21  
  12         16  
68 12         24 my $nshift = $self->nshift;
69             return undef
70 12 100       78 if $nshift == 0;
71 6 100       26 return $self->{_positional_required}[0]
72             if $nshift == 1;
73 3         322 Carp::croak "Can't return a single invocant; this function has $nshift";
74             }
75              
76 21 50   21 1 71 method invocants() {
  21 50       44  
  21         37  
  21         29  
77 21         32 my @p = @{$self->{_positional_required}};
  21         55  
78 21         77 splice @p, $self->nshift;
79             @p
80 21         90 }
81              
82             'ok'
83              
84             __END__