CFLint
C
Uma ferramenta de análise de código estático para CFML.
Licença: BSD
Versão atual: 1.5.x
Consulte Changelog.md para obter mais informações.
O Cflint é um projeto desenvolvido e trabalhado por voluntários. Ao registrar problemas, seja legal e atencioso. Estamos aqui para ajudar. Nós realmente apreciamos correções e melhorias, portanto, fique à vontade para conversar conosco e/ou fornecer solicitações de tração.
/src/main contém o código -fonte. Os testes podem ser encontrados em /src/test . O Cflint depende muito do projeto CFPARSER, bem como em um monte de bibliotecas Java de terceiros.
A filial principal é considerada nossa base de código estável. A maior parte do desenvolvimento acontece no ramo dev respectivamente. ramos de desenvolvimento local para questões específicas.
Fire o repositório em sua conta e clone ou faça o download da base de código como um arquivo zip.
Instale a ferramenta de sua escolha e construa via gradle ou maven (descontinuado). Cflint requer Java 8.
um. Gradle: execute
gradlew build
No diretório Cflint
b. Maven: execute
mvn clean install
No diretório Cflint
Como alternativa, importe a base de código CFLINT para o IDE de sua escolha e use sua integração gradle/maven, respectivamente. Isso deve funcionar fora da caixa para usuários do Eclipse e Intellij.
Obtenha a versão mais recente do Maven Central ou da página de lançamento do Cflint Github ou crie o projeto.
Se você deseja usar o CFLINT de outro projeto Maven, use:
< dependency >
< groupId >com.github.cflint</ groupId >
< artifactId >CFLint</ artifactId >
< version >1.4.0</ version >
</ dependency >Ou sempre use o mais recente:
< dependency >
< groupId >com.github.cflint</ groupId >
< artifactId >CFLint</ artifactId >
< version >LATEST</ version >
</ dependency >Com os binários recuperados de uma ou outra maneira, agora você pode usar o CFLINT na linha de comando.
CFLint-1.5.0-all.jar
java -jar CFLint-1.5.0-all.jar -folder <baseFolder>
java -jar CFLint-1.5.0-all.jar -file <fullPathToFile>
java -jar CFLint-1.5.0-all.jar -help
Nota: Este é um trabalho em andamento, atualmente estamos colando informações de várias fontes.
As opções mais simples para a execução do CFLINT são através da linha de comando. Atualmente, o CFLINT possui um modo de interface do usuário (acionado por -ui na linha de comando) que será removido pelo mais recente do CFLINT 2.0 - consulte a edição #316. Se você confiar no modo da interface do usuário, infelizmente está por conta própria - não há mais trabalho nisso a partir daqui.
Como alternativa para a linha de comando, você pode colocar arquivos .cflintrc em determinados diretórios. Configurando o CFLint dessa maneira conceitualmente permite executar regras específicas em partes específicas do seu aplicativo.
Atualmente, o CFLINT suporta configuração baseada em JSON e XML. A configuração baseada em XML é depreciada no CFLINT 1.3.0 e será removida no CFLINT 2.0.
Quando o CFLINT é executado, ele digitaliza e analisa seu código (usando o CFPARSER). A árvore de sintaxe está sendo examinada contra um conjunto de regras internas.
No CFLINT, essas regras são chamadas e implementadas como plugins (elas vivem em /src/main/java/com/cflint/plugins ). Por padrão, todas as regras serão usadas na sua base de código. É isso que muitas pessoas farão, mas o uso da configuração permite criar um cenário personalizado para testar seu código. Consulte Regras.md para obter mais informações sobre regras e seu significado.
O CFLINT é opinativo e todo lançamento após o 1.3.0 nunca escaneará em diretórios que começam com a . Para evitar o desperdício de tempo de diretórios ocultos, como configuração de construção, armazenamento de módulos/bibliotecas ou informações de controle de versão.
O arquivo de configuração padrão e global é /src/main/resources/cflint.definition.json . O uso comum do CFLINT geralmente não requer substituição deste arquivo.
Colocar um arquivo .cflintrc em um diretório permite especificar certas regras que devem ser executadas para este diretório e seus filhos. Além disso, você pode especificar um punhado de outras propriedades.
Um exemplo de arquivo .cflintrc é mostrado abaixo:
{
"rule" : [ ],
"excludes" : [ ],
"includes" : [ {
"code" : " FUNCTION_HINT_MISSING "
} ],
"inheritParent" : false ,
"parameters" : { }
} rule permite adicionar um plug -in para esta pasta que não está listada na configuração global. Consulte ruleImpl em cflint.definition.json para exemplos.
excludes e includes permitir que você especifique uma variedade de objetos que descrevem regras que você deseja ser aplicado para este diretório e seus filhos. No exemplo acima, a única regra a ser verificada será function_hint_missing.
inheritParent Configura se as regras definidas na configuração global ou pai deverão ser herdadas como um conjunto de regras básicas.
parameters permitem a configuração das regras. Consulte Regras.md para os parâmetros de cada regra e seus padrões. Você deve preceder o nome do parâmetro com o nome da regra separado por um ponto.
Observação: inheritPlugins e output foram marcados deprimidos no CFLINT 1.2.0 e removidos em 1.4.0. A herança do plug -in agora é sempre tratada como verdadeira, pois a equipe não pode ver um caso de uso no qual deve ser desativado. O tipo de saída pode ser controlado em outros lugares, como sinalizadores de linha de comando.
Fornecemos um esquema com as propriedades depreciadas excluídas.
Consulte Receitas para alguns exemplos de uso de .cflintrc . Os arquivos de exemplo podem ser encontrados navegando nos arquivos de teste do projeto.
Muitas vezes, existem cenários em que você geralmente deseja executar um certo conjunto de regras em relação ao seu código, mas em casos específicos precisam ignorar uma violação válida.
Um exemplo comum são violações do CFQUERYPARAM_REQ que não podem ser corrigidas aplicando <cfqueryparam> porque o servidor de banco de dados não permite params em determinadas posições (por exemplo, em uma SELECT something FROM #application.config.linkedServerName#.DefaultDatabase.dbo.Comment cenário). Veja a edição nº 282 para mais exemplos.
O CFLINT oferece uma configuração baseada em anotação para lidar com este e cenários similares. As anotações podem ser colocadas no nível de componente ou função em um CFC ou embutido com código.
<!---
@CFLintIgnore SOMETHINGELSE,MISSING_VAR,ANOTHERTHINGTOIGNORE
--->
Ignorando todas as regras na linha atual:
//cflint ignore:line
Ignorando uma regra específica (ou uma lista de regras separada por vírgula) na linha atual:
//cflint ignore:MISSING_VAR
Anotação de ignorar multilina:
/*
@CFLintIgnore SOMETHINGELSE,MISSING_VAR,ANOTHERTHINGTOIGNORE
*/
No SQL, você também pode usar
<!--- @CFLintIgnore CFQUERYPARAM_REQ --->
ignorar uma violação de regra na próxima linha.
A configuração da qual os plugins são executados e quais regras são incluídas inicia com a configuração global e flui através dos parâmetros da linha de comando, regras do nível da pasta e até as anotações dentro da fonte.
-configfile , não incentivamos essa opção a ser usada nas operações diárias do CFLINT)-rulegroups , comportamento padrão é - -RuleGroups! Experimental)-includeRule e -excludeRule )A regra de configuração mais próxima da regra é a que entra em vigor.
.cflintrc a adicionará, ela disparará para arquivos de origem nessa parte da árvore de origem.-includeRule "MISSING_VAR,CFQUERYPARAM_REQ" O CFLINT suporta uma variedade de opções de relatórios e saída que você pode controlar via sinalizadores da linha de comando. Além dos formatos de saída de texto direcionados, XML, JSON ou HTML Você também pode executar o CFLINT com opções para saída silenciosa, detalhada e depurada.
Se nenhum formato de saída segmentado for especificado, o CFLINT padrão é a criação de um relatório HTML no arquivo cflint-result.html .
Você pode forçar o comportamento de saída do CFLINT para Stdout e Stderr, especificando opções para silencioso, detalhado e depuração. Se você também não especificar, o CFLINT retornará informações internas básicas e saída de erros ao stdout e STDERR.
O modo silencioso ( -quiet <boolean> ) suprime a maior parte da saída que o CFLINT criaria durante o revestimento. Isso pode conter erros e exceções reais, mas também informações como o término da análise de modelo recursivo ou determinados problemas de configuração. Não execute o modo silencioso se você provavelmente precisará de assistência com mensagens de erro ou quiser entender melhor o que o CFLINT está fazendo.
Este é o modo de saída mínimo em que você pode executar o CFLINT e o recurso foi originalmente inspirado na edição nº 4.
Pode haver mensagens ocasionais do CFPARSER e do ANTLR sendo empurradas para o Stderr nesta fase - mesmo que o CFLINT funcione no modo silencioso. Este é um problema conhecido e será abordado no futuro.
Modo verbose ( -verbose <boolean> ) Ativa a saída de linha detalhada. Isso contém informações sobre formatos de saída selecionados e arquivos de configuração que estão sendo encontrados e processos durante o linhagem, bem como o arquivo atualmente processado, está funcionando (mostrando apenas arquivos que são realmente digitalizados).
Se você deseja mais informações sobre o funcionamento interno do CFLINT durante a execução, o modo detalhado é o mínimo em que você deve executar o CFLINT.
Modo de depuração ( -debug <boolean> ) Ativa a saída de depuração. O modo de depuração implica no modo detalhado, mas adiciona informações adicionais, como os tokens de analisador e todos os arquivos processados (independentemente de serem suportados pela sua lista de extensão padrão) nos fluxos de saída.
É possível ligar e executar modos silenciosos, detalhados e de depuração juntos ao mesmo tempo. Isso se destina parcialmente, pois você pode não querer ver as informações de erro sendo suprimidas pelo modo silencioso, mas ainda querem, portanto, consulte certas informações sendo mostradas no modo detalhado. Por favor, pegue esse comportamento com um grão de sal -pode haver o cenário ímpar em que a combinação -quiet , -verbose e -debug causa saída incomum.
A exceção é o modo de depuração. No modo de depuração, o CFLINT sempre ignorará as configurações do usuário para verboso e silencioso e definir verbose como true e quiet a false .
O sinalizador -html instrui o cflint a criar um documento HTML. A sintaxe completa é:
-html -html <outputFileName>
O sinalizador -xml instrui o cflint a criar XML. Existem duas opções para relatórios XML.
A primeira opção é o que chamamos de Cflint XML. É um formato interno que segue um esquema básico fornecido aqui. Você pode usar este formato como está ou fazer um processamento adicional de sua escolha.
A segunda opção é o FindBugs XML. O documento XML resultante adere à versão atual da definição do FindBugs BugCollection XML Schema e pode ser usado na maioria dos produtos Ci-/Build-Server. O JetBrains TeamCity 10+ pode importar esse formato para fora da caixa.
Observação : atualmente não é possível produzir os dois sabores dos relatórios XML ao mesmo tempo. Esta é uma limitação conhecida. Essa limitação será removida como parte do CFLINT 2.0 (consulte a edição nº 331).
Para criar o Cflint XML, forneça os seguintes argumentos da linha de comando:
-xml -xmlstyle cflint -xmlfile <outputFileName>
Exemplo de Cflint XML:
<? xml version = " 1.0 " encoding = " UTF-8 " ?>
< issues version = " 1.2.1 " timestamp = " 1500107134 " >
< issue severity = " WARNING " id = " CFQUERYPARAM_REQ " message = " CFQUERYPARAM_REQ " category = " CFLint " abbrev = " CR " >
< location file = " /Users/kai/Documents/Code/paypal.cfc " fileName = " paypal.cfc " function = " doSomething " column = " 0 " line = " 325 " message = " < cfquery > should use < cfqueryparam/ > for variable 'arguments.PaymentType'. " variable = " arguments.PaymentType " >
< Expression > <![CDATA[ <cfquery name="doPayment" datasource="#paymentDatasource#">...some more Details... ]]> </ Expression >
</ location >
</ issue >
< issue severity = " WARNING " id = " CFQUERYPARAM_REQ " message = " CFQUERYPARAM_REQ " category = " CFLint " abbrev = " CR " >
< location file = " /Users/kai/Documents/Code/paypal.cfc " fileName = " paypal.cfc " function = " doSomethingElse " column = " 0 " line = " 432 " message = " < cfquery > should use < cfqueryparam/ > for variable 'arguments.something'. " variable = " arguments.something " >
< Expression > <![CDATA[ <cfquery name="doPayment" datasource="#paymentDatasource#">...some more Details... ]]> </ Expression >
</ location >
</ issue >
...
< counts totalfiles = " 108 " totallines = " 55596 " >
< count code = " CFQUERYPARAM_REQ " count = " 39 " ></ count >
< count severity = " WARNING " count = " 39 " ></ count >
</ counts >
</ issues >Para criar o FindBugs XML, forneça os seguintes argumentos da linha de comando:
-xml -xmlstyle findbugs -xmlfile <outputFileName>
O formato FindBugs XML é atualmente criado usando um documento XSLT, transformando o relatório do CFLINT para FindBugs XML ( /src/main/resources/findbugs/cflint-to-findbugs.xsl ).
A saída JSON pode ser criada com
-json -jsonfile <outputFileName>
Exemplo de Cflint JSON:
{
"version" : " 1.2.1 " ,
"timestamp" : 1501202128 ,
"issues" : [ {
"severity" : " ERROR " ,
"id" : " MISSING_VAR " ,
"message" : " MISSING_VAR " ,
"category" : " CFLINT " ,
"abbrev" : " MV " ,
"locations" : [ {
"file" : " src/test/resources/com/cflint/tests/Ignores/ignoreCFMLAny2.cfc " ,
"fileName" : " ignoreCFMLAny2.cfc " ,
"function" : " testFunction " ,
"column" : 6 ,
"line" : 14 ,
"message" : " Variable someVar is not declared with a var statement. " ,
"variable" : " someVar " ,
"expression" : " someVar "
} ]
} ],
"counts" : {
"totalFiles" : 7 ,
"totalLines" : 49 ,
"countByCode" : [ {
"code" : " MISSING_VAR " ,
"count" : 1
} ],
"countBySeverity" : [ {
"severity" : " ERROR " ,
"count" : 1
} ]
}
}O esquema JSON está disponível aqui.
A saída de texto simples pode ser criada com
-text -textfile <outputFileName>
Exemplo de saída de texto simples:
Issue
Severity:WARNING
Message code:CFQUERYPARAM_REQ
File:/Users/kai/Documents/Code/paypal.cfc
Column:0
Line:79
Message:<cfquery> should use <cfqueryparam/> for variable 'arguments.something'.
Variable:'arguments.something' in function:
Expression:<cfquery name="qry" datasource="#variables.dsn#" cachedwithin="#createTimeSpan(0,0,arguments.cacheInMins,0)#">rn...some Details...
Severity:WARNING
Message code:CFQUERYPARAM_REQ
File:/Users/kai/Documents/Code/paypal.cfc
Column:0
Line:145
Message:<cfquery> should use <cfqueryparam/> for variable 'arguments.something'.
Variable:'arguments.something' in function:
Expression:<cfquery name="qry" datasource="#variables.dsn#" cachedwithin="#createTimeSpan(0,0,arguments.cacheInMins,0)#">rn...some Details...
...
Total files:108
Total lines:55690
Issue counts:1
CFQUERYPARAM_REQ:4
Total issues:4
Total warnings:4
Para interagir diretamente com o CFLINT dentro da JVM, use a API CFLINT.
import com . cflint . api . CFLintAPI ;
import com . cflint . api . CFLintResult ;
CFLintAPI api = new CFLintAPI ();
CFLintResult result = api . scan ( filename );
String jsonResult = result . getJSON ();Para Jenkins , veja o plugin Jenkins/Hudson mencionado mais adiante.
O TeamCity da JetBrains tem suporte para os relatórios de inspeção de código XML do FindBugs. Eles podem ser produzidos para fora da caixa com CFLINT a partir de 1.2.0 (veja acima na seção FindBugs XML).
Há apoio ao Sonarqube através do plug -in ColdFusion do STEPStone mencionado mais adiante.
Para o Azure DevOps/TFs , consulte a extensão do Build Azure Pipeline/TFS mencionada mais adiante.
Há um invólucro npm para o CFLINT abaixo. Esteja ciente de que o invólucro parece vir com seu próprio binário CFLINT, que pode não estar atualizado, que está fora do nosso controle.
Outros produtos na categoria de integração/servidor de construção também podem funcionar. Se você estiver usando um produto específico que funcione para você com o CFLINT, informe -nos. Se você não conseguir fazer com que o CFLINT funcione em um ambiente que você usa, informe -nos também - podemos ajudar.
Existem várias integrações de IDE para o CFLINT que estão disponíveis. Abaixo estão algumas breves descrições, mas se você quiser saber mais, consulte projetos interessantes de terceiros.
Há suporte IDE para o Sublime Text 3 através de um projeto de terceiros utilizando o sublimelinter.
Também há suporte para o Adobe Coldfusion Builder por meio de um projeto de terceiros. Usuários do CFBuilder, consulte também a discussão na edição #327.
Os usuários do Atom podem se integrar via AtomLiner através de um projeto de terceiros.
Uma extensão para o código do Visual Studio também está disponível como um projeto de terceiros.
O suporte ao Intellij, do JetBrains, está disponível como plug-in de terceiros.
package com . cflint . plugins . core ;
import net . htmlparser . jericho . Element ;
import cfml . parsing . cfscript . script . CFFuncDeclStatement ;
import cfml . parsing . cfscript . script . CFFunctionParameter ;
import cfml . parsing . cfscript . script . CFScriptStatement ;
import com . cflint . BugList ;
import com . cflint . plugins . CFLintScannerAdapter ;
import com . cflint . plugins . Context ;
import com . cflint . tools . CFTool ;
public class ArgDefChecker extends CFLintScannerAdapter {
@ Override
public void expression ( final CFScriptStatement expression , final Context context , final BugList bugs ) {
if ( expression instanceof CFFuncDeclStatement ) {
final CFFuncDeclStatement function = ( CFFuncDeclStatement ) expression ;
for ( final CFFunctionParameter argument : function . getFormals ()) {
// handler.addArgument(param.getName());
final String name = argument . getName ();
if (! argument . toString (). contains ( "required" ) && ! argument . toString (). contains ( "=" )) {
function . getLine ();
function . getColumn ();
context . addMessage ( "ARG_DEFAULT_MISSING" , name );
}
}
}
}
@ Override
public void element ( final Element element , final Context context , final BugList bugs ) {
if ( element . getName (). equals ( "cfargument" )) {
final String name = element . getAttributeValue ( "name" );
final boolean required = CFTool . toBoolean ( element . getAttributeValue ( "required" ));
final String defaultExpr = element . getAttributeValue ( "default" );
if (! required && defaultExpr == null ) {
element . getSource (). getRow ( element . getBegin ());
element . getSource (). getColumn ( element . getBegin ());
context . addMessage ( "ARG_DEFAULT_MISSING" , name );
}
}
}
} Olhando para o element de função, os argumentos são:
element - a tag CFML atualcontext - o arquivo atual que está sendo verificadobugs - o objeto anexado de violações A maneira mais fácil de conseguir isso é com um arquivo .cflintrc personalizado:
O campo includes é ignorado se for uma lista vazia; portanto, basta adicionar um único item para o qual nada corresponde.
{
"code" : " NOTHING "
}ou mais simplesmente:
{}O seguinte ignorará todas as regras na pasta atual e abaixo.
{
"rule" : [ ],
"excludes" : [ ],
"includes" : [ {} ],
"inheritParent" : false ,
"parameters" : {}
} Isso pode ser simplificado usando os valores padrão de um arquivo .cflintrc :
{
"includes" : [{}],
"inheritParent" : false
}Veja a discussão na edição nº 290 para obter mais informações.
Os parâmetros dentro das regras podem ser substituídos nos arquivos .cflintrc . Use o nome da regra e o parâmetro unido com um ponto.
{
"parameters" : {
"VariableNameChecker.maxLength" : " 15 "
}
} Forneça um arquivo cflintexclude.json na linha de comando com o argumento -filterfile.
Para filtrar as mensagens global_var na pasta "Alguns package location", adicione o seguinte ao cflintexclude.json
[
other exclude rules...,
{"file":".*some\\package\\location\\.*","code":"GLOBAL_VAR"}
]
NOTA: As barras traseiras devem ser escapadas duas vezes, uma vez para JSON, uma vez para expressões regulares
[
other exclude rules...,
{"file":".*some/package/location/.*","code":"GLOBAL_VAR"}
]
Levante questões aqui no Github e vamos olhar para eles.
A equipe do CFML Slack possui um canal #cflint que você pode participar e conversar com a maioria dos colaboradores regulares e outros usuários.
Consulte Contribuindo.md para obter mais informações.
Observe que a maioria das bibliotecas e projetos mencionados aqui não está diretamente relacionada e mantida pela equipe do CFLINT. Consulte os autores e mantenedores do respectivo projeto para obter suporte usando suas bibliotecas primeiro.
Se você está trabalhando (ou está pensando em começar) um projeto relacionado ao CFLINT, informe -nos. Estamos felizes em incluir projetos de terceiros relevantes na lista acima.
