File Coverage

blib/lib/Dist/Zilla/Util/RoleDB/Entry.pm

Criterion	Covered	Total	%
statement	24	33	72.7
branch	1	2	50.0
condition			n/a
subroutine	8	11	72.7
pod	2	2	100.0
total	35	48	72.9

use 5.006;
use strict;
use warnings;

package Dist::Zilla::Util::RoleDB::Entry;

our $VERSION = '0.004000'; # TRIAL

# ABSTRACT: Extracted meta-data about a role

our $AUTHORITY = 'cpan:KENTNL'; # AUTHORITY

use Moo qw( has );
use Carp qw( croak );

## no critic (NamingConventions)
my $is_Str = sub { 'SCALAR' eq ref \$_[0] or 'SCALAR' eq ref \( my $val = $_[0] ) };
my $is_ArrayRef = sub {
  return 'ARRAY' eq ref $_[0] unless $_[1];
  return unless 'ARRAY' eq ref $_[0];
  for ( @{ $_[0] } ) {
    return unless $_[1]->($_);
  }
  1;
};
my $is_Bool = sub { not defined $_[0] or q() eq $_[0] or '0' eq $_[0] or '1' eq $_[0] };















has name => (
  isa => sub { $is_Str->( $_[0] ) or croak 'name must be a Str' },
  is            => ro =>,
  required      => 1,
  documentation => q[The unprefixed version of the role name, ie: -Foo => DZR::Foo],
);









has full_name => (
  isa => sub { $is_Str->( $_[0] ) or croak 'full_name must be a Str' },
  is            => ro =>,
  lazy          => 1,
  builder       => '_build_full_name',
  documentation => q[The fully qualified version of the role name],
);

sub _build_full_name {
  my ($self) = @_;
  my $role_name = $self->name;
  return $role_name unless $role_name =~ /\A-/msx;
  $role_name =~ s{\A-}{Dist::Zilla::Role::}msx;
  return $role_name;
}



































has required_modules => (
  isa => sub { $is_ArrayRef->( $_[0], $is_Str ) or croak 'required_modules must be an ArrayRef of Str' },
  is      => ro =>,
  lazy    => 1,
  builder => '_build_required_modules',
  ## no critic (ProhibitImplicitNewlines)
  documentation => <<'EOF', );
A list of things that must be manually require()d for the module to exist.
Note: This should not be needed for anything, as its really only intended
as a way to make hidden packages require()able.
Usually, this will be exactly one item, and it will be the same as the modules name.
EOF

sub _build_required_modules {
  my ($self) = @_;
  return [ $self->full_name ];
}







sub is_phase { return }









has description => (
  isa => sub { $is_Str->( $_[0] ) or croak 'description must be a Str' },
  is            => ro =>,
  required      => 1,
  documentation => q[A text description of the role. A copy of ABSTRACT would be fine],
);







has deprecated => (
  isa => sub { $is_Bool->( $_[0] ) or croak 'deprecated must be Boolean' },
  is            => ro =>,
  lazy          => 1,
  builder       => '_build_deprecated',
  documentation => q[Set this to 1 if this role is deprecated],
);

sub _build_deprecated { return }

no Moo;










sub require_module {
  my ($self) = @_;
  require Module::Runtime;
  for my $module ( @{ $self->required_modules } ) {
    Module::Runtime::require_module($module);
  }
  return $self->full_name;
}

1;

__END__