

<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: Module.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;'># -*- Mode: cperl; coding: utf-8; cperl-indent-level: 4 -*-
# vim: ts=4 sts=4 sw=4:
package CPAN::Module;
use strict;
@CPAN::Module::ISA = qw(CPAN::InfoObj);

use vars qw(
            $VERSION
);
$VERSION = &quot;5.5003&quot;;

BEGIN {
    # alarm() is not implemented in perl 5.6.x and earlier under Windows
    *ALARM_IMPLEMENTED = sub () { $] &gt;= 5.007 || $^O !~ /MSWin/ };
}

# Accessors
#-&gt; sub CPAN::Module::userid
sub userid {
    my $self = shift;
    my $ro = $self-&gt;ro;
    return unless $ro;
    return $ro-&gt;{userid} || $ro-&gt;{CPAN_USERID};
}
#-&gt; sub CPAN::Module::description
sub description {
    my $self = shift;
    my $ro = $self-&gt;ro or return &quot;&quot;;
    $ro-&gt;{description}
}

#-&gt; sub CPAN::Module::distribution
sub distribution {
    my($self) = @_;
    CPAN::Shell-&gt;expand(&quot;Distribution&quot;,$self-&gt;cpan_file);
}

#-&gt; sub CPAN::Module::_is_representative_module
sub _is_representative_module {
    my($self) = @_;
    return $self-&gt;{_is_representative_module} if defined $self-&gt;{_is_representative_module};
    my $pm = $self-&gt;cpan_file or return $self-&gt;{_is_representative_module} = 0;
    $pm =~ s|.+/||;
    $pm =~ s{\.(?:tar\.(bz2|gz|Z)|t(?:gz|bz)|zip)$}{}i; # see base_id
    $pm =~ s|-\d+\.\d+.+$||;
    $pm =~ s|-[\d\.]+$||;
    $pm =~ s/-/::/g;
    $self-&gt;{_is_representative_module} = $pm eq $self-&gt;{ID} ? 1 : 0;
    # warn &quot;DEBUG: $pm eq $self-&gt;{ID} =&gt; $self-&gt;{_is_representative_module}&quot;;
    $self-&gt;{_is_representative_module};
}

#-&gt; sub CPAN::Module::undelay
sub undelay {
    my $self = shift;
    delete $self-&gt;{later};
    if ( my $dist = CPAN::Shell-&gt;expand(&quot;Distribution&quot;, $self-&gt;cpan_file) ) {
        $dist-&gt;undelay;
    }
}

# mark as dirty/clean
#-&gt; sub CPAN::Module::color_cmd_tmps ;
sub color_cmd_tmps {
    my($self) = shift;
    my($depth) = shift || 0;
    my($color) = shift || 0;
    my($ancestors) = shift || [];
    # a module needs to recurse to its cpan_file

    return if exists $self-&gt;{incommandcolor}
        &amp;&amp; $color==1
        &amp;&amp; $self-&gt;{incommandcolor}==$color;
    return if $color==0 &amp;&amp; !$self-&gt;{incommandcolor};
    if ($color&gt;=1) {
        if ( $self-&gt;uptodate ) {
            $self-&gt;{incommandcolor} = $color;
            return;
        } elsif (my $have_version = $self-&gt;available_version) {
            # maybe what we have is good enough
            if (@$ancestors) {
                my $who_asked_for_me = $ancestors-&gt;[-1];
                my $obj = CPAN::Shell-&gt;expandany($who_asked_for_me);
                if (0) {
                } elsif ($obj-&gt;isa(&quot;CPAN::Bundle&quot;)) {
                    # bundles cannot specify a minimum version
                    return;
                } elsif ($obj-&gt;isa(&quot;CPAN::Distribution&quot;)) {
                    if (my $prereq_pm = $obj-&gt;prereq_pm) {
                        for my $k (keys %$prereq_pm) {
                            if (my $want_version = $prereq_pm-&gt;{$k}{$self-&gt;id}) {
                                if (CPAN::Version-&gt;vcmp($have_version,$want_version) &gt;= 0) {
                                    $self-&gt;{incommandcolor} = $color;
                                    return;
                                }
                            }
                        }
                    }
                }
            }
        }
    } else {
        $self-&gt;{incommandcolor} = $color; # set me before recursion,
                                          # so we can break it
    }
    if ($depth&gt;=$CPAN::MAX_RECURSION) {
        my $e = CPAN::Exception::RecursiveDependency-&gt;new($ancestors);
        if ($e-&gt;is_resolvable) {
            return $self-&gt;{incommandcolor}=2;
        } else {
            die $e;
        }
    }
    # warn &quot;color_cmd_tmps $depth $color &quot; . $self-&gt;id; # sleep 1;

    if ( my $dist = CPAN::Shell-&gt;expand(&quot;Distribution&quot;, $self-&gt;cpan_file) ) {
        $dist-&gt;color_cmd_tmps($depth+1,$color,[@$ancestors, $self-&gt;id]);
    }
    # unreached code?
    # if ($color==0) {
    #    delete $self-&gt;{badtestcnt};
    # }
    $self-&gt;{incommandcolor} = $color;
}

