

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: Meta.pm</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>use 5.006;
use strict;
use warnings;
package CPAN::Meta;

our $VERSION = &#039;2.150010&#039;;

#pod =head1 SYNOPSIS
#pod
#pod     use v5.10;
#pod     use strict;
#pod     use warnings;
#pod     use CPAN::Meta;
#pod     use Module::Load;
#pod
#pod     my $meta = CPAN::Meta-&gt;load_file(&#039;META.json&#039;);
#pod
#pod     printf &quot;testing requirements for %s version %s\n&quot;,
#pod     $meta-&gt;name,
#pod     $meta-&gt;version;
#pod
#pod     my $prereqs = $meta-&gt;effective_prereqs;
#pod
#pod     for my $phase ( qw/configure runtime build test/ ) {
#pod         say &quot;Requirements for $phase:&quot;;
#pod         my $reqs = $prereqs-&gt;requirements_for($phase, &quot;requires&quot;);
#pod         for my $module ( sort $reqs-&gt;required_modules ) {
#pod             my $status;
#pod             if ( eval { load $module unless $module eq &#039;perl&#039;; 1 } ) {
#pod                 my $version = $module eq &#039;perl&#039; ? $] : $module-&gt;VERSION;
#pod                 $status = $reqs-&gt;accepts_module($module, $version)
#pod                         ? &quot;$version ok&quot; : &quot;$version not ok&quot;;
#pod             } else {
#pod                 $status = &quot;missing&quot;
#pod             };
#pod             say &quot;  $module ($status)&quot;;
#pod         }
#pod     }
#pod
#pod =head1 DESCRIPTION
#pod
#pod Software distributions released to the CPAN include a F&lt;META.json&gt; or, for
#pod older distributions, F&lt;META.yml&gt;, which describes the distribution, its
#pod contents, and the requirements for building and installing the distribution.
#pod The data structure stored in the F&lt;META.json&gt; file is described in
#pod L&lt;CPAN::Meta::Spec&gt;.
#pod
#pod CPAN::Meta provides a simple class to represent this distribution metadata (or
#pod I&lt;distmeta&gt;), along with some helpful methods for interrogating that data.
#pod
#pod The documentation below is only for the methods of the CPAN::Meta object.  For
#pod information on the meaning of individual fields, consult the spec.
#pod
#pod =cut

use Carp qw(carp croak);
use CPAN::Meta::Feature;
use CPAN::Meta::Prereqs;
use CPAN::Meta::Converter;
use CPAN::Meta::Validator;
use Parse::CPAN::Meta 1.4414 ();

BEGIN { *_dclone = \&amp;CPAN::Meta::Converter::_dclone }

#pod =head1 STRING DATA
#pod
#pod The following methods return a single value, which is the value for the
#pod corresponding entry in the distmeta structure.  Values should be either undef
#pod or strings.
#pod
#pod =for :list
#pod * abstract
#pod * description
#pod * dynamic_config
#pod * generated_by
#pod * name
#pod * release_status
#pod * version
#pod
#pod =cut

BEGIN {
  my @STRING_READERS = qw(
    abstract
    description
    dynamic_config
    generated_by
    name
    release_status
    version
  );

  no strict &#039;refs&#039;;
  for my $attr (@STRING_READERS) {
    *$attr = sub { $_[0]{ $attr } };
  }
}

#pod =head1 LIST DATA
#pod
#pod These methods return lists of string values, which might be represented in the
#pod distmeta structure as arrayrefs or scalars:
#pod
#pod =for :list
#pod * authors
#pod * keywords
#pod * licenses
#pod
#pod The C&lt;authors&gt; and C&lt;licenses&gt; methods may also be called as C&lt;author&gt; and
#pod C&lt;license&gt;, respectively, to match the field name in the distmeta structure.
#pod
#pod =cut

BEGIN {
  my @LIST_READERS = qw(
    author
    keywords
    license
  );

  no strict &#039;refs&#039;;
  for my $attr (@LIST_READERS) {
    *$attr = sub {
      my $value = $_[0]{ $attr };
      croak &quot;$attr must be called in list context&quot;
        unless wantarray;
      return @{ _dclone($value) } if ref $value;
      return $value;
    };
  }
}

sub authors  { $_[0]-&gt;author }
sub licenses { $_[0]-&gt;license }

#pod =head1 MAP DATA
#pod
#pod These readers return hashrefs of arbitrary unblessed data structures, each
#pod described more fully in the specification:
#pod
#pod =for :list
#pod * meta_spec
#pod * resources
#pod * provides
#pod * no_index
#pod * prereqs
#pod * optional_features
#pod
#pod =cut

