Initial Commit

database/perl/vendor/lib/Parse/Method/Signatures/Param.pm

@@ -0,0 +1,201 @@
+package Parse::Method::Signatures::Param;
+
+use Moose;
+use MooseX::Types::Structured qw/Tuple/;
+use MooseX::Types::Moose qw/Bool Str ArrayRef HashRef/;
+
+use namespace::clean -except => 'meta';
+
+with 'MooseX::Traits';
+
+has required => (
+    is       => 'ro',
+    isa      => Bool,
+    required => 1
+);
+
+has sigil => (
+    is       => 'ro',
+    isa      => Str,
+    required => 1,
+);
+
+has type_constraints => (
+    is         => 'ro',
+    isa        => 'Parse::Method::Signatures::TypeConstraint',
+    predicate  => 'has_type_constraints',
+    handles    => {
+        meta_type_constraint => 'tc'
+    },
+);
+
+has default_value => (
+    is        => 'ro',
+    isa       => Str,
+    predicate => 'has_default_value',
+);
+
+has constraints => (
+    is         => 'ro',
+    isa        => ArrayRef[Str],
+    predicate  => 'has_constraints',
+    auto_deref => 1,
+);
+
+has param_traits => (
+    is         => 'ro',
+    isa        => ArrayRef[Tuple[Str, Str]],
+    predicate  => 'has_traits',
+    auto_deref => 1
+);
+
+has '+_trait_namespace' => (
+    default => 'Parse::Method::Signatures::Param',
+);
+
+sub _stringify_type_constraints {
+    my ($self) = @_;
+    return $self->has_type_constraints
+        ? $self->type_constraints->to_string . q{ }
+        : q{};
+}
+
+sub _stringify_default_value {
+    my ($self) = @_;
+    return $self->has_default_value
+        ? q{ = } . $self->default_value
+        : q{};
+}
+
+sub _stringify_constraints {
+    my ($self) = @_;
+    return q{} unless $self->has_constraints;
+    return q{ where } . join(q{ where }, $self->constraints);
+}
+
+sub _stringify_traits {
+    my ($self) = @_;
+    return q{} unless $self->has_traits;
+    return q{ } . join q{ }, map { @{ $_ } } $self->param_traits;
+}
+
+sub to_string {
+    my ($self) = @_;
+    my $ret = q{};
+
+    $ret .= $self->_stringify_type_constraints;
+    $ret .= $self->_stringify_variable_name;
+    $ret .= $self->_stringify_required;
+    $ret .= $self->_stringify_default_value;
+    $ret .= $self->_stringify_constraints;
+    $ret .= $self->_stringify_traits;
+
+    return $ret;
+}
+
+__PACKAGE__->meta->make_immutable;
+
+1;
+
+=head1 NAME
+
+Parse::Method::Signatures::Param - a parsed parameter from a signature
+
+=head1 ATTRIBUTES
+
+All attributes of this class are read-only.
+
+=head2 required
+
+Is this parameter required (true) or optional (false)?
+
+=head2 sigil
+
+The effective sigil ('$', '@' or '%') of this parameter.
+
+=head2 type_constraints
+
+=over
+
+B<Type:> L<Parse::Method::Signatures::TypeConstraint>
+
+B<Predicate:> has_type_constraints
+
+=back
+
+Representation of the type constraint for this parameter. Most commonly you
+will just call L</meta_type_constraint> and not access this attribute directly.
+
+=head2 default_value
+
+=over
+
+B<Type:> Str
+
+B<Predicate:> has_default_value
+
+=back
+
+A string that should be eval'd or injected to get the default value for this
+parameter. For example:
+
+ $name = 'bar'
+
+Would give a default_value of "'bar'".
+
+=head2 constraints
+
+=over
+
+B<Type:> ArrayRef[Str]
+
+B<Predicate:> has_constraints
+
+=back
+
+C<where> constraints for this type. Each member of the array a the string
+(including enclosing braces) of the where constraint block.
+
+=head2 param_traits
+
+=over
+
+B<Type:> ArrayRef[ Tupple[Str,Str] ]
+
+B<Predicate:> has_traits
+
+=back
+
+Traits that this parameter is declared to have. For instance
+
+ $foo does coerce
+
+would have a trait of
+
+ ['does', 'coerce']
+
+=head1 METHODS
+
+=head2 to_string
+
+=head2 meta_type_constraint
+
+Get the L<Moose::Meta::TypeConstraint> for this parameter. Check first that the
+type has a type constraint:
+
+ $tc = $param->meta_type_constraint if $param->has_type_constraints;
+
+=head1 SEE ALSO
+
+L<Parse::Method::Signatures>.
+
+=head1 AUTHORS
+
+Ash Berlin <ash@cpan.org>.
+
+Florian Ragwitz <rafl@debian.org>.
+
+=head1 LICENSE
+
+Licensed under the same terms as Perl itself.
+