#-&gt; sub CPAN::Module::as_glimpse ;
sub as_glimpse {
    my($self) = @_;
    my(@m);
    my $class = ref($self);
    $class =~ s/^CPAN:://;
    my $color_on = &quot;&quot;;
    my $color_off = &quot;&quot;;
    if (
        $CPAN::Shell::COLOR_REGISTERED
        &amp;&amp;
        $CPAN::META-&gt;has_inst(&quot;Term::ANSIColor&quot;)
        &amp;&amp;
        $self-&gt;description
       ) {
        $color_on = Term::ANSIColor::color(&quot;green&quot;);
        $color_off = Term::ANSIColor::color(&quot;reset&quot;);
    }
    my $uptodateness = &quot; &quot;;
    unless ($class eq &quot;Bundle&quot;) {
        my $u = $self-&gt;uptodate;
        $uptodateness = $u ? &quot;=&quot; : &quot;&lt;&quot; if defined $u;
    };
    my $id = do {
        my $d = $self-&gt;distribution;
        $d ? $d -&gt; pretty_id : $self-&gt;cpan_userid;
    };
    push @m, sprintf(&quot;%-7s %1s %s%-22s%s (%s)\n&quot;,
                     $class,
                     $uptodateness,
                     $color_on,
                     $self-&gt;id,
                     $color_off,
                     $id,
                    );
    join &quot;&quot;, @m;
}

