Como obtenho uma lista dos módulos CPAN instalados?

Além de tentar

perldoc <module name>

individualmente para qualquer módulo CPAN que me agrade, ou examinando o sistema de arquivos e olhando os diretórios, não tenho ideia de quais módulos instalamos.

Qual é a maneira mais fácil de obter uma grande lista de cada módulo CPAN instalado? Da linha de comando ou de outra forma.

Isso é respondido no FAQ do Perl, cuja resposta pode ser encontrada rapidamente com perldoc -q installed. Resumindo, tudo se resume a usar ExtUtils::Installedou usar File::Find, variantes de ambos que foram abordadas anteriormente neste tópico.

Você também pode encontrar a entrada da FAQ "Como descubro quais módulos estão instalados em meu sistema?" em perlfaq3. Você pode ver uma lista de todas as respostas do FAQ procurando em perlfaq

perldoc perllocal

Edit: Há um (pouco) mais informações sobre isso no CPAN FAQ

perldoc -q installed

afirma que cpan -lresolverá o problema, mas não está funcionando para mim. A outra opção:

cpan -a

expulsa uma boa lista de pacotes instalados e tem o efeito colateral agradável de gravá-los em um arquivo.

É importante notar que perldoc perllocal reportará apenas em módulos instalados via CPAN. Se alguém instalar os módulos manualmente, não os encontrará. Além disso, se você tiver várias pessoas instalando módulos e o perllocal.pod estiver sob controle de origem, as pessoas podem resolver os conflitos incorretamente e corromper a lista (isso aconteceu aqui no trabalho, por exemplo).

Infelizmente, a solução parece estar percorrendo @INC com File :: Find ou algo semelhante. No entanto, isso não localiza apenas os módulos, também encontra módulos relacionados em uma distribuição. Por exemplo, ele relataria TAP :: Harness e TAP :: Parser além do nome real da distribuição de Test :: Harness (assumindo que você tenha a versão 3 ou superior). Você poderia potencialmente combiná-los com nomes de distribuição e descartar aqueles nomes que não combinam, mas então você pode estar descartando módulos construídos e instalados localmente.

Acredito que o trabalho de indexação backpan de brian d foy deve ter código para entregá-lo no arquivo .pm e tentará inferir a distribuição, mas mesmo isso às vezes falha porque o que está em um pacote não está necessariamente instalado (consulte Devel :: Cover :: Inc para um exemplo).

$ for M in `perldoc -t perllocal|grep Module |sed -e 's/^.*" //'`; do V=`perldoc -t perllocal|awk "/$M/{y=1;next}y" |grep VERSION |head -n 1`; printf "%30s %s\n" "$M" "$V"; done |sort
              Class::Inspector     *   "VERSION: 1.28"
                    Crypt::CBC     *   "VERSION: 2.33"
               Crypt::Rijndael     *   "VERSION: 1.11"
                    Data::Dump     *   "VERSION: 1.22"
                   DBD::Oracle     *   "VERSION: 1.68"
                           DBI     *   "VERSION: 1.630"
                   Digest::SHA     *   "VERSION: 5.92"
           ExtUtils::MakeMaker     *   "VERSION: 6.84"
                       install     *   "VERSION: 6.84"
               IO::SessionData     *   "VERSION: 1.03"
               IO::Socket::SSL     *   "VERSION: 2.016"
                          JSON     *   "VERSION: 2.90"
                  MIME::Base64     *   "VERSION: 3.14"
                  MIME::Base64     *   "VERSION: 3.14"
                   Mozilla::CA     *   "VERSION: 20141217"
                   Net::SSLeay     *   "VERSION: 1.68"
                        parent     *   "VERSION: 0.228"
                  REST::Client     *   "VERSION: 271"
                    SOAP::Lite     *   "VERSION: 1.08"
                  Task::Weaken     *   "VERSION: 1.04"
                 Term::ReadKey     *   "VERSION: 2.31"
                Test::Manifest     *   "VERSION: 1.23"
                  Test::Simple     *   "VERSION: 1.001002"
                  Text::CSV_XS     *   "VERSION: 1.16"
                     Try::Tiny     *   "VERSION: 0.22"
                   XML::LibXML     *   "VERSION: 2.0108"
         XML::NamespaceSupport     *   "VERSION: 1.11"
                XML::SAX::Base     *   "VERSION: 1.08"

Você pode tentar ExtUtils-Installed , mas ele só olha em .packlists, então pode faltar módulos para os quais as pessoas movem as coisas @INCmanualmente.