BEGIN {
  my @MAP_READERS = qw(
    meta-spec
    resources
    provides
    no_index

    prereqs
    optional_features
  );

  no strict &#039;refs&#039;;
  for my $attr (@MAP_READERS) {
    (my $subname = $attr) =~ s/-/_/;
    *$subname = sub {
      my $value = $_[0]{ $attr };
      return _dclone($value) if $value;
      return {};
    };
  }
}

#pod =head1 CUSTOM DATA
#pod
#pod A list of custom keys are available from the C&lt;custom_keys&gt; method and
#pod particular keys may be retrieved with the C&lt;custom&gt; method.
#pod
#pod   say $meta-&gt;custom($_) for $meta-&gt;custom_keys;
#pod
#pod If a custom key refers to a data structure, a deep clone is returned.
#pod
#pod =cut

sub custom_keys {
  return grep { /^x_/i } keys %{$_[0]};
}

sub custom {
  my ($self, $attr) = @_;
  my $value = $self-&gt;{$attr};
  return _dclone($value) if ref $value;
  return $value;
}

#pod =method new
#pod
#pod   my $meta = CPAN::Meta-&gt;new($distmeta_struct, \%options);
#pod
#pod Returns a valid CPAN::Meta object or dies if the supplied metadata hash
#pod reference fails to validate.  Older-format metadata will be up-converted to
#pod version 2 if they validate against the original stated specification.
#pod
#pod It takes an optional hashref of options. Valid options include:
#pod
#pod =over
#pod
#pod =item *
#pod
#pod lazy_validation -- if true, new will attempt to convert the given metadata
#pod to version 2 before attempting to validate it.  This means than any
#pod fixable errors will be handled by CPAN::Meta::Converter before validation.
#pod (Note that this might result in invalid optional data being silently
#pod dropped.)  The default is false.
#pod
#pod =back
#pod
#pod =cut