#-&gt; sub CPAN::Module::dslip_status
sub dslip_status {
    my($self) = @_;
    my($stat);
    # development status
    @{$stat-&gt;{D}}{qw,i c a b R M S,}     = qw,idea
                                              pre-alpha alpha beta released
                                              mature standard,;
    # support level
    @{$stat-&gt;{S}}{qw,m d u n a,}         = qw,mailing-list
                                              developer comp.lang.perl.*
                                              none abandoned,;
    # language
    @{$stat-&gt;{L}}{qw,p c + o h,}         = qw,perl C C++ other hybrid,;
    # interface
    @{$stat-&gt;{I}}{qw,f r O p h n,}       = qw,functions
                                              references+ties
                                              object-oriented pragma
                                              hybrid none,;
    # public licence
    @{$stat-&gt;{P}}{qw,p g l b a 2 o d r n,} = qw,Standard-Perl
                                              GPL LGPL
                                              BSD Artistic Artistic_2
                                              open-source
                                              distribution_allowed
                                              restricted_distribution
                                              no_licence,;
    for my $x (qw(d s l i p)) {
        $stat-&gt;{$x}{&#039; &#039;} = &#039;unknown&#039;;
        $stat-&gt;{$x}{&#039;?&#039;} = &#039;unknown&#039;;
    }
    my $ro = $self-&gt;ro;
    return +{} unless $ro &amp;&amp; $ro-&gt;{statd};
    return {
            D  =&gt; $ro-&gt;{statd},
            S  =&gt; $ro-&gt;{stats},
            L  =&gt; $ro-&gt;{statl},
            I  =&gt; $ro-&gt;{stati},
            P  =&gt; $ro-&gt;{statp},
            DV =&gt; $stat-&gt;{D}{$ro-&gt;{statd}},
            SV =&gt; $stat-&gt;{S}{$ro-&gt;{stats}},
            LV =&gt; $stat-&gt;{L}{$ro-&gt;{statl}},
            IV =&gt; $stat-&gt;{I}{$ro-&gt;{stati}},
            PV =&gt; $stat-&gt;{P}{$ro-&gt;{statp}},
           };
}

#-&gt; sub CPAN::Module::as_string ;
sub as_string {
    my($self) = @_;
    my(@m);
    CPAN-&gt;debug(&quot;$self entering as_string&quot;) if $CPAN::DEBUG;
    my $class = ref($self);
    $class =~ s/^CPAN:://;
    local($^W) = 0;
    push @m, $class, &quot; id = $self-&gt;{ID}\n&quot;;
    my $sprintf = &quot;    %-12s %s\n&quot;;
    push @m, sprintf($sprintf, &#039;DESCRIPTION&#039;, $self-&gt;description)
        if $self-&gt;description;
    my $sprintf2 = &quot;    %-12s %s (%s)\n&quot;;
    my($userid);
    $userid = $self-&gt;userid;
    if ( $userid ) {
        my $author;
        if ($author = CPAN::Shell-&gt;expand(&#039;Author&#039;,$userid)) {
            my $email = &quot;&quot;;
            my $m; # old perls
            if ($m = $author-&gt;email) {
                $email = &quot; &lt;$m&gt;&quot;;
            }
            push @m, sprintf(
                             $sprintf2,
                             &#039;CPAN_USERID&#039;,
                             $userid,
                             $author-&gt;fullname . $email
                            );
        }
    }
    push @m, sprintf($sprintf, &#039;CPAN_VERSION&#039;, $self-&gt;cpan_version)
        if $self-&gt;cpan_version;
    if (my $cpan_file = $self-&gt;cpan_file) {
        push @m, sprintf($sprintf, &#039;CPAN_FILE&#039;, $cpan_file);
        if (my $dist = CPAN::Shell-&gt;expand(&quot;Distribution&quot;,$cpan_file)) {
            my $upload_date = $dist-&gt;upload_date;
            if ($upload_date) {
                push @m, sprintf($sprintf, &#039;UPLOAD_DATE&#039;, $upload_date);
            }
        }
    }
    my $sprintf3 = &quot;    %-12s %1s%1s%1s%1s%1s (%s,%s,%s,%s,%s)\n&quot;;
    my $dslip = $self-&gt;dslip_status;
    push @m, sprintf(
                     $sprintf3,
                     &#039;DSLIP_STATUS&#039;,
                     @{$dslip}{qw(D S L I P DV SV LV IV PV)},
                    ) if $dslip-&gt;{D};
    my $local_file = $self-&gt;inst_file;
    unless ($self-&gt;{MANPAGE}) {
        my $manpage;
        if ($local_file) {
            $manpage = $self-&gt;manpage_headline($local_file);
        } else {
            # If we have already untarred it, we should look there
            my $dist = $CPAN::META-&gt;instance(&#039;CPAN::Distribution&#039;,
                                             $self-&gt;cpan_file);
            # warn &quot;dist[$dist]&quot;;
            # mff=manifest file; mfh=manifest handle
            my($mff,$mfh);
            if (
                $dist-&gt;{build_dir}
                and
                (-f  ($mff = File::Spec-&gt;catfile($dist-&gt;{build_dir}, &quot;MANIFEST&quot;)))
                and
                $mfh = FileHandle-&gt;new($mff)
               ) {
                CPAN-&gt;debug(&quot;mff[$mff]&quot;) if $CPAN::DEBUG;
                my $lfre = $self-&gt;id; # local file RE
                $lfre =~ s/::/./g;
                $lfre .= &quot;\\.pm\$&quot;;
                my($lfl); # local file file
                local $/ = &quot;\n&quot;;
                my(@mflines) = &lt;$mfh&gt;;
                for (@mflines) {
                    s/^\s+//;
                    s/\s.*//s;
                }
                while (length($lfre)&gt;5 and !$lfl) {
                    ($lfl) = grep /$lfre/, @mflines;
                    CPAN-&gt;debug(&quot;lfl[$lfl]lfre[$lfre]&quot;) if $CPAN::DEBUG;
                    $lfre =~ s/.+?\.//;
                }
                $lfl =~ s/\s.*//; # remove comments
                $lfl =~ s/\s+//g; # chomp would maybe be too system-specific
                my $lfl_abs = File::Spec-&gt;catfile($dist-&gt;{build_dir},$lfl);
                # warn &quot;lfl_abs[$lfl_abs]&quot;;
                if (-f $lfl_abs) {
                    $manpage = $self-&gt;manpage_headline($lfl_abs);
                }
            }
        }
        $self-&gt;{MANPAGE} = $manpage if $manpage;
    }
    my($item);
    for $item (qw/MANPAGE/) {
        push @m, sprintf($sprintf, $item, $self-&gt;{$item})
            if exists $self-&gt;{$item};
    }
    for $item (qw/CONTAINS/) {
        push @m, sprintf($sprintf, $item, join(&quot; &quot;,@{$self-&gt;{$item}}))
            if exists $self-&gt;{$item} &amp;&amp; @{$self-&gt;{$item}};
    }
    push @m, sprintf($sprintf, &#039;INST_FILE&#039;,
                     $local_file || &quot;(not installed)&quot;);
    push @m, sprintf($sprintf, &#039;INST_VERSION&#039;,
                     $self-&gt;inst_version) if $local_file;
    if (%{$CPAN::META-&gt;{is_tested}||{}}) { # XXX needs to be methodified somehow
        my $available_file = $self-&gt;available_file;
        if ($available_file &amp;&amp; $available_file ne $local_file) {
            push @m, sprintf($sprintf, &#039;AVAILABLE_FILE&#039;, $available_file);
            push @m, sprintf($sprintf, &#039;AVAILABLE_VERSION&#039;, $self-&gt;available_version);
        }
    }
    join &quot;&quot;, @m, &quot;\n&quot;;
}

#-&gt; sub CPAN::Module::manpage_headline
sub manpage_headline {
    my($self,$local_file) = @_;
    my(@local_file) = $local_file;
    $local_file =~ s/\.pm(?!\n)\Z/.pod/;
    push @local_file, $local_file;
    my(@result,$locf);
    for $locf (@local_file) {
        next unless -f $locf;
        my $fh = FileHandle-&gt;new($locf)
            or $Carp::Frontend-&gt;mydie(&quot;Couldn&#039;t open $locf: $!&quot;);
        my $inpod = 0;
        local $/ = &quot;\n&quot;;
        while (&lt;$fh&gt;) {
            $inpod = m/^=(?!head1\s+NAME\s*$)/ ? 0 :
                m/^=head1\s+NAME\s*$/ ? 1 : $inpod;
            next unless $inpod;
            next if /^=/;
            next if /^\s+$/;
            chomp;
            push @result, $_;
        }
        close $fh;
        last if @result;
    }
    for (@result) {
        s/^\s+//;
        s/\s+$//;
    }
    join &quot; &quot;, @result;
}

#-&gt; sub CPAN::Module::cpan_file ;
# Note: also inherited by CPAN::Bundle
sub cpan_file {
    my $self = shift;
    # CPAN-&gt;debug(sprintf &quot;id[%s]&quot;, $self-&gt;id) if $CPAN::DEBUG;
    unless ($self-&gt;ro) {
        CPAN::Index-&gt;reload;
    }
    my $ro = $self-&gt;ro;
    if ($ro &amp;&amp; defined $ro-&gt;{CPAN_FILE}) {
        return $ro-&gt;{CPAN_FILE};
    } else {
        my $userid = $self-&gt;userid;
        if ( $userid ) {
            if ($CPAN::META-&gt;exists(&quot;CPAN::Author&quot;,$userid)) {
                my $author = $CPAN::META-&gt;instance(&quot;CPAN::Author&quot;,
                                                   $userid);
                my $fullname = $author-&gt;fullname;
                my $email = $author-&gt;email;
                unless (defined $fullname &amp;&amp; defined $email) {
                    return sprintf(&quot;Contact Author %s&quot;,
                                   $userid,
                                  );
                }
                return &quot;Contact Author $fullname &lt;$email&gt;&quot;;
            } else {
                return &quot;Contact Author $userid (Email address not available)&quot;;
            }
        } else {
            return &quot;N/A&quot;;
        }
    }
}

#-&gt; sub CPAN::Module::cpan_version ;
sub cpan_version {
    my $self = shift;

    my $ro = $self-&gt;ro;
    unless ($ro) {
        # Can happen with modules that are not on CPAN
        $ro = {};
    }
    $ro-&gt;{CPAN_VERSION} = &#039;undef&#039;
        unless defined $ro-&gt;{CPAN_VERSION};
    $ro-&gt;{CPAN_VERSION};
}

#-&gt; sub CPAN::Module::force ;
sub force {
    my($self) = @_;
    $self-&gt;{force_update} = 1;
}

#-&gt; sub CPAN::Module::fforce ;
sub fforce {
    my($self) = @_;
    $self-&gt;{force_update} = 2;
}

#-&gt; sub CPAN::Module::notest ;
sub notest {
    my($self) = @_;
    # $CPAN::Frontend-&gt;mywarn(&quot;XDEBUG: set notest for Module&quot;);
    $self-&gt;{notest}++;
}

#-&gt; sub CPAN::Module::rematein ;
sub rematein {
    my($self,$meth) = @_;
    $CPAN::Frontend-&gt;myprint(sprintf(&quot;Running %s for module &#039;%s&#039;\n&quot;,
                                     $meth,
                                     $self-&gt;id));
    my $cpan_file = $self-&gt;cpan_file;
    if ($cpan_file eq &quot;N/A&quot; || $cpan_file =~ /^Contact Author/) {
        $CPAN::Frontend-&gt;mywarn(sprintf qq{
  The module %s isn\&#039;t available on CPAN.

  Either the module has not yet been uploaded to CPAN, or it is
  temporary unavailable. Please contact the author to find out
  more about the status. Try &#039;i %s&#039;.
},
                                $self-&gt;id,
                                $self-&gt;id,
                               );
        return;
    }
    my $pack = $CPAN::META-&gt;instance(&#039;CPAN::Distribution&#039;,$cpan_file);
    $pack-&gt;called_for($self-&gt;id);
    if (exists $self-&gt;{force_update}) {
        if ($self-&gt;{force_update} == 2) {
            $pack-&gt;fforce($meth);
        } else {
            $pack-&gt;force($meth);
        }
    }
    $pack-&gt;notest($meth) if exists $self-&gt;{notest} &amp;&amp; $self-&gt;{notest};

    $pack-&gt;{reqtype} ||= &quot;&quot;;
    CPAN-&gt;debug(&quot;dist-reqtype[$pack-&gt;{reqtype}]&quot;.
                &quot;self-reqtype[$self-&gt;{reqtype}]&quot;) if $CPAN::DEBUG;
        if ($pack-&gt;{reqtype}) {
            if ($pack-&gt;{reqtype} eq &quot;b&quot; &amp;&amp; $self-&gt;{reqtype} =~ /^[rc]$/) {
                $pack-&gt;{reqtype} = $self-&gt;{reqtype};
                if (
                    exists $pack-&gt;{install}
                    &amp;&amp;
                    (
                     UNIVERSAL::can($pack-&gt;{install},&quot;failed&quot;) ?
                     $pack-&gt;{install}-&gt;failed :
                     $pack-&gt;{install} =~ /^NO/
                    )
                   ) {
                    delete $pack-&gt;{install};
                    $CPAN::Frontend-&gt;mywarn
                        (&quot;Promoting $pack-&gt;{ID} from &#039;build_requires&#039; to &#039;requires&#039;&quot;);
                }
            }
        } else {
            $pack-&gt;{reqtype} = $self-&gt;{reqtype};
        }

    my $success = eval {
        $pack-&gt;$meth();
    };
    my $err = $@;
    $pack-&gt;unforce if $pack-&gt;can(&quot;unforce&quot;) &amp;&amp; exists $self-&gt;{force_update};
    $pack-&gt;unnotest if $pack-&gt;can(&quot;unnotest&quot;) &amp;&amp; exists $self-&gt;{notest};
    delete $self-&gt;{force_update};
    delete $self-&gt;{notest};
    if ($err) {
        die $err;
    }
    return $success;
}

#-&gt; sub CPAN::Module::perldoc ;
sub perldoc { shift-&gt;rematein(&#039;perldoc&#039;) }
#-&gt; sub CPAN::Module::readme ;
sub readme  { shift-&gt;rematein(&#039;readme&#039;) }
#-&gt; sub CPAN::Module::look ;
sub look    { shift-&gt;rematein(&#039;look&#039;) }
#-&gt; sub CPAN::Module::cvs_import ;
sub cvs_import { shift-&gt;rematein(&#039;cvs_import&#039;) }
#-&gt; sub CPAN::Module::get ;
sub get     { shift-&gt;rematein(&#039;get&#039;,@_) }
#-&gt; sub CPAN::Module::make ;
sub make    { shift-&gt;rematein(&#039;make&#039;) }
#-&gt; sub CPAN::Module::test ;
sub test   {
    my $self = shift;
    # $self-&gt;{badtestcnt} ||= 0;
    $self-&gt;rematein(&#039;test&#039;,@_);
}

#-&gt; sub CPAN::Module::deprecated_in_core ;
sub deprecated_in_core {
    my ($self) = @_;
    return unless $CPAN::META-&gt;has_inst(&#039;Module::CoreList&#039;) &amp;&amp; Module::CoreList-&gt;can(&#039;is_deprecated&#039;);
    return Module::CoreList::is_deprecated($self-&gt;{ID});
}

#-&gt; sub CPAN::Module::inst_deprecated;
# Indicates whether the *installed* version of the module is a deprecated *and*
# installed as part of the Perl core library path
sub inst_deprecated {
    my ($self) = @_;
    my $inst_file = $self-&gt;inst_file or return;
    return $self-&gt;deprecated_in_core &amp;&amp; $self-&gt;_in_priv_or_arch($inst_file);
}

#-&gt; sub CPAN::Module::uptodate ;
sub uptodate {
    my ($self) = @_;
    local ($_);
    my $inst = $self-&gt;inst_version or return 0;
    my $cpan = $self-&gt;cpan_version;
    return 0 if CPAN::Version-&gt;vgt($cpan,$inst) || $self-&gt;inst_deprecated;
    CPAN-&gt;debug
        (join
         (&quot;&quot;,
          &quot;returning uptodate. &quot;,
          &quot;cpan[$cpan]inst[$inst]&quot;,
         )) if $CPAN::DEBUG;
    return 1;
}

# returns true if installed in privlib or archlib
sub _in_priv_or_arch {
    my($self,$inst_file) = @_;
    foreach my $pair (
        [qw(sitearchexp archlibexp)],
        [qw(sitelibexp privlibexp)]
    ) {
        my ($site, $priv) = @Config::Config{@$pair};
        if ($^O eq &#039;VMS&#039;) {
            for my $d ($site, $priv) { $d = VMS::Filespec::unixify($d) };
        }
        s!/*$!!g foreach $site, $priv;
        next if $site eq $priv;

        if ($priv eq substr($inst_file,0,length($priv))) {
            return 1;
        }
    }
    return 0;
}

#-&gt; sub CPAN::Module::install ;
sub install {
    my($self) = @_;
    my($doit) = 0;
    if ($self-&gt;uptodate
        &amp;&amp;
        not exists $self-&gt;{force_update}
       ) {
        $CPAN::Frontend-&gt;myprint(sprintf(&quot;%s is up to date (%s).\n&quot;,
                                         $self-&gt;id,
                                         $self-&gt;inst_version,
                                        ));
    } else {
        $doit = 1;
    }
    my $ro = $self-&gt;ro;
    if ($ro &amp;&amp; $ro-&gt;{stats} &amp;&amp; $ro-&gt;{stats} eq &quot;a&quot;) {
        $CPAN::Frontend-&gt;mywarn(qq{
\n\n\n     ***WARNING***
     The module $self-&gt;{ID} has no active maintainer (CPAN support level flag &#039;abandoned&#039;).\n\n\n
});
        $CPAN::Frontend-&gt;mysleep(5);
    }
    return $doit ? $self-&gt;rematein(&#039;install&#039;) : 1;
}
#-&gt; sub CPAN::Module::clean ;
sub clean  { shift-&gt;rematein(&#039;clean&#039;) }

#-&gt; sub CPAN::Module::inst_file ;
sub inst_file {
    my($self) = @_;
    $self-&gt;_file_in_path([@INC]);
}

#-&gt; sub CPAN::Module::available_file ;
sub available_file {
    my($self) = @_;
    my $sep = $Config::Config{path_sep};
    my $perllib = $ENV{PERL5LIB};
    $perllib = $ENV{PERLLIB} unless defined $perllib;
    my @perllib = split(/$sep/,$perllib) if defined $perllib;
    my @cpan_perl5inc;
    if ($CPAN::Perl5lib_tempfile) {
        my $yaml = CPAN-&gt;_yaml_loadfile($CPAN::Perl5lib_tempfile);
        @cpan_perl5inc = @{$yaml-&gt;[0]{inc} || []};
    }
    $self-&gt;_file_in_path([@cpan_perl5inc,@perllib,@INC]);
}

#-&gt; sub CPAN::Module::file_in_path ;
sub _file_in_path {
    my($self,$path) = @_;
    my($dir,@packpath);
    @packpath = split /::/, $self-&gt;{ID};
    $packpath[-1] .= &quot;.pm&quot;;
    if (@packpath == 1 &amp;&amp; $packpath[0] eq &quot;readline.pm&quot;) {
        unshift @packpath, &quot;Term&quot;, &quot;ReadLine&quot;; # historical reasons
    }
    foreach $dir (@$path) {
        my $pmfile = File::Spec-&gt;catfile($dir,@packpath);
        if (-f $pmfile) {
            return $pmfile;
        }
    }
    return;
}

#-&gt; sub CPAN::Module::xs_file ;
sub xs_file {
    my($self) = @_;
    my($dir,@packpath);
    @packpath = split /::/, $self-&gt;{ID};
    push @packpath, $packpath[-1];
    $packpath[-1] .= &quot;.&quot; . $Config::Config{&#039;dlext&#039;};
    foreach $dir (@INC) {
        my $xsfile = File::Spec-&gt;catfile($dir,&#039;auto&#039;,@packpath);
        if (-f $xsfile) {
            return $xsfile;
        }
    }
    return;
}

#-&gt; sub CPAN::Module::inst_version ;
sub inst_version {
    my($self) = @_;
    my $parsefile = $self-&gt;inst_file or return;
    my $have = $self-&gt;parse_version($parsefile);
    $have;
}

#-&gt; sub CPAN::Module::inst_version ;
sub available_version {
    my($self) = @_;
    my $parsefile = $self-&gt;available_file or return;
    my $have = $self-&gt;parse_version($parsefile);
    $have;
}

#-&gt; sub CPAN::Module::parse_version ;
sub parse_version {
    my($self,$parsefile) = @_;
    if (ALARM_IMPLEMENTED) {
        my $timeout = (exists($CPAN::Config{&#039;version_timeout&#039;}))
                            ? $CPAN::Config{&#039;version_timeout&#039;}
                            : 15;
        alarm($timeout);
    }
    my $have = eval {
        local $SIG{ALRM} = sub { die &quot;alarm\n&quot; };
        MM-&gt;parse_version($parsefile);
    };
    if ($@) {
        $CPAN::Frontend-&gt;mywarn(&quot;Error while parsing version number in file &#039;$parsefile&#039;\n&quot;);
    }
    alarm(0) if ALARM_IMPLEMENTED;
    my $leastsanity = eval { defined $have &amp;&amp; length $have; };
    $have = &quot;undef&quot; unless $leastsanity;
    $have =~ s/^ //; # since the %vd hack these two lines here are needed
    $have =~ s/ $//; # trailing whitespace happens all the time

    $have = CPAN::Version-&gt;readable($have);

    $have =~ s/\s*//g; # stringify to float around floating point issues
    $have; # no stringify needed, \s* above matches always
}

#-&gt; sub CPAN::Module::reports
sub reports {
    my($self) = @_;
    $self-&gt;distribution-&gt;reports;
}

1;
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/share/perl5/vendor_perl/CPAN/Module.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>