Escrevi App-Module-Lister para um amigo que queria fazer isso como um script CGI em uma conta de hospedagem web não shell. Você simplesmente pega o arquivo do módulo e carrega-o como um nome de arquivo que seu servidor tratará como um script CGI. Não tem dependências fora da Biblioteca Padrão. Use-o como está ou roube o código.

Ele produz uma lista dos módulos e suas versões:

Empate :: Ciclo 1.15
Empate :: IxHash 1.21
Tie :: Toggle 1.07
Tie :: ToObject 0,03
Tempo :: CTime 99.062201
Time :: DaysInMonth 99.1117
Tempo :: Época 0,02
Tempo :: Fuzzy 0,34
Hora :: JulianDay 2003.1125
Time :: ParseDate 2006.0814
Time :: Timezone 2006.0814

Tenho pretendido adicionar isso como um recurso à cpanferramenta, então farei isso também. [O tempo passa] E, agora eu tenho um -linterruptor cpan. Tenho algumas outras coisas a fazer com ele antes de fazer um lançamento, mas está no github . Se você não quiser esperar por isso, pode simplesmente tentar o -aswitch para criar um agrupamento automático, embora isso coloque alguns Pod em torno da lista.

Boa sorte;

Aqui está um script que faria o truque:

use ExtUtils::Installed;

my $inst = ExtUtils::Installed->new();
my @modules = $inst->modules();
foreach $module (@modules){
       print $module ." - ". $inst->version($module). "\n";
}

=head1 ABOUT

This scripts lists installed cpan modules using the ExtUtils modules

=head1 FORMAT

Prints each module in the following format
<name> - <version>

=cut

Eu gosto de usar o comando 'r' do CPAN para isso. Você pode entrar no shell CPAN com o estilo antigo:

sudo perl -MCPAN -e shell

ou, na maioria dos sistemas mais recentes, há um comando 'cpan', portanto, este comando o levará ao shell:

sudo cpan

(Você normalmente tem que usar 'sudo' para executá-lo como root ou usar 'su -' para se tornar root antes de executá-lo, a menos que você tenha o cpan configurado para permitir que você execute-o como um usuário normal, mas instale como root. Se você não tem root nesta máquina, você ainda pode usar o shell CPAN para descobrir esta informação, mas você não será capaz de instalar os módulos, e você pode ter que passar por algumas configurações na primeira vez que executá-lo.)

Então, uma vez no shell cpan, você pode usar o comando 'r' para relatar todos os módulos instalados e suas versões. Portanto, no prompt "cpan>", digite 'r'. Isso listará todos os módulos instalados e suas versões. Usar '?' para obter mais ajuda.

Esta é uma maneira realmente hacky de fazer isso em * nix, você obterá algumas coisas com as quais realmente não se preocupa (por exemplo: warnings :: register etc), mas deve fornecer uma lista de todos os arquivos .pm que podem ser acessados ​​via perl.

for my $path (@INC) {
    my @list = `ls -R $path/**/*.pm`;
    for (@list) {
        s/$path\///g;
        s/\//::/g;
        s/\.pm$//g;
        print;
    }
}

perl -MFile::Find=find -MFile::Spec::Functions -Tlwe 'find { wanted => sub { print canonpath $_ if /\.pm\z/ }, no_chdir => 1 }, @INC'

Você pode obter uma lista de módulos perl instalados em seu sistema usando o instmodshcomando em seu terminal. Ele irá pedir-lhe três opções para melhorar a saída são:

   l            - List all installed modules
   m <module>   - Select a module
   q            - Quit the program

No Linux / Unix, uso este comando simples:

perl -e 'print qx/find $_ -name "*.pm"/ foreach ( @INC );' 

Ele verifica todas as pastas @INCe procura qualquer arquivo * .pm.

Tente o seguinte comando

instmodsh

A resposta pode ser encontrada na lista Perl FAQ .

Você deve dar uma olhada na excelente documentação que vem com o Perl

perldoc perltoc

Experimente man perllocalou perldoc perllocal.

Todos aqueles que não podem instalar o perldoc, ou outros módulos, e querem saber quais módulos estão disponíveis (CPAN ou outro), o seguinte funciona para linux e Mingw32 / 64:

grep -RhIP '^package [A-Z][\w:]+;' `perl -e 'print join " ",@INC'` | sed 's/package //' | sort | uniq

Sim, está bagunçado. Sim, provavelmente reporta mais do que você deseja. Mas se você canalizá-lo em um arquivo, poderá verificar facilmente, digamos, quais interfaces dbm estão presentes:

 grep -RhIP '^package [A-Z][\w:]+;' `perl -e 'print join " ",@INC'` | sed 's/package //' | sort | uniq > modules-installed
 cat modules-installed | grep -i dbm 