sub _new {
  my ($class, $struct, $options) = @_;
  my $self;

  if ( $options-&gt;{lazy_validation} ) {
    # try to convert to a valid structure; if succeeds, then return it
    my $cmc = CPAN::Meta::Converter-&gt;new( $struct );
    $self = $cmc-&gt;convert( version =&gt; 2 ); # valid or dies
    return bless $self, $class;
  }
  else {
    # validate original struct
    my $cmv = CPAN::Meta::Validator-&gt;new( $struct );
    unless ( $cmv-&gt;is_valid) {
      die &quot;Invalid metadata structure. Errors: &quot;
        . join(&quot;, &quot;, $cmv-&gt;errors) . &quot;\n&quot;;
    }
  }

  # up-convert older spec versions
  my $version = $struct-&gt;{&#039;meta-spec&#039;}{version} || &#039;1.0&#039;;
  if ( $version == 2 ) {
    $self = $struct;
  }
  else {
    my $cmc = CPAN::Meta::Converter-&gt;new( $struct );
    $self = $cmc-&gt;convert( version =&gt; 2 );
  }

  return bless $self, $class;
}

sub new {
  my ($class, $struct, $options) = @_;
  my $self = eval { $class-&gt;_new($struct, $options) };
  croak($@) if $@;
  return $self;
}

#pod =method create
#pod
#pod   my $meta = CPAN::Meta-&gt;create($distmeta_struct, \%options);
#pod
#pod This is same as C&lt;new()&gt;, except that C&lt;generated_by&gt; and C&lt;meta-spec&gt; fields
#pod will be generated if not provided.  This means the metadata structure is
#pod assumed to otherwise follow the latest L&lt;CPAN::Meta::Spec&gt;.
#pod
#pod =cut

sub create {
  my ($class, $struct, $options) = @_;
  my $version = __PACKAGE__-&gt;VERSION || 2;
  $struct-&gt;{generated_by} ||= __PACKAGE__ . &quot; version $version&quot; ;
  $struct-&gt;{&#039;meta-spec&#039;}{version} ||= int($version);
  my $self = eval { $class-&gt;_new($struct, $options) };
  croak ($@) if $@;
  return $self;
}

#pod =method load_file
#pod
#pod   my $meta = CPAN::Meta-&gt;load_file($distmeta_file, \%options);
#pod
#pod Given a pathname to a file containing metadata, this deserializes the file
#pod according to its file suffix and constructs a new C&lt;CPAN::Meta&gt; object, just
#pod like C&lt;new()&gt;.  It will die if the deserialized version fails to validate
#pod against its stated specification version.
#pod
#pod It takes the same options as C&lt;new()&gt; but C&lt;lazy_validation&gt; defaults to
#pod true.
#pod
#pod =cut

sub load_file {
  my ($class, $file, $options) = @_;
  $options-&gt;{lazy_validation} = 1 unless exists $options-&gt;{lazy_validation};

  croak &quot;load_file() requires a valid, readable filename&quot;
    unless -r $file;

  my $self;
  eval {
    my $struct = Parse::CPAN::Meta-&gt;load_file( $file );
    $self = $class-&gt;_new($struct, $options);
  };
  croak($@) if $@;
  return $self;
}

#pod =method load_yaml_string
#pod
#pod   my $meta = CPAN::Meta-&gt;load_yaml_string($yaml, \%options);
#pod
#pod This method returns a new CPAN::Meta object using the first document in the
#pod given YAML string.  In other respects it is identical to C&lt;load_file()&gt;.
#pod
#pod =cut

sub load_yaml_string {
  my ($class, $yaml, $options) = @_;
  $options-&gt;{lazy_validation} = 1 unless exists $options-&gt;{lazy_validation};

  my $self;
  eval {
    my ($struct) = Parse::CPAN::Meta-&gt;load_yaml_string( $yaml );
    $self = $class-&gt;_new($struct, $options);
  };
  croak($@) if $@;
  return $self;
}

#pod =method load_json_string
#pod
#pod   my $meta = CPAN::Meta-&gt;load_json_string($json, \%options);
#pod
#pod This method returns a new CPAN::Meta object using the structure represented by
#pod the given JSON string.  In other respects it is identical to C&lt;load_file()&gt;.
#pod
#pod =cut

sub load_json_string {
  my ($class, $json, $options) = @_;
  $options-&gt;{lazy_validation} = 1 unless exists $options-&gt;{lazy_validation};

  my $self;
  eval {
    my $struct = Parse::CPAN::Meta-&gt;load_json_string( $json );
    $self = $class-&gt;_new($struct, $options);
  };
  croak($@) if $@;
  return $self;
}

#pod =method load_string
#pod
#pod   my $meta = CPAN::Meta-&gt;load_string($string, \%options);
#pod
#pod If you don&#039;t know if a string contains YAML or JSON, this method will use
#pod L&lt;Parse::CPAN::Meta&gt; to guess.  In other respects it is identical to
#pod C&lt;load_file()&gt;.
#pod
#pod =cut

sub load_string {
  my ($class, $string, $options) = @_;
  $options-&gt;{lazy_validation} = 1 unless exists $options-&gt;{lazy_validation};

  my $self;
  eval {
    my $struct = Parse::CPAN::Meta-&gt;load_string( $string );
    $self = $class-&gt;_new($struct, $options);
  };
  croak($@) if $@;
  return $self;
}

#pod =method save
#pod
#pod   $meta-&gt;save($distmeta_file, \%options);
#pod
#pod Serializes the object as JSON and writes it to the given file.  The only valid
#pod option is C&lt;version&gt;, which defaults to &#039;2&#039;. On Perl 5.8.1 or later, the file
#pod is saved with UTF-8 encoding.
#pod
#pod For C&lt;version&gt; 2 (or higher), the filename should end in &#039;.json&#039;.  L&lt;JSON::PP&gt;
#pod is the default JSON backend. Using another JSON backend requires L&lt;JSON&gt; 2.5 or
#pod later and you must set the C&lt;$ENV{PERL_JSON_BACKEND}&gt; to a supported alternate
#pod backend like L&lt;JSON::XS&gt;.
#pod
#pod For C&lt;version&gt; less than 2, the filename should end in &#039;.yml&#039;.
#pod L&lt;CPAN::Meta::Converter&gt; is used to generate an older metadata structure, which
#pod is serialized to YAML.  CPAN::Meta::YAML is the default YAML backend.  You may
#pod set the C&lt;$ENV{PERL_YAML_BACKEND}&gt; to a supported alternative backend, though
#pod this is not recommended due to subtle incompatibilities between YAML parsers on
#pod CPAN.
#pod
#pod =cut

sub save {
  my ($self, $file, $options) = @_;

  my $version = $options-&gt;{version} || &#039;2&#039;;
  my $layer = $] ge &#039;5.008001&#039; ? &#039;:utf8&#039; : &#039;&#039;;

  if ( $version ge &#039;2&#039; ) {
    carp &quot;&#039;$file&#039; should end in &#039;.json&#039;&quot;
      unless $file =~ m{\.json$};
  }
  else {
    carp &quot;&#039;$file&#039; should end in &#039;.yml&#039;&quot;
      unless $file =~ m{\.yml$};
  }

  my $data = $self-&gt;as_string( $options );
  open my $fh, &quot;&gt;$layer&quot;, $file
    or die &quot;Error opening &#039;$file&#039; for writing: $!\n&quot;;

  print {$fh} $data;
  close $fh
    or die &quot;Error closing &#039;$file&#039;: $!\n&quot;;

  return 1;
}

#pod =method meta_spec_version
#pod
#pod This method returns the version part of the C&lt;meta_spec&gt; entry in the distmeta
#pod structure.  It is equivalent to:
#pod
#pod   $meta-&gt;meta_spec-&gt;{version};
#pod
#pod =cut

sub meta_spec_version {
  my ($self) = @_;
  return $self-&gt;meta_spec-&gt;{version};
}

#pod =method effective_prereqs
#pod
#pod   my $prereqs = $meta-&gt;effective_prereqs;
#pod
#pod   my $prereqs = $meta-&gt;effective_prereqs( \@feature_identifiers );
#pod
#pod This method returns a L&lt;CPAN::Meta::Prereqs&gt; object describing all the
#pod prereqs for the distribution.  If an arrayref of feature identifiers is given,
#pod the prereqs for the identified features are merged together with the
#pod distribution&#039;s core prereqs before the CPAN::Meta::Prereqs object is returned.
#pod
#pod =cut

sub effective_prereqs {
  my ($self, $features) = @_;
  $features ||= [];

  my $prereq = CPAN::Meta::Prereqs-&gt;new($self-&gt;prereqs);

  return $prereq unless @$features;

  my @other = map {; $self-&gt;feature($_)-&gt;prereqs } @$features;

  return $prereq-&gt;with_merged_prereqs(\@other);
}

#pod =method should_index_file
#pod
#pod   ... if $meta-&gt;should_index_file( $filename );
#pod
#pod This method returns true if the given file should be indexed.  It decides this
#pod by checking the C&lt;file&gt; and C&lt;directory&gt; keys in the C&lt;no_index&gt; property of
#pod the distmeta structure. Note that neither the version format nor
#pod C&lt;release_status&gt; are considered.
#pod
#pod C&lt;$filename&gt; should be given in unix format.
#pod
#pod =cut

sub should_index_file {
  my ($self, $filename) = @_;

  for my $no_index_file (@{ $self-&gt;no_index-&gt;{file} || [] }) {
    return if $filename eq $no_index_file;
  }

  for my $no_index_dir (@{ $self-&gt;no_index-&gt;{directory} }) {
    $no_index_dir =~ s{$}{/} unless $no_index_dir =~ m{/\z};
    return if index($filename, $no_index_dir) == 0;
  }

  return 1;
}

#pod =method should_index_package
#pod
#pod   ... if $meta-&gt;should_index_package( $package );
#pod
#pod This method returns true if the given package should be indexed.  It decides
#pod this by checking the C&lt;package&gt; and C&lt;namespace&gt; keys in the C&lt;no_index&gt;
#pod property of the distmeta structure. Note that neither the version format nor
#pod C&lt;release_status&gt; are considered.
#pod
#pod =cut

sub should_index_package {
  my ($self, $package) = @_;

  for my $no_index_pkg (@{ $self-&gt;no_index-&gt;{package} || [] }) {
    return if $package eq $no_index_pkg;
  }

  for my $no_index_ns (@{ $self-&gt;no_index-&gt;{namespace} }) {
    return if index($package, &quot;${no_index_ns}::&quot;) == 0;
  }

  return 1;
}

#pod =method features
#pod
#pod   my @feature_objects = $meta-&gt;features;
#pod
#pod This method returns a list of L&lt;CPAN::Meta::Feature&gt; objects, one for each
#pod optional feature described by the distribution&#039;s metadata.
#pod
#pod =cut

sub features {
  my ($self) = @_;

  my $opt_f = $self-&gt;optional_features;
  my @features = map {; CPAN::Meta::Feature-&gt;new($_ =&gt; $opt_f-&gt;{ $_ }) }
                 keys %$opt_f;

  return @features;
}

#pod =method feature
#pod
#pod   my $feature_object = $meta-&gt;feature( $identifier );
#pod
#pod This method returns a L&lt;CPAN::Meta::Feature&gt; object for the optional feature
#pod with the given identifier.  If no feature with that identifier exists, an
#pod exception will be raised.
#pod
#pod =cut

sub feature {
  my ($self, $ident) = @_;

  croak &quot;no feature named $ident&quot;
    unless my $f = $self-&gt;optional_features-&gt;{ $ident };

  return CPAN::Meta::Feature-&gt;new($ident, $f);
}

#pod =method as_struct
#pod
#pod   my $copy = $meta-&gt;as_struct( \%options );
#pod
#pod This method returns a deep copy of the object&#039;s metadata as an unblessed hash
#pod reference.  It takes an optional hashref of options.  If the hashref contains
#pod a C&lt;version&gt; argument, the copied metadata will be converted to the version
#pod of the specification and returned.  For example:
#pod
#pod   my $old_spec = $meta-&gt;as_struct( {version =&gt; &quot;1.4&quot;} );
#pod
#pod =cut

sub as_struct {
  my ($self, $options) = @_;
  my $struct = _dclone($self);
  if ( $options-&gt;{version} ) {
    my $cmc = CPAN::Meta::Converter-&gt;new( $struct );
    $struct = $cmc-&gt;convert( version =&gt; $options-&gt;{version} );
  }
  return $struct;
}

#pod =method as_string
#pod
#pod   my $string = $meta-&gt;as_string( \%options );
#pod
#pod This method returns a serialized copy of the object&#039;s metadata as a character
#pod string.  (The strings are B&lt;not&gt; UTF-8 encoded.)  It takes an optional hashref
#pod of options.  If the hashref contains a C&lt;version&gt; argument, the copied metadata
#pod will be converted to the version of the specification and returned.  For
#pod example:
#pod
#pod   my $string = $meta-&gt;as_string( {version =&gt; &quot;1.4&quot;} );
#pod
#pod For C&lt;version&gt; greater than or equal to 2, the string will be serialized as
#pod JSON.  For C&lt;version&gt; less than 2, the string will be serialized as YAML.  In
#pod both cases, the same rules are followed as in the C&lt;save()&gt; method for choosing
#pod a serialization backend.
#pod
#pod The serialized structure will include a C&lt;x_serialization_backend&gt; entry giving
#pod the package and version used to serialize.  Any existing key in the given
#pod C&lt;$meta&gt; object will be clobbered.
#pod
#pod =cut

sub as_string {
  my ($self, $options) = @_;

  my $version = $options-&gt;{version} || &#039;2&#039;;

  my $struct;
  if ( $self-&gt;meta_spec_version ne $version ) {
    my $cmc = CPAN::Meta::Converter-&gt;new( $self-&gt;as_struct );
    $struct = $cmc-&gt;convert( version =&gt; $version );
  }
  else {
    $struct = $self-&gt;as_struct;
  }

  my ($data, $backend);
  if ( $version ge &#039;2&#039; ) {
    $backend = Parse::CPAN::Meta-&gt;json_backend();
    local $struct-&gt;{x_serialization_backend} = sprintf &#039;%s version %s&#039;,
      $backend, $backend-&gt;VERSION;
    $data = $backend-&gt;new-&gt;pretty-&gt;canonical-&gt;encode($struct);
  }
  else {
    $backend = Parse::CPAN::Meta-&gt;yaml_backend();
    local $struct-&gt;{x_serialization_backend} = sprintf &#039;%s version %s&#039;,
      $backend, $backend-&gt;VERSION;
    $data = eval { no strict &#039;refs&#039;; &amp;{&quot;$backend\::Dump&quot;}($struct) };
    if ( $@ ) {
      croak $backend-&gt;can(&#039;errstr&#039;) ? $backend-&gt;errstr : $@
    }
  }

  return $data;
}

# Used by JSON::PP, etc. for &quot;convert_blessed&quot;
sub TO_JSON {
  return { %{ $_[0] } };
}

1;

# ABSTRACT: the distribution metadata for a CPAN dist

=pod

=encoding UTF-8

=head1 NAME

CPAN::Meta - the distribution metadata for a CPAN dist

=head1 VERSION

version 2.150010

=head1 SYNOPSIS

    use v5.10;
    use strict;
    use warnings;
    use CPAN::Meta;
    use Module::Load;

    my $meta = CPAN::Meta-&gt;load_file(&#039;META.json&#039;);

    printf &quot;testing requirements for %s version %s\n&quot;,
    $meta-&gt;name,
    $meta-&gt;version;

    my $prereqs = $meta-&gt;effective_prereqs;

    for my $phase ( qw/configure runtime build test/ ) {
        say &quot;Requirements for $phase:&quot;;
        my $reqs = $prereqs-&gt;requirements_for($phase, &quot;requires&quot;);
        for my $module ( sort $reqs-&gt;required_modules ) {
            my $status;
            if ( eval { load $module unless $module eq &#039;perl&#039;; 1 } ) {
                my $version = $module eq &#039;perl&#039; ? $] : $module-&gt;VERSION;
                $status = $reqs-&gt;accepts_module($module, $version)
                        ? &quot;$version ok&quot; : &quot;$version not ok&quot;;
            } else {
                $status = &quot;missing&quot;
            };
            say &quot;  $module ($status)&quot;;
        }
    }

=head1 DESCRIPTION

Software distributions released to the CPAN include a F&lt;META.json&gt; or, for
older distributions, F&lt;META.yml&gt;, which describes the distribution, its
contents, and the requirements for building and installing the distribution.
The data structure stored in the F&lt;META.json&gt; file is described in
L&lt;CPAN::Meta::Spec&gt;.

CPAN::Meta provides a simple class to represent this distribution metadata (or
I&lt;distmeta&gt;), along with some helpful methods for interrogating that data.

The documentation below is only for the methods of the CPAN::Meta object.  For
information on the meaning of individual fields, consult the spec.

=head1 METHODS

=head2 new

  my $meta = CPAN::Meta-&gt;new($distmeta_struct, \%options);

Returns a valid CPAN::Meta object or dies if the supplied metadata hash
reference fails to validate.  Older-format metadata will be up-converted to
version 2 if they validate against the original stated specification.

It takes an optional hashref of options. Valid options include:

=over

=item *

lazy_validation -- if true, new will attempt to convert the given metadata
to version 2 before attempting to validate it.  This means than any
fixable errors will be handled by CPAN::Meta::Converter before validation.
(Note that this might result in invalid optional data being silently
dropped.)  The default is false.

=back

=head2 create

  my $meta = CPAN::Meta-&gt;create($distmeta_struct, \%options);

This is same as C&lt;new()&gt;, except that C&lt;generated_by&gt; and C&lt;meta-spec&gt; fields
will be generated if not provided.  This means the metadata structure is
assumed to otherwise follow the latest L&lt;CPAN::Meta::Spec&gt;.

=head2 load_file

  my $meta = CPAN::Meta-&gt;load_file($distmeta_file, \%options);

Given a pathname to a file containing metadata, this deserializes the file
according to its file suffix and constructs a new C&lt;CPAN::Meta&gt; object, just
like C&lt;new()&gt;.  It will die if the deserialized version fails to validate
against its stated specification version.

It takes the same options as C&lt;new()&gt; but C&lt;lazy_validation&gt; defaults to
true.

=head2 load_yaml_string

  my $meta = CPAN::Meta-&gt;load_yaml_string($yaml, \%options);

This method returns a new CPAN::Meta object using the first document in the
given YAML string.  In other respects it is identical to C&lt;load_file()&gt;.

=head2 load_json_string

  my $meta = CPAN::Meta-&gt;load_json_string($json, \%options);

This method returns a new CPAN::Meta object using the structure represented by
the given JSON string.  In other respects it is identical to C&lt;load_file()&gt;.

=head2 load_string

  my $meta = CPAN::Meta-&gt;load_string($string, \%options);

If you don&#039;t know if a string contains YAML or JSON, this method will use
L&lt;Parse::CPAN::Meta&gt; to guess.  In other respects it is identical to
C&lt;load_file()&gt;.

=head2 save

  $meta-&gt;save($distmeta_file, \%options);

Serializes the object as JSON and writes it to the given file.  The only valid
option is C&lt;version&gt;, which defaults to &#039;2&#039;. On Perl 5.8.1 or later, the file
is saved with UTF-8 encoding.

For C&lt;version&gt; 2 (or higher), the filename should end in &#039;.json&#039;.  L&lt;JSON::PP&gt;
is the default JSON backend. Using another JSON backend requires L&lt;JSON&gt; 2.5 or
later and you must set the C&lt;$ENV{PERL_JSON_BACKEND}&gt; to a supported alternate
backend like L&lt;JSON::XS&gt;.

For C&lt;version&gt; less than 2, the filename should end in &#039;.yml&#039;.
L&lt;CPAN::Meta::Converter&gt; is used to generate an older metadata structure, which
is serialized to YAML.  CPAN::Meta::YAML is the default YAML backend.  You may
set the C&lt;$ENV{PERL_YAML_BACKEND}&gt; to a supported alternative backend, though
this is not recommended due to subtle incompatibilities between YAML parsers on
CPAN.

=head2 meta_spec_version

This method returns the version part of the C&lt;meta_spec&gt; entry in the distmeta
structure.  It is equivalent to:

  $meta-&gt;meta_spec-&gt;{version};

=head2 effective_prereqs

  my $prereqs = $meta-&gt;effective_prereqs;

  my $prereqs = $meta-&gt;effective_prereqs( \@feature_identifiers );

This method returns a L&lt;CPAN::Meta::Prereqs&gt; object describing all the
prereqs for the distribution.  If an arrayref of feature identifiers is given,
the prereqs for the identified features are merged together with the
distribution&#039;s core prereqs before the CPAN::Meta::Prereqs object is returned.

=head2 should_index_file

  ... if $meta-&gt;should_index_file( $filename );

This method returns true if the given file should be indexed.  It decides this
by checking the C&lt;file&gt; and C&lt;directory&gt; keys in the C&lt;no_index&gt; property of
the distmeta structure. Note that neither the version format nor
C&lt;release_status&gt; are considered.

C&lt;$filename&gt; should be given in unix format.

=head2 should_index_package

  ... if $meta-&gt;should_index_package( $package );

This method returns true if the given package should be indexed.  It decides
this by checking the C&lt;package&gt; and C&lt;namespace&gt; keys in the C&lt;no_index&gt;
property of the distmeta structure. Note that neither the version format nor
C&lt;release_status&gt; are considered.

=head2 features

  my @feature_objects = $meta-&gt;features;

This method returns a list of L&lt;CPAN::Meta::Feature&gt; objects, one for each
optional feature described by the distribution&#039;s metadata.

=head2 feature

  my $feature_object = $meta-&gt;feature( $identifier );

This method returns a L&lt;CPAN::Meta::Feature&gt; object for the optional feature
with the given identifier.  If no feature with that identifier exists, an
exception will be raised.

=head2 as_struct

  my $copy = $meta-&gt;as_struct( \%options );

This method returns a deep copy of the object&#039;s metadata as an unblessed hash
reference.  It takes an optional hashref of options.  If the hashref contains
a C&lt;version&gt; argument, the copied metadata will be converted to the version
of the specification and returned.  For example:

  my $old_spec = $meta-&gt;as_struct( {version =&gt; &quot;1.4&quot;} );

=head2 as_string

  my $string = $meta-&gt;as_string( \%options );

This method returns a serialized copy of the object&#039;s metadata as a character
string.  (The strings are B&lt;not&gt; UTF-8 encoded.)  It takes an optional hashref
of options.  If the hashref contains a C&lt;version&gt; argument, the copied metadata
will be converted to the version of the specification and returned.  For
example:

  my $string = $meta-&gt;as_string( {version =&gt; &quot;1.4&quot;} );

For C&lt;version&gt; greater than or equal to 2, the string will be serialized as
JSON.  For C&lt;version&gt; less than 2, the string will be serialized as YAML.  In
both cases, the same rules are followed as in the C&lt;save()&gt; method for choosing
a serialization backend.

The serialized structure will include a C&lt;x_serialization_backend&gt; entry giving
the package and version used to serialize.  Any existing key in the given
C&lt;$meta&gt; object will be clobbered.

=head1 STRING DATA

The following methods return a single value, which is the value for the
corresponding entry in the distmeta structure.  Values should be either undef
or strings.

=over 4

=item *

abstract

=item *

description

=item *

dynamic_config

=item *

generated_by

=item *

name

=item *

release_status

=item *

version

=back

=head1 LIST DATA

These methods return lists of string values, which might be represented in the
distmeta structure as arrayrefs or scalars:

=over 4

=item *

authors

=item *

keywords

=item *

licenses

=back

The C&lt;authors&gt; and C&lt;licenses&gt; methods may also be called as C&lt;author&gt; and
C&lt;license&gt;, respectively, to match the field name in the distmeta structure.

=head1 MAP DATA

These readers return hashrefs of arbitrary unblessed data structures, each
described more fully in the specification:

=over 4

=item *

meta_spec

=item *

resources

=item *

provides

=item *

no_index

=item *

prereqs

=item *

optional_features

=back

=head1 CUSTOM DATA

A list of custom keys are available from the C&lt;custom_keys&gt; method and
particular keys may be retrieved with the C&lt;custom&gt; method.

  say $meta-&gt;custom($_) for $meta-&gt;custom_keys;

If a custom key refers to a data structure, a deep clone is returned.

=for Pod::Coverage TO_JSON abstract author authors custom custom_keys description dynamic_config
generated_by keywords license licenses meta_spec name no_index
optional_features prereqs provides release_status resources version

=head1 BUGS

Please report any bugs or feature using the CPAN Request Tracker.
Bugs can be submitted through the web interface at
L&lt;http://rt.cpan.org/Dist/Display.html?Queue=CPAN-Meta&gt;

When submitting a bug or request, please include a test-file or a patch to an
existing test-file that illustrates the bug or desired feature.

=head1 SEE ALSO

=over 4

=item *

L&lt;CPAN::Meta::Converter&gt;

=item *

L&lt;CPAN::Meta::Validator&gt;

=back

=for :stopwords cpan testmatrix url annocpan anno bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan

=head1 SUPPORT

=head2 Bugs / Feature Requests

Please report any bugs or feature requests through the issue tracker
at L&lt;https://github.com/Perl-Toolchain-Gang/CPAN-Meta/issues&gt;.
You will be notified automatically of any progress on your issue.

=head2 Source Code

This is open source software.  The code repository is available for
public review and contribution under the terms of the license.

L&lt;https://github.com/Perl-Toolchain-Gang/CPAN-Meta&gt;

  git clone https://github.com/Perl-Toolchain-Gang/CPAN-Meta.git

=head1 AUTHORS

=over 4

=item *

David Golden &lt;dagolden@cpan.org&gt;

=item *

Ricardo Signes &lt;rjbs@cpan.org&gt;

=item *

Adam Kennedy &lt;adamk@cpan.org&gt;

=back

=head1 CONTRIBUTORS

=for stopwords Ansgar Burchardt Avar Arnfjord Bjarmason Benjamin Noggle Christopher J. Madsen Chuck Adams Cory G Watson Damyan Ivanov David Golden Eric Wilhelm Graham Knop Gregor Hermann Karen Etheridge Kenichi Ishigaki Kent Fredric Ken Williams Lars Dieckow Leon Timmermans majensen Mark Fowler Matt S Trout Michael G. Schwern Mohammad Anwar mohawk2 moznion Niko Tyni Olaf Alders Olivier Mengué Randy Sims Tomohiro Hosaka

=over 4

=item *

Ansgar Burchardt &lt;ansgar@cpan.org&gt;

=item *

Avar Arnfjord Bjarmason &lt;avar@cpan.org&gt;

=item *

Benjamin Noggle &lt;agwind@users.noreply.github.com&gt;

=item *

Christopher J. Madsen &lt;cjm@cpan.org&gt;

=item *

Chuck Adams &lt;cja987@gmail.com&gt;

=item *

Cory G Watson &lt;gphat@cpan.org&gt;

=item *

Damyan Ivanov &lt;dam@cpan.org&gt;

=item *

David Golden &lt;xdg@xdg.me&gt;

=item *

Eric Wilhelm &lt;ewilhelm@cpan.org&gt;

=item *

Graham Knop &lt;haarg@haarg.org&gt;

=item *

Gregor Hermann &lt;gregoa@debian.org&gt;

=item *

Karen Etheridge &lt;ether@cpan.org&gt;

=item *

Kenichi Ishigaki &lt;ishigaki@cpan.org&gt;

=item *

Kent Fredric &lt;kentfredric@gmail.com&gt;

=item *

Ken Williams &lt;kwilliams@cpan.org&gt;

=item *

Lars Dieckow &lt;daxim@cpan.org&gt;

=item *

Leon Timmermans &lt;leont@cpan.org&gt;

=item *

majensen &lt;maj@fortinbras.us&gt;

=item *

Mark Fowler &lt;markf@cpan.org&gt;

=item *

Matt S Trout &lt;mst@shadowcat.co.uk&gt;

=item *

Michael G. Schwern &lt;mschwern@cpan.org&gt;

=item *

Mohammad S Anwar &lt;mohammad.anwar@yahoo.com&gt;

=item *

mohawk2 &lt;mohawk2@users.noreply.github.com&gt;

=item *

moznion &lt;moznion@gmail.com&gt;

=item *

Niko Tyni &lt;ntyni@debian.org&gt;

=item *

Olaf Alders &lt;olaf@wundersolutions.com&gt;

=item *

Olivier Mengué &lt;dolmen@cpan.org&gt;

=item *

Randy Sims &lt;randys@thepierianspring.org&gt;

=item *

Tomohiro Hosaka &lt;bokutin@bokut.in&gt;

=back

=head1 COPYRIGHT AND LICENSE

This software is copyright (c) 2010 by David Golden, Ricardo Signes, Adam Kennedy and Contributors.

This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.

=cut

__END__


# vim: ts=2 sts=2 sw=2 et :
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/share/perl5/vendor_perl/CPAN/Meta.pm'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Fshare%2Fperl5%2Fvendor_perl%2FCPAN' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>