File Coverage

blib/lib/Parse/Method/Signatures/Param.pm
Criterion Covered Total %
statement 33 33 100.0
branch 8 8 100.0
condition n/a
subroutine 9 9 100.0
pod 1 1 100.0
total 51 51 100.0


line stmt bran cond sub pod time code
1             package Parse::Method::Signatures::Param;
2              
3 3     3   3149 use Moose;
  3         5  
  3         21  
4 3     3   14277 use MooseX::Types::Structured qw/Tuple/;
  3         584278  
  3         19  
5 3     3   651 use MooseX::Types::Moose qw/Bool Str ArrayRef HashRef/;
  3         8  
  3         28  
6              
7 3     3   10383 use namespace::clean -except => 'meta';
  3         4  
  3         22  
8              
9             with 'MooseX::Traits';
10              
11             has required => (
12             is => 'ro',
13             isa => Bool,
14             required => 1
15             );
16              
17             has sigil => (
18             is => 'ro',
19             isa => Str,
20             required => 1,
21             );
22              
23             has type_constraints => (
24             is => 'ro',
25             isa => 'Parse::Method::Signatures::TypeConstraint',
26             predicate => 'has_type_constraints',
27             handles => {
28             meta_type_constraint => 'tc'
29             },
30             );
31              
32             has default_value => (
33             is => 'ro',
34             isa => Str,
35             predicate => 'has_default_value',
36             );
37              
38             has constraints => (
39             is => 'ro',
40             isa => ArrayRef[Str],
41             predicate => 'has_constraints',
42             auto_deref => 1,
43             );
44              
45             has param_traits => (
46             is => 'ro',
47             isa => ArrayRef[Tuple[Str, Str]],
48             predicate => 'has_traits',
49             auto_deref => 1
50             );
51              
52             has '+_trait_namespace' => (
53             default => 'Parse::Method::Signatures::Param',
54             );
55              
56             sub _stringify_type_constraints {
57 157     157   229 my ($self) = @_;
58 157 100       5599 return $self->has_type_constraints
59             ? $self->type_constraints->to_string . q{ }
60             : q{};
61             }
62              
63             sub _stringify_default_value {
64 157     157   164 my ($self) = @_;
65 157 100       5065 return $self->has_default_value
66             ? q{ = } . $self->default_value
67             : q{};
68             }
69              
70             sub _stringify_constraints {
71 157     157   168 my ($self) = @_;
72 157 100       5104 return q{} unless $self->has_constraints;
73 7         199 return q{ where } . join(q{ where }, $self->constraints);
74             }
75              
76             sub _stringify_traits {
77 157     157   172 my ($self) = @_;
78 157 100       4830 return q{} unless $self->has_traits;
79 5         157 return q{ } . join q{ }, map { @{ $_ } } $self->param_traits;
  7         11  
  7         35  
80             }
81              
82             sub to_string {
83 157     157 1 187 my ($self) = @_;
84 157         183 my $ret = q{};
85              
86 157         808 $ret .= $self->_stringify_type_constraints;
87 157         792 $ret .= $self->_stringify_variable_name;
88 157         547 $ret .= $self->_stringify_required;
89 157         670 $ret .= $self->_stringify_default_value;
90 157         676 $ret .= $self->_stringify_constraints;
91 157         621 $ret .= $self->_stringify_traits;
92              
93 157         641 return $ret;
94             }
95              
96             __PACKAGE__->meta->make_immutable;
97              
98             1;
99              
100             =head1 NAME
101              
102             Parse::Method::Signatures::Param - a parsed parameter from a signature
103              
104             =head1 ATTRIBUTES
105              
106             All attributes of this class are read-only.
107              
108             =head2 required
109              
110             Is this parameter required (true) or optional (false)?
111              
112             =head2 sigil
113              
114             The effective sigil ('$', '@' or '%') of this parameter.
115              
116             =head2 type_constraints
117              
118             =over
119              
120             B<Type:> L<Parse::Method::Signatures::TypeConstraint>
121              
122             B<Predicate:> has_type_constraints
123              
124             =back
125              
126             Representation of the type constraint for this parameter. Most commonly you
127             will just call L</meta_type_constraint> and not access this attribute directly.
128              
129             =head2 default_value
130              
131             =over
132              
133             B<Type:> Str
134              
135             B<Predicate:> has_default_value
136              
137             =back
138              
139             A string that should be eval'd or injected to get the default value for this
140             parameter. For example:
141              
142             $name = 'bar'
143              
144             Would give a default_value of "'bar'".
145              
146             =head2 constraints
147              
148             =over
149              
150             B<Type:> ArrayRef[Str]
151              
152             B<Predicate:> has_constraints
153              
154             =back
155              
156             C<where> constraints for this type. Each member of the array a the string
157             (including enclosing braces) of the where constraint block.
158              
159             =head2 param_traits
160              
161             =over
162              
163             B<Type:> ArrayRef[ Tupple[Str,Str] ]
164              
165             B<Predicate:> has_traits
166              
167             =back
168              
169             Traits that this parameter is declared to have. For instance
170              
171             $foo does coerce
172              
173             would have a trait of
174              
175             ['does', 'coerce']
176              
177             =head1 METHODS
178              
179             =head2 to_string
180              
181             =head2 meta_type_constraint
182              
183             Get the L<Moose::Meta::TypeConstraint> for this parameter. Check first that the
184             type has a type constraint:
185              
186             $tc = $param->meta_type_constraint if $param->has_type_constraints;
187              
188             =head1 SEE ALSO
189              
190             L<Parse::Method::Signatures>.
191              
192             =head1 AUTHORS
193              
194             Ash Berlin <ash@cpan.org>.
195              
196             Florian Ragwitz <rafl@debian.org>.
197              
198             =head1 LICENSE
199              
200             Licensed under the same terms as Perl itself.
201