AnyDBM_File;
Memoize::AnyDBM_File;
Memoize::NDBM_File;
Memoize::SDBM_File;
WWW::RobotRules::AnyDBM_File;

É por isso que acabei nesta página (decepcionado)

(Eu sei que isso não responde exatamente à pergunta do OP, mas estou postando para qualquer um que acabou aqui pelo mesmo motivo que eu fiz. Esse é o problema com pilha *** é quase impossível encontrar a pergunta que você está perguntando, mesmo quando existe, mas stack *** é quase sempre o maior hit do Google!)

Eu escrevi um script perl ontem para fazer exatamente isso. O script retorna a lista de módulos perl instalados em @INC usando '::' como separador. Chame o script usando -

perl perlmod.pl

OU

perl perlmod.pl <module name> #Case-insensitive(eg. perl perlmod.pl ftp)

A partir de agora, o script pula o diretório atual ('.'), Pois eu estava tendo problemas com links de software recorrentes, mas você pode incluí-lo alterando a função grep na linha 17 de

  grep { $_ !~ '^\.$' } @INC

para apenas,

@INC

O script pode ser encontrado aqui.

Aqui está outra ferramenta de linha de comando para listar todos os arquivos .pm instalados:

Encontre módulos Perl instalados que correspondam a uma expressão regular

• Portátil (usa apenas módulos principais)
• Opção de cache para pesquisas mais rápidas
• Opções de exibição configuráveis

Para percorrer as árvores de diretório @INC sem usar um programa externo como ls (1), pode-se usar o File::Find::Rulemódulo, que tem uma interface declarativa agradável.

Além disso, você deseja filtrar as duplicatas caso as versões anteriores do Perl contenham os mesmos módulos. O código para fazer isso se parece com:

#! /usr/bin/perl -l

use strict;
use warnings;
use File::Find::Rule;

my %seen;
for my $path (@INC) {
    for my $file (File::Find::Rule->name('*.pm')->in($path)) {
        my $module = substr($file, length($path)+1);
        $module =~ s/.pm$//;
        $module =~ s{[\\/]}{::}g;
        print $module unless $seen{$module}++;
    }
}

No final da execução, você também terá todos os nomes de seus módulos como chaves no hash% seen. O código pode ser adaptado para salvar o nome do arquivo canônico (fornecido em $ file) como o valor da chave em vez de uma contagem de vezes visto.

O seguinte funcionou para mim.

$ perldoc perllocal | grep Module
$ perldoc perllocal | grep -E 'VERSION|Module'

Aqui está um roteiro de @ JamesThomasMoon1979 reescrito como uma linha

perl -MExtUtils::Installed -e '$i=ExtUtils::Installed->new(); 
      print "$_ ".$i->version($_)."\n" for $i->modules();'

o livro de receitas do Perl contém várias iterações de um script "pmdesc" que faz o que você deseja. Pesquise no Google por "Perl Cookbook pmdesc" e você encontrará artigos em outros sites de perguntas e respostas , várias listagens de códigos na rede, uma discussão sobre a solução e até mesmo alguns refinamentos .

Aqui está um one-liner Perl que imprimirá uma lista dos módulos instalados:

perl -MExtUtils::Installed -MData::Dumper -e  'my ($inst) = ExtUtils::Installed->new(); print Dumper($inst->modules());'

Apenas certifique-se de que o Data :: Dumper esteja instalado.

cd /the/lib/dir/of/your/perl/installation
perldoc $(find . -name perllocal.pod)

Os usuários do Windows apenas fazem uma pesquisa no Windows Explorer para encontrá-lo.

Experimente "perldoc -l":

$ perldoc -l Log :: Dispatch /usr/local/share/perl/5.26.1/Log/Dispatch.pm

Ao inserir seu script Perl, você terá todos os módulos instalados como arquivos .pm abaixo das pastas em @INC, portanto, um pequeno script bash fará o trabalho para você:

#!/bin/bash

echo -e -n "Content-type: text/plain\n\n"

inc=`perl -e '$, = "\n"; print @INC;'`

for d in $inc
do
   find $d -name '*.pm'
done

Para Linux, a maneira mais fácil de obter é,

dpkg -l | grep "perl"

Isso funciona para mim

perl -e 'print join("\n",@INC,"")'

Isto é o que eu faço: perl -M{cpan_module}
Se você não receber nenhum erro, há uma boa chance de que o módulo esteja instalado.