Perl Critic
1.0.0
Perl :: Critic - Crítica do Código Fonte Perl para Best -Practices.
use Perl::Critic;
my $file = shift;
my $critic = Perl::Critic->new();
my @violations = $critic->critique($file);
print @violations;
Perl :: Critic é uma estrutura extensível para criar e aplicar padrões de codificação ao código -fonte Perl. Essencialmente, é um mecanismo estático de análise de código -fonte. Perl :: Critic é distribuído com vários módulos de política do Perl :: Critic :: Policy que tentam aplicar várias diretrizes de codificação. A maioria dos módulos de política é baseada no livro de Damian Conway , as melhores práticas Perl . No entanto, Perl :: Critic não se limita ao PBP e até apoiará políticas que contradizem Conway. Você pode ativar, desativar e personalizar essas políticas através da interface Perl :: Critic. Você também pode criar novos módulos de política adequados aos seus próprios gostos.
Para uma interface de linha de comando para Perl :: Critic, consulte a documentação para perlcritic. Se você deseja integrar o crítico Perl :: seu processo de construção, teste :: Perl :: Critic fornece uma interface adequada para programas de teste. Além disso, Test :: Perl :: Critic :: Progressive é útil para aplicar gradualmente os padrões de codificação ao código legado. Para a conveniência final (às custas de alguma flexibilidade), veja as críticas Pragma.
Se você quiser experimentar o Perl :: Critic sem instalar nada, há um serviço da Web disponível em http://perlcritic.com. O serviço da Web ainda não suporta todos os recursos de configuração disponíveis na API nativa Perl :: Critic, mas deve lhe dar uma boa idéia do que faz.
Além disso, o ActivePerl inclui uma interface gráfica muito lisa para o perl-crítico chamado perlcritic-gui . Você pode obter uma edição comunitária gratuita do ActivePerl em http://www.activestate.com.
Perl :: Critic roda em Perl de volta ao Perl 5.10.1. Ele se baseia no módulo PPI para fazer o trabalho pesado de analisar Perl.
O módulo Perl::Critic é considerado uma classe pública. Qualquer alteração em sua interface passará por um ciclo de depreciação.
new( [ -profile => $FILE, -severity => $N, -theme => $string, -include => @PATTERNS, -exclude => @PATTERNS, -top => $N, -only => $B, -profile-strictness => $PROFILE_STRICTNESS_{WARN|FATAL|QUIET}, -force => $B, -verbose => $N ], -color => $B, -pager => $string, -allow-unsafe => $B, -criticism-fatal => $B)
new()
Retorna uma referência a um novo objeto Perl :: Critic. A maioria dos argumentos é passada diretamente para o Perl :: Critic :: Config, mas eu os descrevi aqui também. O valor padrão para todos os argumentos pode ser definido no seu arquivo .perlcriticrc . Consulte a seção "Configuração" para obter mais informações sobre isso. Todos os argumentos são pares opcionais de valor-chave da seguinte forma:
-PROFILE é um caminho para um arquivo de configuração. Se $FILE não estiver definido, o Perl :: Critic :: Config tenta encontrar um arquivo de configuração .perlcriticrc no diretório atual e depois no seu diretório inicial. Como alternativa, você pode definir a variável de ambiente PERLCRITIC para apontar para um arquivo em outro local. Se um arquivo de configuração não puder ser encontrado ou se $FILE for uma string vazia, todas as políticas serão carregadas com sua configuração padrão. Consulte "Configuração" para obter mais informações.
-Severidade é o nível mínimo de gravidade. Somente módulos políticos que têm uma gravidade maior que $N serão aplicados. Os valores de gravidade são inteiros que variam de 1 (violações menos graves) a 5 (violações mais graves). O padrão é 5. Para um determinado -profile , diminuir a -severity geralmente revelará mais violações de políticas. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc . Os usuários podem redefinir o nível de gravidade para qualquer política em seu arquivo .perlcriticrc . Consulte "Configuração" para obter mais informações.
Se for difícil para você lembrar se a gravidade "5" é o nível mais ou menos restritivo, você pode usar um desses valores nomeados:
SEVERITY NAME ...is equivalent to... SEVERITY NUMBER
--------------------------------------------------------
-severity => 'gentle' -severity => 5
-severity => 'stern' -severity => 4
-severity => 'harsh' -severity => 3
-severity => 'cruel' -severity => 2
-severity => 'brutal' -severity => 1
Os nomes refletem o quão severamente o código é criticado: uma crítica gentle relata apenas as violações mais severas e assim por diante, até uma crítica brutal que relata até as violações mais menores.
-Meme é uma expressão especial que determina quais políticas aplicar com base em seus respectivos temas. Por exemplo, o seguinte carregaria apenas políticas que possuem um tema 'Bugs' e 'PBP':
my $critic = Perl::Critic->new( -theme => 'bugs && pbp' );
A menos que a opção -severity seja explicitamente fornecida, a configuração -theme silenciosamente faz com que a -severity seja definida como 1. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc . Consulte a seção "Temas da Política" para obter mais informações sobre temas.
-include é uma referência a uma lista de string @PATTERNS . Os módulos de política que correspondem a pelo menos um m/$PATTERN/ixms sempre serão carregados, independentemente de todas as outras configurações. Por exemplo:
my $critic = Perl::Critic->new(-include => ['layout'], -severity => 4);
Isso faria com que Perl :: crítico aplique todos os módulos de política CodeLayout::* , mesmo que eles tenham um nível de gravidade menor que 4. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc . Você também pode usar -include em conjunto com a opção -exclude . Observe que -exclude tem precedência sobre -include quando uma política corresponde a ambos os padrões.
-Exclude é uma referência a uma lista de string @PATTERNS . Os módulos de política que correspondem a pelo menos um m/$PATTERN/ixms não serão carregados, independentemente de todas as outras configurações. Por exemplo:
my $critic = Perl::Critic->new(-exclude => ['strict'], -severity => 1);
Isso faria com que Perl :: Crítico não aplique os módulos de política RequireUseStrict e ProhibitNoStrict , mesmo que eles tenham um nível de gravidade maior que 1. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc . Você também pode usar -exclude em conjunto com a opção -include . Observe que -exclude tem precedência sobre -include quando uma política corresponde a ambos os padrões.
-Single-Policy é um PATTERN de string. Apenas uma política que corresponde m/$PATTERN/ixms será usada. Políticas que não correspondem serão excluídas. Esta opção tem precedência sobre as opções -severity , -theme , -include , -exclude e -only . Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc .
-top é o número máximo de violações para retornar quando classificado por seus níveis de gravidade. Este deve ser um número inteiro positivo. Violações ainda são devolvidas na ordem em que ocorrem dentro do arquivo. A menos que a opção -severity seja explicitamente fornecida, a configuração -top silenciosamente faz com que a -severity seja definida como 1. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc .
-No é um valor booleano. Se definido como um valor verdadeiro, o crítico perl :: escolherá apenas de políticas mencionadas no perfil do usuário. Se definido como um valor falso (que é o padrão), o Perl :: Critic escolhe de todas as políticas que encontra em seu site. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc .
-Profile Strictness é um valor enumerado, um dos "$ perfil_strictness_warn" em perl :: crítico :: utils :: Constants (o padrão), "$ perfil_strictness_fatal" em perl :: critic :: utils :: constantes e "$ perfil. Se definido como "$ perfil_strictness_fatal" em perl :: crítico :: utils :: constantes, perl :: crítico fará com que certos avisos sobre os problemas encontrados em um .perlcriticrc ou arquivo especificado através da opção -Profile fatal. Por exemplo, o crítico de Perl :: normalmente warn apenas sobre perfis referentes a políticas inexistentes, mas esse valor torna essa situação fatal. Da mesma forma, "$ perfil_strictness_quiet" em perl :: crítico :: utils :: Constants faz Perl :: Crítico calar a boca sobre essas coisas.
-Force é um valor booleano que controla se Perl :: Critic observa as anotações mágicas "## no critic" em seu código. Se definido como um valor verdadeiro, o Perl :: Critic analisará todo o código. Se definido como um valor falso (que é o padrão) perl :: crítico ignorará o código que é marcado com essas anotações. Consulte "dobrando as regras" para obter mais informações. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc .
-Verbose pode ser um número inteiro positivo (de 1 a 11) ou uma especificação de formato literal. Veja Perl :: Critic :: Violation para uma explicação das especificações do formato. Você pode definir o valor padrão para esta opção no seu arquivo .perlcriticrc .
-UNSAVE direciona Perl :: Critic para permitir o uso de políticas marcadas como "inseguras" pelo autor. Tais políticas podem compilar código não confiável ou fazer outras coisas nefastas.
-Color e -Pager não são usados pelo Perl :: Critic, mas são fornecidos para o benefício do perlcrítico.
-Criticitic-Fatal não é usado por Perl :: Critic, mas é previsto para o benefício das críticas.
-Color-Severity-High-High , -Color-Severity-High-High , -Color-Severity-Medium , -Color-Severity-Low e -Color-Severity-Lowest não são usados por Perl :: Critic, mas são fornecidos para o benefício da perlcrítica. Cada um é definido como o termo :: especificação de cores Ansicolor a ser usada para exibir violações da gravidade correspondente.
-Files-with-violações e -files-without-violações não são usados pelo Perl :: Critic, mas são fornecidos para o benefício do perlcrítico, para fazer com que apenas os nomes de arquivos relevantes sejam exibidos.
critique( $source_code )
Executa o $source_code através do mecanismo Perl :: Critic usando todas as políticas que foram carregadas neste mecanismo. Se $source_code for uma referência escalar, ele será tratado como uma sequência de código PERL real. Se $source_code for uma referência a uma instância do documento PPI ::, essa instância será usada diretamente. Caso contrário, ele é tratado como um caminho para um arquivo local que contém código Perl. Este método retorna uma lista de objetos de perl :: crítico :: violação para cada violação das políticas carregadas. A lista é classificada na ordem em que as violações aparecem no código. Se não houver violações, esse método retornará uma lista vazia.
add_policy( -policy => $policy_name, -params => %param_hash )
Cria um objeto político e o carrega nesse crítico. Se o objeto não puder ser instanciado, ele lançará uma exceção fatal. Caso contrário, retorna uma referência a esse crítico.
-Policy é o nome de um módulo PERL :: Critic :: Policy Subclass. A parte 'Perl::Critic::Policy' do nome pode ser omitida por brevidade. Este argumento é necessário.
-Params é uma referência opcional a um hash de parâmetros políticos. O conteúdo desta referência de hash será passado para o construtor do módulo de política. Consulte a documentação no módulo de política relevante para obter uma descrição dos argumentos que ele suporta.
policies()
Retorna uma lista contendo referências a todos os objetos de política que foram carregados neste mecanismo. Os objetos estarão na ordem em que foram carregados.
config()
Retorna o objeto Perl :: Critic :: Config que foi criado ou dado a esse crítico.
statistics()
Retorna o objeto Perl :: Critic :: Statistics que foi criado para esse crítico. O objeto de estatística acumula dados para todos os arquivos que são analisados por esse crítico.
Para aquelas pessoas que preferem ter uma interface funcional, o método critique pode ser exportado mediante solicitação e chamado como uma função estática. Se o primeiro argumento é um hashref, seu conteúdo é usado para construir um novo objeto Perl :: Critic Internamente. As chaves desse hash devem ser as mesmas que as suportadas pelo método Perl::Critic::new() . Aqui estão alguns exemplos:
use Perl::Critic qw(critique);
# Use default parameters...
@violations = critique( $some_file );
# Use custom parameters...
@violations = critique( {-severity => 2}, $some_file );
# As a one-liner
%> perl -MPerl::Critic=critique -e 'print critique(shift)' some_file.pm
Atualmente, nenhum dos outros métodos de objetos é suportado como funções estáticas. Desculpe.
A maioria das configurações para Perl :: Critic e cada um dos módulos de política pode ser controlada por um arquivo de configuração. O arquivo de configuração padrão é chamado .perlcriticrc . Perl :: Critic procurará esse arquivo no diretório atual primeiro e depois no seu diretório inicial. Como alternativa, você pode definir a variável de ambiente PERLCRITIC para apontar explicitamente para um arquivo diferente em outro local. Se não houver nenhum desses arquivos e a opção -profile não for dada ao construtor, todos os módulos encontrados no espaço para nome de Policy Perl :: Critic :: Policy serão carregados com sua configuração padrão.
O formato do arquivo de configuração é uma série de blocos de estilo INI que contêm pares de valor-chave separados por '='. Os comentários devem começar com '#' e podem ser colocados em uma linha separada ou após os pares de nomes-valor, se desejar.
As configurações padrão para Perl :: o próprio crítico podem ser definidas antes do primeiro bloco nomeado. Por exemplo, colocar qualquer um ou todos eles na parte superior do seu arquivo de configuração definirá o valor padrão para o argumento do construtor correspondente.
severity = 3 #Integer or named level
only = 1 #Zero or One
force = 0 #Zero or One
verbose = 4 #Integer or format spec
top = 50 #A positive integer
theme = (pbp || security) && bugs #A theme expression
include = NamingConventions ClassHierarchies #Space-delimited list
exclude = Variables Modules::RequirePackage #Space-delimited list
criticism-fatal = 1 #Zero or One
color = 1 #Zero or One
allow-unsafe = 1 #Zero or One
pager = less #pager to pipe output to
O restante do arquivo de configuração é uma série de blocos como este:
[Perl::Critic::Policy::Category::PolicyName]
severity = 1
set_themes = foo bar
add_themes = baz
maximum_violations_per_document = 57
arg1 = value1
arg2 = value2
Perl::Critic::Policy::Category::PolicyName é o nome completo de um módulo que implementa a política. Os módulos políticos distribuídos com Perl :: Critic foram agrupados em categorias de acordo com o índice no livro de Damian Conway , as melhores práticas Perl . Para a brevidade, você pode omitir a parte 'Perl::Critic::Policy' do nome do módulo.
severity é o nível de importância que você deseja atribuir à política. Todos os módulos de política são definidos com um valor de gravidade padrão que varia de 1 (menos grave) a 5 (mais grave). No entanto, você pode discordar da severidade padrão e optar por dar uma gravidade mais alta ou menor, com base em sua própria filosofia de codificação. Você pode definir a severity para um número inteiro de 1 a 5 ou usar um dos nomes equivalentes:
SEVERITY NAME ...is equivalent to... SEVERITY NUMBER
----------------------------------------------------
gentle 5
stern 4
harsh 3
cruel 2
brutal 1
Os nomes refletem o quão severamente o código é criticado: uma crítica gentle relata apenas as violações mais severas e assim por diante, até uma crítica brutal que relata até as violações mais menores.
set_themes define o tema da política e substitui seu tema padrão. O argumento é uma sequência de um ou mais palavras alfanuméricas delimitadas em branco. Os temas são insensíveis ao caso. Consulte "Temas de Política" para obter mais informações.
add_themes anexa aos temas padrão para esta política. O argumento é uma sequência de uma ou mais palavras delimitadas por espaço em branco. Os temas são insensíveis ao caso. Consulte "Temas de Política" para obter mais informações.
maximum_violations_per_document LIMITES O número de violações que a política retornará para um determinado documento. Algumas políticas têm um limite padrão; Veja a documentação para as políticas individuais para ver se existe uma. Para forçar uma política a não ter um limite, especifique "no_limit" ou a sequência vazia para o valor desse parâmetro.
Os pares de valor-chave restantes são parâmetros de configuração que serão transmitidos para o construtor para essa política. Os construtores para a maioria dos objetos de política não suportam argumentos, e os que o fazem devem ter padrões razoáveis. Consulte a documentação sobre o módulo de política apropriado para obter mais detalhes.
Em vez de redefinir a gravidade de uma determinada política, você pode desativar completamente uma política precendendo um '-' para o nome do módulo em seu arquivo de configuração. Dessa maneira, a política nunca será carregada, independentemente da -severity dada ao construtor crítico perl ::.
Uma configuração simples pode ser assim:
#--------------------------------------------------------------
# I think these are really important, so always load them
[TestingAndDebugging::RequireUseStrict]
severity = 5
[TestingAndDebugging::RequireUseWarnings]
severity = 5
#--------------------------------------------------------------
# I think these are less important, so only load when asked
[Variables::ProhibitPackageVars]
severity = 2
[ControlStructures::ProhibitPostfixControls]
allow = if unless # My custom configuration
severity = cruel # Same as "severity = 2"
#--------------------------------------------------------------
# Give these policies a custom theme. I can activate just
# these policies by saying `perlcritic -theme larry`
[Modules::RequireFilenameMatchesPackage]
add_themes = larry
[TestingAndDebugging::RequireTestLabels]
add_themes = larry curly moe
#--------------------------------------------------------------
# I do not agree with these at all, so never load them
[-NamingConventions::Capitalization]
[-ValuesAndExpressions::ProhibitMagicNumbers]
#--------------------------------------------------------------
# For all other Policies, I accept the default severity,
# so no additional configuration is required for them.
Para exemplos de configuração adicionais, consulte o arquivo perlcriticrc , incluído neste diretório de examples dessa distribuição.
A configuração de Damian Conway Perl :: Critic também está incluída nesta distribuição como examples/perlcriticrc-conway .
Um grande número de módulos de política é distribuído com Perl :: Critic. Eles são descritos brevemente no documento complementar Perl :: Critic :: PolicySummary e em mais detalhes nos próprios módulos individuais. Diga "perlcritic -doc PATTERN" para ver o PerlDoc para todos os módulos de política que correspondem ao regex m/PATTERN/ixms
Existem várias distribuições de políticas adicionais na CPAN. Se Perl :: Critic não contiver uma política que você deseja, alguém já pode ter escrito. Veja a seção "Veja também" abaixo para obter uma lista de algumas dessas distribuições.
Cada política é definida com um ou mais "temas". Os temas podem ser usados para criar grupos arbitrários de políticas. Eles pretendem fornecer um mecanismo alternativo para selecionar seu conjunto preferido de políticas. Por exemplo, você pode desejar desativar um determinado subconjunto de políticas ao analisar programas de teste. Por outro lado, você pode permitir apenas um subconjunto específico de políticas ao analisar os módulos.
As políticas que enviam com Perl :: Critic foram divididas nos seguintes temas. Esta é apenas nossa tentativa de fornecer alguns agrupamentos lógicos básicos. Você é livre para inventar novos temas que atendam às suas necessidades.
THEME DESCRIPTION
--------------------------------------------------------------------------
core All policies that ship with Perl::Critic
pbp Policies that come directly from "Perl Best Practices"
bugs Policies that that prevent or reveal bugs
certrec Policies that CERT recommends
certrule Policies that CERT considers rules
maintenance Policies that affect the long-term health of the code
cosmetic Policies that only have a superficial effect
complexity Policies that specifically relate to code complexity
security Policies that relate to security issues
tests Policies that are specific to test programs
Qualquer política pode se encaixar em vários temas. Diga "perlcritic -list" para obter uma lista de todas as políticas disponíveis e os temas associados a cada um. Você também pode alterar o tema para qualquer política no seu arquivo .perlcriticrc . Consulte a seção "Configuração" para obter mais informações sobre isso.
Usando a opção -theme , você pode criar uma regra arbitrariamente complexa que determina quais políticas serão carregadas. A precedência é a mesma do código PERL regular e você pode usar parênteses para aplicar a precedência também. Os operadores suportados são:
Operator Alternative Example
-----------------------------------------------------------------
&& and 'pbp && core'
|| or 'pbp || (bugs && security)'
! not 'pbp && ! (portability || complexity)'
Os nomes dos temas são insensíveis a minúsculas. Se o -theme estiver definido como uma string vazia, ele avaliará como todas as políticas verdadeiras.
Perl :: Critic adota uma abordagem de linha dura para o seu código: você cumpre ou não. No mundo real, nem sempre é prático (nem possível) cumprir completamente os padrões de codificação. Nesses casos, é aconselhável mostrar que você está violando conscientemente os padrões e que tem um bom motivo (DGR) por fazê -lo.
Para ajudar nessas situações, você pode direcionar o crítico de Perl :: para ignorar certas linhas ou blocos de código usando anotações:
require 'LegacyLibaray1.pl'; ## no critic
require 'LegacyLibrary2.pl'; ## no critic
for my $element (@list) {
## no critic
$foo = ""; #Violates 'ProhibitEmptyQuotes'
$barf = bar() if $foo; #Violates 'ProhibitPostfixControls'
#Some more evil code...
## use critic
#Some good code...
do_something($_);
}
As anotações "## no critic" direcionam o crítico de perl :: para ignorar as linhas de código restantes até que uma anotação "## use critic" seja encontrada. Se a anotação "## no critic" estiver na mesma linha que uma instrução Code, apenas essa linha de código será ignorada. Para direcionar o perlcrítico para ignorar as anotações "## no critic" , use a opção --force .
Uma anotação nua "## no critic" desativa todas as políticas ativas. Se você deseja desativar apenas políticas específicas, adicione uma lista de nomes de políticas como argumentos, assim como faria com os Pragmas "no strict" ou "no warnings" . Por exemplo, isso desativaria as políticas ProhibitEmptyQuotes e ProhibitPostfixControls até o final do bloco ou até a próxima anotação "## use critic" (o que ocorrer primeiro):
## no critic (EmptyQuotes, PostfixControls)
# Now exempt from ValuesAndExpressions::ProhibitEmptyQuotes
$foo = "";
# Now exempt ControlStructures::ProhibitPostfixControls
$barf = bar() if $foo;
# Still subjected to ValuesAndExpression::RequireNumberSeparators
$long_int = 10000000000;
Como os nomes de políticas são comparados aos argumentos "## no critic" como expressões regulares, você pode abreviar os nomes de políticas ou desativar uma família inteira de políticas de uma só vez:
## no critic (NamingConventions)
# Now exempt from NamingConventions::Capitalization
my $camelHumpVar = 'foo';
# Now exempt from NamingConventions::Capitalization
sub camelHumpSub {}
A lista de argumentos deve ser fechada entre parênteses ou colchetes e deve conter uma ou mais palavras nuas separadas por vírgula (por exemplo, não use cotações). As anotações "## no critic" podem ser aninhadas, e as políticas nomeadas por uma anotação interna serão desativadas junto com aqueles já desativados uma anotação externa.
Algumas políticas como Subroutines::ProhibitExcessComplexity se aplicam a um bloco inteiro de código. Nesses casos, a anotação "## no critic" deve aparecer na linha em que a violação é relatada. Por exemplo:
sub complicated_function { ## no critic (ProhibitExcessComplexity)
# Your code here...
}
Políticas como Documentation::RequirePodSections se aplicam a todo o documento; nesse caso, as violações são relatadas na linha 1.
Use esse recurso com sabedoria. As anotações "## no critic" devem ser usadas no menor escopo possível, ou apenas em linhas de código individuais. E você deve sempre ser o mais específico possível sobre quais políticas deseja desativar (ou seja, nunca use um "## no critic" ). Se Perl :: Critic reclamar do seu código, tente encontrar uma solução compatível antes de recorrer a esse recurso.
Os padrões de codificação são profundamente pessoais e altamente subjetivos. O objetivo do Perl :: Critic é ajudá -lo a escrever código que se conforme com um conjunto de práticas recomendadas. Nosso objetivo principal não é ditar quais são essas práticas, mas sim implementar as práticas descobertas por outras pessoas. Por fim, você faz as regras - Perl :: Critic é apenas uma ferramenta para incentivar a consistência. Se houver uma política que você acha importante ou que tenhamos esquecido, ficaríamos muito gratos por contribuições ou você pode simplesmente carregar seu próprio conjunto privado de políticas no crítico de Perl ::.
O design modular de Perl :: Critic pretende facilitar a adição de novas políticas. Você precisará entender o PPI, mas a maioria dos módulos de política é bastante direta e exige apenas cerca de 20 linhas de código. Consulte o arquivo Perl :: Critic :: Developer incluído nesta distribuição para uma demonstração passo a passo de como criar novos módulos de política.
Se você desenvolver novos módulos de política, sinta -se à vontade para enviá -los para <[email protected]> e ficarei feliz em considerá -los na distribuição do Perl :: Critic. Ou, se você deseja trabalhar diretamente no projeto Perl :: Critic, pode gastar nosso repositório em https://github.com/perl-critic/perl-critic.git.
A equipe de Perl :: Critic também está disponível para alugar. Se sua organização tiver seus próprios padrões de codificação, podemos criar políticas personalizadas para fazer cumprir suas diretrizes locais. Ou se a sua base de código for propensa a um padrão de defeito específico, podemos projetar políticas que o ajudarão a pegar esses defeitos caros antes que eles entrem em produção. Para discutir suas necessidades com a equipe de Perl :: Critic, basta entrar em contato com <[email protected]> .
Perl :: Critic requer os seguintes módulos:
B :: Palavras -chave
Config :: Tiny
Exception :: Class
Arquivo :: Spec
Arquivo :: spec :: Unix
Arquivo :: qual
List :: SomeUtils
Lista :: Util
Módulo :: Classificado
Perl :: Tidy
Pod :: Spell
PPI
Pod :: Text simples
Pod :: select
Pod :: Uso
Readonly
Escalar :: util
String :: formato
Termo :: Ansicolor
Texto :: Parsewords
versão
Você é incentivado a se inscrever na lista de correspondência pública em https://groups.google.com/d/forum/perl-critic. Pelo menos um membro da equipe de desenvolvimento geralmente fica em Irc: //irc.perl.org/#perlcritic e você pode seguir o Perl :: Critic no Twitter, em https://twitter.com/perlcritic.
Existem várias distribuições de políticas adicionais disponíveis. Alguns estão listados aqui:
Perl :: crítico :: mais
Perl :: Critic :: Bangs
Perl :: Critic :: LAX
Perl :: crítico :: strictersubs
Perl :: Critic :: Swift
Perl :: Critic :: tics
Essas distribuições permitem que você use Perl :: Critic em seus testes de unidade:
Teste :: Perl :: Critic
Test :: Perl :: Critic :: Progressive
Há também uma distribuição que instalará todos os módulos relacionados ao crítico Perl :: conhecidos pela equipe de desenvolvimento:
Tarefa :: Perl :: Critic
Examinar o código Perl é difícil para os seres humanos, muito menos máquinas. Se você encontrar bugs, particularmente falsos positivos ou falsos negativos de uma política de crítica ::, envie-os em https://github.com/perl-critic/perl-critic/issues. Obrigado.
Adam Kennedy - para criar PPI, o coração e a alma de Perl :: Critic.
Damian Conway - Para escrever práticas recomendadas Perl , finalmente :)
Chris Dolan - por contribuir com os melhores recursos e módulos de política.
ANDY LESTER-Sábio sábio e mestre de todas as coisas.
Elliot Shank - A auto -proclamada Freak de qualidade.
Giuseppe Maxia - Para todas as grandes idéias e incentivo positivo.
E Sharon, minha esposa - por aguentar minhas sessões de código a noite toda.
Agradecemos também à Fundação Perl por fornecer uma doação para apoiar o projeto de Chris Dolan para implementar vinte políticas de PBP. http://www.perlfoundation.org/april_1_2007_new_grant_awards
Thanks also to this incomplete laundry list of folks who have contributed to Perl::Critic in some way: Gregory Oschwald, Mike O'Regan, Tom Hukins, Omer Gazit, Evan Zacks, Paul Howarth, Sawyer X, Christian Walde, Dave Rolsky, Jakub Wilk, Roy Ivy III, Oliver Trosien, Glenn Fowler, Matt Creenan, Alex Balhatchet, Sebastian Paaske Tørholm, Stuart A Johnston, Dan Book, Steven Humphrey, James Raspass, Nick Tonkin, Harrison Katz, Douglas Sims, Mark Fowler, Alan Berndt, Neil Bowers, Sergey Romanov, Gabor Szabo, Graham Knop, Mike Eldridge, David Steinbrunner, Kirk Kimmel, Guillaume Aubert, Dave Cross, Anirvan Chatterjee, Todd Rinaldo, Graham Ollis, Karen Etheridge, Jonas Brømsø, Olaf Alders, Jim Keenan, Slaven Rezić, Szymon Nieznański.
Jeffrey ryan thalhammer [email protected]
Copyright (C) 2005-2018 Sistemas de software imaginativos. Todos os direitos reservados.
Este programa é software livre; Você pode redistribuí -lo e/ou modificá -lo nos mesmos termos que o próprio Perl. O texto completo desta licença pode ser encontrado no arquivo de licença incluído neste módulo.
