luacheck - En ligne dans le Cloud

PROGRAMME:

Nom

luacheck - Documentation luacheck

Contenu:

LISTE OF MISES EN GARDE

Les avertissements produits par Luacheck sont catégorisés à l'aide de codes d'avertissement à trois chiffres. Avertissement
les codes peuvent être affichés dans la sortie CLI en utilisant --codes option CLI ou codes option de configuration.
Les erreurs ont également des codes commençant par zéro.

??
Code │ Description │
??
│011 │ Une erreur de syntaxe. ??
??
│021 │ Une option en ligne non valide. ??
??
│022 │ Un push inline upaired │
│ directive. ??
??
│023 │ Une directive pop upaired inline. ??
??
│111 │ Définir un global non défini │
│ variable. ??
??
│112 │ Mutation d'un global indéfini │
│ variable. ??
??
│113 │ Accéder à un global non défini │
│ variable. ??
??
│121 │ Définition d'un global en lecture seule │
│ variable. ??
??
│122 │ Mutation d'un global en lecture seule │
│ variable. ??
??
│131 │ Global défini implicitement non utilisé │
│ variable. ??
??
│211 │ Variable locale inutilisée. ??
??
│212 │ Argument non utilisé. ??
??
│213 │ Variable de boucle inutilisée. ??
??
│221 │ La variable locale est accédée mais │
│ │ jamais défini. ??
??
│231 │ La variable locale est définie mais jamais │
│ │ accédé. ??
??
│232 │ Un argument est défini mais jamais │
│ │ accédé. ??
??
│233 │ La variable de boucle est définie mais jamais │
│ │ accédé. ??
??
│311 │ Valeur attribuée à un local │
La variable │ │ n'est pas utilisée. ??
??

│312 │ La valeur d'un argument n'est pas utilisée. ??
??
│313 │ La valeur d'une variable de boucle est │
│ │ inutilisé. ??
??
│321 │ Accès local non initialisé │
│ variable. ??
??
│411 │ Redéfinir une variable locale. ??
??
│412 │ Redéfinir un argument. ??
??
│413 │ Redéfinir une variable de boucle. ??
??
│421 │ Ombrer une variable locale. ??
??
│422 Ombrer un argument. ??
??
│423 │ Ombrage d'une variable de boucle. ??
??
│431 │ Ombrage d'une valeur supérieure. ??
??
│432 │ Ombrer un argument de valeur supérieure. ??
??
│433 │ Ombrage d'une boucle de valeur supérieure │
│ variable. ??
??
│511 │ Code inaccessible. ??
??
│512 │ La boucle peut être exécutée au maximum │
│ une fois. ??
??
│521 │ Étiquette non utilisée. ??
??
│531 │ Partie gauche d'un devoir │
│ │ est trop court. ??
??
│532 │ Partie gauche d'un devoir │
│ est trop long. ??
??
│541 │ Un vide do fin bloquer. ??
??
│542 │ Un vide if branche. ??
??
│551 │ Une instruction vide. ??
??

Global les variables
Pour chaque fichier, Luacheck construit une liste de globals définis qui peuvent y être utilisés. Par défaut
seuls les globals de la bibliothèque standard Lua sont définis ; des globals personnalisés peuvent être ajoutés en utilisant
--globaux option CLI ou globals option de configuration, et la version de la bibliothèque standard peut être
sélectionné à l'aide --std option CLI ou std option de configuration. Lorsqu'un global non défini est défini,
muté ou accédé, Luacheck produit un avertissement.

Lecture seule globals
Par défaut, tous les globals standard sauf _G et paquet sont marqués comme en lecture seule, de sorte que
leur définition ou leur mutation génère un avertissement. Des globals personnalisés en lecture seule peuvent être ajoutés en utilisant
--read-globales option CLI ou read_globals option de configuration.

Implicitement défini globals
Luacheck peut être configuré pour considérer les globals assignés dans certaines conditions comme étant
défini implicitement. Lorsque -d/--allow_défini option CLI ou autoriser_défini l'option de configuration est
utilisé, toutes les affectations aux globals les définissent ; lorsque -t/--allow_défini_top option CLI ou
allow_défini_top l'option de configuration est utilisée, les affectations aux globals dans la fonction de niveau supérieur
scope (également connu sous le nom de morceau principal) les définit. Un avertissement est généré lorsqu'un
défini global n'est accessible nulle part.

formation vidéo
Les fichiers peuvent être marqués comme modules en utilisant -m/--module option CLI ou module option de configuration à
simuler la sémantique de l'obsolète module fonction. Globals définis implicitement à l'intérieur d'un
module sont considérés comme faisant partie de son interface, ne sont pas visibles à l'extérieur et ne sont pas signalés
comme inutilisé. Les affectations à d'autres globales ne sont pas autorisées, même à celles définies.

Inutilisé les variables et valeurs
Luacheck génère des avertissements pour toutes les variables locales inutilisées sauf une nommée _. Elle
détecte les variables qui sont définies mais jamais accédées ou accédées mais jamais définies.

Inutilisé valeurs et non initialisé les variables
Pour chaque valeur affectée à une variable locale, Luacheck calcule un ensemble d'expressions où il
peut être utilisé. Des avertissements sont générés pour les valeurs inutilisées (quand une valeur ne peut pas être utilisée
n'importe où) et pour accéder à des variables non initialisées (quand aucune valeur ne peut atteindre un
expression). Par exemple, dans la valeur d'extrait suivante attribuée à foo sur la ligne 1 est inutilisé, et
variable Bar n'est pas initialisé à la ligne 9 :

truc local = expr1()
bar local

si condition() alors
truc = expr2()
barre = expr3()
d'autre
truc = expr4()
imprimer (barre)
fin

retour foo, bar

Secondaire valeurs et les variables
La valeur inutilisée affectée à une variable locale est secondaire si son origine est le dernier élément sur
le RHS d'affectation, et une autre valeur de cet élément est utilisée. Valeurs secondaires
apparaissent généralement lorsque le résultat d'un appel de fonction est mis dans les locaux, et seulement certains d'entre eux
sont ensuite utilisés. Par exemple, ici la valeur attribuée à b est secondaire, valeur attribuée à c is
utilisé et la valeur attribuée à a est tout simplement inutilisé :

locale a, b, c = f(), g()

retour c

Une variable est secondaire si toutes les valeurs qui lui sont affectées sont secondaires. Dans l'extrait ci-dessus,
b est une variable secondaire.

Les avertissements liés aux valeurs secondaires et aux variables inutilisées peuvent être supprimés à l'aide de
-s/--pas de secondaires inutilisés option CLI ou secondaires_inutilisés option de configuration.

Ombre déclarations
Luacheck détecte les déclarations de variables locales occultant les déclarations précédentes, à moins que
la variable est nommée _. Si la déclaration précédente est dans le même périmètre que la nouvelle,
cela s'appelle redéfinir.

Notez que c'est pas nécessaire de définir une nouvelle variable locale lors de l'écrasement d'un argument :

fonction locale f(x)
local x = x ou "default" -- mauvais
fin

fonction locale f(x)
x = x ou "par défaut" -- bien
fin

Contrôle flux et données, flux vous aider à faire face aux problèmes qui vous perturbent
Les problèmes de flux de contrôle et de flux de données suivants sont détectés :

· Code et boucles inaccessibles qui peuvent être exécutés au plus une fois (par exemple en raison d'un
pause inconditionnelle);

· Étiquettes non utilisées ;

· Affectations déséquilibrées ;

· Blocs vides.

· Instructions vides (points-virgules sans instructions précédentes).

COMMAND LINE INTERFACE

lucheck programme accepte les fichiers, répertoires et rockspec comme arguments.

· Étant donné un dossier, lucheck va le vérifier.

· Étant donné -, lucheck vérifiera stdin.

· Étant donné un annuaire, lucheck vérifiera tous les fichiers qu'il contient, en sélectionnant uniquement les fichiers avec
.lune prolongation à moins que --include-fichiers option est utilisée. Cette fonctionnalité nécessite
Système de fichiers Lua (installé automatiquement si LuaRocks a été utilisé pour installer Luacheck).

· Étant donné un rockspec (un fichier avec .rockspec extension), lucheck vérifiera tous les fichiers avec
.lune extension mentionnée dans le rockspec dans build.install.lua, build.install.bin et
build.modules les tables.

La sortie de lucheck se compose de rapports séparés pour chaque fichier vérifié et se termine par un
sommaire:

$luacheck src
Vérification des avertissements src/bad_code.lua 5

src/bad_code.lua:3:16 : assistant de variable inutilisé
src/bad_code.lua:3:23 : argument de longueur variable inutilisé
src/bad_code.lua:7:10 : définition de la variable globale non standard embrasser
src/bad_code.lua:8:10 : la variable opt était précédemment définie comme argument à la ligne 7
src/bad_code.lua:9:11 : accès à une variable non définie hepler

Vérification de src/good_code.lua OK
Vérification de l'erreur src/python_code.lua 1

src/python_code.lua:1:6 : attendu '=' près de '__future__'

Vérification des avertissements src/unused_code.lua 9

src/unused_code.lua:3:18 : baz d'argument inutilisé
src/unused_code.lua:4:8 : variable de boucle inutilisée i
src/unused_code.lua:5:13 : variable inutilisée q
src/unused_code.lua:7:11 : variable de boucle inutilisée a
src/unused_code.lua:7:14 : variable de boucle inutilisée b
src/unused_code.lua:7:17 : variable de boucle inutilisée c
src/unused_code.lua:13:7 : la valeur affectée à la variable x est inutilisée
src/unused_code.lua:14:1 : la valeur affectée à la variable x est inutilisée
src/unused_code.lua:22:1 : la valeur affectée à la variable z est inutilisée

Total : 14 avertissements / 1 erreur dans 4 fichiers

lucheck sort avec 0 si aucun avertissement ou erreur ne s'est produit et avec un nombre positif
autrement.

Command en ligne Options
Les options courtes qui ne prennent pas d'argument peuvent être combinées en une seule, de sorte que -qqu is
équivalente à -q -q -u. Pour les options longues, les deux --option Plus-value or --option=valeur peuvent être
utilisé.

Les options prenant plusieurs arguments peuvent être utilisées plusieurs fois ; --ignorer foo --ignorer Bar is
équivalente à --ignorer foo Bar.

Notez que les options qui peuvent prendre plusieurs arguments, telles que --globaux, ne doit pas être utilisé
immédiatement avant les arguments positionnels ; étant donné --globaux foo Bar fichier.lua, lucheck seront
considérer tout foo, Bar et fichier.lua global puis panique car il n'y a plus de noms de fichiers.

?? ??
Option │ Signification │
?? ??
│-g | --non-global Filtrez les avertissements liés à │
│ variables globales. ??
?? ??
│-u | --no-inutilisé Filtrez les avertissements liés à │
│ │ variables et valeurs inutilisées. ??
?? ??
│-r | --no-redéfini Filtrez les avertissements liés à │
│ │ variables redéfinies. ??
?? ??
│-a | --pas d'arguments inutilisés Filtrez les avertissements liés à │
│ │ arguments et boucle inutilisés │
│ variables. ??
?? ??
│-s | --pas de secondaires inutilisés Filtrez les avertissements liés à │
│ │ variables inutilisées réunies │
│ avec ceux d'occasion. ??
│ │
│ │ Voir valeurs et variables secondaires │
?? ??
│--non-soi Filtrez les avertissements liés à │
│ implicite soi argument. ??
?? ??

│--std Définir des globales standard. peut
│ être l'un des : │
│ │
│ · _G - les globales des Lua │
│ interprète lucheck │
│ │ s'exécute (par défaut) ; ??
│ │
│ · Lua51 - globals de Lua │
│ 5.1 ; ??
│ │
│ · Lua52 - globals de Lua │
│ 5.2 ; ??
│ │
│ · lua52c - globals de Lua │
│ │ 5.2 compilé avec │
│ LUA_COMPAT_ALL; ??
│ │
│ · Lua53 - globals de Lua │
│ 5.3 ; ??
│ │
│ · lua53c - globals de Lua │
│ │ 5.3 compilé avec │
│ LUA_COMPAT_5_2; ??
│ │
│ · Luajit - globales de │
│ LuaJIT 2.0; ??
│ │
│ · ngx_lua - globales de │
│ Openresty │
│ module-lua-nginx avec
│ LuaJIT 2.0; ??
│ │
│ · m. - intersection de
│ │ globales de Lua 5.1, Lua │
│ 5.2 et LuaJIT 2.0 ; ??
│ │
│ · max - union des mondiaux │
│ │ de Lua 5.1, Lua 5.2 et │
│ LuaJIT 2.0; ??
│ │
│ · Busted - globals ajoutés │
│ par Busted 2.0; ??
│ │
│ · aucun - pas de norme │
│ globales. ??
│ │
│ Voir Ensembles of Standard │
│ globals │
?? ??
│--globaux [ ] ... │ Ajouter des globals personnalisés en plus de │
│ standards. ??
?? ??
│--read-globales [ ] ... │ Ajouter des globals en lecture seule. ??
?? ??
│--nouveaux-globaux [ ] ... Définir des globals personnalisés. Supprime │
│ │ globals personnalisés ajoutés précédemment. ??
?? ??
│--new-read-globaux [ ] │ Définir des globals en lecture seule. Supprime │
│... │ globals en lecture seule ajoutés │
│ précédemment. ??
?? ??
│-c | --compat Équivalent à --std max. ??
?? ??

│-d | --allow-défini │ Permet de définir des globales │
│ │ implicitement en les définissant. ??
│ │
│ │ Voir les valeurs globales implicitement définies │
?? ??
│-t | --allow-défini-haut │ Permet de définir des globales │
│ │ implicitement en les définissant dans │
│ │ la portée de niveau supérieur. ??
│ │
│ │ Voir les valeurs globales implicitement définies │
?? ??
│-m | --module │ Limiter la visibilité de implicitement │
│ │ défini globals à leurs fichiers. ??
│ │
│ │ Voir les modules │
?? ??
│--ignorer | -i [ ] Filtrer les avertissements correspondant │
│... modèles. ??
?? ??
│--permettre | -e [ ] │ Ne filtrez pas les avertissements │
│... motifs assortis. ??
?? ??
│--seul | -o [ ] ... Filtrer les avertissements ne correspondant pas │
│ motifs. ??
?? ??
│--pas de ligne │ Désactivez les options en ligne. ??
?? ??
│--config │ Chemin vers la configuration personnalisée │
│ │ fichier (par défaut : .luacheckrc). ??
?? ??
│--no-config │ Ne cherchez pas personnalisé │
│ fichier de configuration. ??
?? ??
│--nom de fichier │ Utilisez un autre nom de fichier en sortie, │
│ │ pour sélectionner la configuration │
│ │ remplace et pour le fichier │
│ filtrage. ??
?? ??
│--exclure-les-fichiers [ ] │ Ne pas vérifier la correspondance des fichiers │
│... ces motifs globuleux. ??
│ │ Les globs récursifs tels que **/*.lua │
│ sont pris en charge. ??
?? ??
│--include-fichiers [ ] Ne pas vérifier les fichiers qui ne correspondent pas │
│... ces motifs globuleux. ??
?? ??
│--cache [ ] │ Chemin d'accès au fichier cache. (par défaut : 
│ .luacheckcache). Voir Cache haute performance │
?? ??
│--pas de cache N'utilisez pas le cache. ??
?? ??
│-j | --travaux Vérifier fichiers en parallèle. ??
│ │ Nécessite LuaLanes. ??
?? ??

│--formateur Utilisez un formateur personnalisé. ??
│ doit être un module │
│ │ nom ou l'un des : │
│ │
│ · TAP - Testez n'importe quoi
│ │ Formateur de protocole ; ??
│ │
│ · JUnit -JUnit XML│
│ formateur; ??
│ │
│ · plaine - simple
│ │ avertissement par ligne │
│ formateur; ??
│ │
│ · défaut - norme
│ formateur. ??
?? ??
│-q | --silencieux │ Supprimer la sortie de rapport pour les fichiers │
│ │ sans avertissements. ??
│ │
│ · -qq - Supprimer la sortie │
│ │ d'avertissements. ??
│ │
│ · -qqq - Uniquement en sortie │
│ résumé. ??
?? ??
│--codes Afficher les codes d'avertissement. ??
?? ??
│--plages │ Afficher les plages de colonnes liées │
│ aux avertissements. ??
?? ??
│--sans couleur │ Ne colorez pas la sortie. ??
?? ??
│-v | --version │ Afficher la version de Luacheck et ses │
│ dépendances et sortie. ??
?? ??
│-h | --Aidez-moi Afficher l'aide et quitter. ??
?? ??

Motifs
Options de l'interface de ligne de commande --ignorer, --permettre et --seul et les options de configuration correspondantes permettent le filtrage
avertissements utilisant la correspondance de modèle sur les codes d'avertissement, les noms de variables ou les deux. Si un modèle
contient une barre oblique, la partie avant la barre oblique correspond au code d'avertissement et la partie après les correspondances
Nom de variable. Sinon, si un motif contient une lettre ou un trait de soulignement, il correspond
Nom de variable. Sinon, il correspond au code d'avertissement. Par exemple:

??
Modèle │ Avertissements correspondants │
??
│4.2 │ Shadowing déclarations de │
│ arguments ou de les redéfinir. ??
??
│.*_ │ Avertissements liés aux variables │
│ avec _ suffixe. ??
??
│4.2/.*_ │ Déclarations d'occultation de │
│ arguments avec _ suffixe ou
│ en les redéfinissant. ??
??

À moins qu'ils ne soient déjà ancrés, les modèles correspondant aux noms de variables sont ancrés des deux côtés et
les motifs correspondant aux codes d'avertissement sont ancrés à leurs débuts. Cela permet de
filtrer les avertissements par catégorie (par ex. --seul 1 se concentre lucheck sur les avertissements liés au monde).

Ensembles of Standard globals
Option CLI --stds permet de combiner les ensembles intégrés décrits ci-dessus en utilisant +. Par exemple,
--std max équivaut à --std=lua51+lua52+lua53. Le signe plus principal ajoute de nouveaux ensembles à
celui par défaut au lieu de le remplacer. Par exemple, --std +cassé convient pour vérifier
fichiers de test qui utilisent Busted cadre de test. Des ensembles personnalisés de globals peuvent être définis par
variable globale en mutation normes dans la config. Voir custom_stds

Formateurs
Option CLI --formateur permet de sélectionner un formateur personnalisé pour lucheck sortir. Une coutume
formateur est un module Lua renvoyant une fonction avec trois arguments : rapport tel que renvoyé par
lucheck module (voir rapport), tableau de noms de fichiers et table d'options. Les options contiennent
valeurs attribuées à calme, couleur, limite, codes, gammes et formateur options dans CLI ou
configuration. La fonction de formateur doit renvoyer une chaîne.

Cache haute performance
Si LuaFileSystem est disponible, Luacheck peut mettre en cache les résultats de la vérification des fichiers. A la suite
vérifications, seuls les fichiers qui ont changé depuis la dernière vérification seront revérifiés, améliorant
temps d'exécution de manière significative. Changer les options (par exemple, définir des variables globales supplémentaires) ne
invalider le cache. La mise en cache peut être activée en utilisant --cache Option ou cachette config
option. En utilisant --cache sans argument ni paramètre cachette option de configuration à oui ensembles
.luacheckcache comme fichier cache. Noter que --cache doit être utilisé à chaque fois lucheck is
courir, pas sur la première manche seulement.

Stable interface pour éditeur plugins et les outils
L'interface de ligne de commande de Luacheck peut changer entre les versions mineures. À partir de 0.11.0
version, l'interface suivante est garantie au moins jusqu'à la version 1.0.0 et doit être
utilisé par les outils utilisant la sortie Luacheck, par exemple les plugins d'éditeur.

· Luacheck doit être lancé à partir du répertoire contenant le fichier vérifié.

· Le fichier peut être transmis via stdin en utilisant - comme argument ou en utilisant un fichier temporaire. Réel
le nom de fichier doit être passé en utilisant --nom de fichier option.

· Un formateur simple doit être utilisé. Il génère un problème (avertissement ou erreur) par ligne.

· Pour obtenir l'emplacement précis de l'erreur, --plages option peut être utilisée. Chaque ligne commence par real
nom de fichier (passé en utilisant --nom de fichier), suivi par : : - :,
où est le numéro de la ligne sur laquelle le problème s'est produit et - is
plage inclusive de colonnes de jetons liés au problème. La numérotation commence à partir de 1. Si
--plages n'est pas utilisé, la colonne de fin et le tiret ne sont pas imprimés.

· Pour obtenir les codes d'avertissement et d'erreur, --codes option peut être utilisée. Pour chaque ligne, sous-chaîne
entre parenthèses contient un code d'émission à trois chiffres, préfixé par E pour les erreurs et W
pour les avertissements. L'absence d'une telle sous-chaîne indique une erreur fatale (par exemple une erreur d'E/S).

· Le reste de la ligne est un message d'avertissement.

Si la compatibilité avec l'ancienne version de Luacheck est souhaitée, la sortie de lucheck --Aidez-moi peuvent être
utilisé pour obtenir sa version. S'il contient une chaîne 0. ., Où est à
au moins 11 et pièce est un nombre quelconque, l'interface décrite ci-dessus doit être utilisée.

CONFIGURATION DOSSIER

lucheck essaie de charger la configuration depuis .luacheckrc fichier dans le répertoire courant. Si
introuvable, il le recherchera dans le répertoire parent et ainsi de suite, en remontant jusqu'à ce qu'il
atteint la racine du système de fichiers. Le chemin d'accès à la configuration peut être défini à l'aide de --config option, auquel cas
il sera utilisé lors du chargement récursif. Le chargement de la configuration peut être désactivé en utilisant --no-config
drapeau.

Config est simplement un script Lua exécuté par lucheck. Il peut définir diverses options en
assignation aux globals ou en retournant une table avec des noms d'options comme clés.

Config Options
?? ??
Option │ Type │ Valeur par défaut │
?? ??
│couleur booléen │ oui │
?? ??
│codes booléen │ non │
?? ??

│formateur Chaîne ou fonction │ "défaut" │
?? ??
│cachette │ Booléen ou chaîne │ non │
?? ??
│emplois Entier positif │ 1 │
?? ??
│exclure_fichiers Tableau de chaînes │ {} │
?? ??
│inclure_fichiers │ Tableau de chaînes │ (Inclure tous les fichiers) │
?? ??
│de défis booléen │ oui │
?? ??
│inutilisé booléen │ oui │
?? ??
│redéfini booléen │ oui │
?? ??
│arguments_inutilisés booléen │ oui │
?? ??
│secondaires_inutilisés booléen │ oui │
?? ??
│soi booléen │ oui │
?? ??
│std Chaîne ou ensemble de │ "_G" │
│ │ globales standard │ │
?? ??
│globals Tableau de chaînes │ {} │
?? ??
│nouveaux_globaux │ Tableau de chaînes │ (Ne pas écraser) │
?? ??
│read_globals Tableau de chaînes │ {} │
?? ??
│new_read_globals │ Tableau de chaînes │ (Ne pas écraser) │
?? ??
│compat booléen │ non │
?? ??
│autoriser_défini booléen │ non │
?? ??
│allow_défini_top booléen │ non │
?? ??
│module booléen │ non │
?? ??
│ignorer │ Tableau de motifs (voir │ {} │
│ motifs) │ │
?? ??
│permettre Tableau de motifs │ {} │
?? ??
│uniquement │ Tableau de motifs │ (Ne pas filtrer) │
?? ??
│en ligne booléen │ oui │
?? ??

Un exemple de config qui fait lucheck s'assurer que seuls les globals du portable
l'intersection de Lua 5.1, Lua 5.2, Lua 5.3 et LuaJIT 2.0 est utilisée, ainsi que des désactivations
détection des arguments inutilisés :

std = "min"
ignorer = {"212"}

Personnalisé ensembles of globals
std L'option permet de définir un ensemble standard personnalisé de valeurs globales à l'aide d'une table. Dans ce tableau,
les clés de chaîne sont des globales et les chaînes dans la partie tableau sont des globales en lecture seule.

De plus, les ensembles personnalisés peuvent recevoir des noms en mutant global normes variable. Pour
exemple, lors de l'utilisation LPEG bibliothèque, il est logique d'accéder à ses fonctions laconiquement en utilisant
mondiales. Dans ce cas, la config suivante permet de supprimer les faux positifs liés à
accès global facilement :

stds.lpeg = requiert "lpeg"

lpeg local = requiert "lpeg"

fonction locale parse1(...)
-- Cette fonction n'utilise que les fonctions lpeg comme globales.
_ENV locale = lpeg
-- luacheck : std lpeg
chiffre local, espace = R "09", S " "
- ...
fin

fonction locale parse2(...)
-- Cette fonction utilise les fonctions lpeg ainsi que les globales standard.
local _ENV = setmetatable({}, {__index = function(_, k) return _ENV[k] ou lpeg[k] end})
-- luacheck : std +lpeg
chiffre local, espace = R "09", S " "
numéro local = C(chiffre^1) / tonumber
- ...
fin

Par fichier et par chemin remplacements
L'environnement dans lequel lucheck charge la config contient un global spécial fichiers. Quand
vérification d'un fichier , lucheck remplacera les options de la configuration principale par des entrées
de des dossiers[ ] et des dossiers[ ], en appliquant d'abord les entrées pour les chemins plus courts. Pour
exemple, la configuration suivante réactive la détection des arguments inutilisés uniquement pour les fichiers dans
source/répertoiremais pas pour src/dir/monfichier.lua, et permet d'utiliser Busted mondiales au sein spec /:

std = "min"
ignorer = {"212"}
fichiers["src/dir"] = {activer = {"212"}}
fichiers["src/dir/myfile.lua"] = {ignorer = {"212"}}
fichiers["spec"] = {std = "+busted"}

Notez que fichiers table prend en charge l'autovivification, de sorte que

fichiers["monfichier.lua"].ignore = {"212"}

et

fichiers["monfichier.lua"] = {ignorer = {"212"}}

sont équivalents.

EN LIGNE OPTIONS

Luacheck prend en charge la définition de certaines options directement dans les fichiers vérifiés à l'aide d'inline
commentaires de configuration. Un commentaire de configuration en ligne commence par luacheck : étiqueter,
peut-être après quelques espaces. Le corps du commentaire doit contenir des virgules séparées
options, où l'invocation d'option se compose de son nom plus des arguments séparés par des espaces. Les
les options suivantes sont prises en charge :

?? ??
Option │ Nombre d'arguments │
?? ??
global │ 0 │
?? ??
inutilisé │ 0 │
?? ??
│redéfini │ 0 │
?? ??
args inutilisés │ 0 │
?? ??
│secondaires inutilisés │ 0 │
?? ??
│soi │ 0 │
?? ??

compat │ 0 │
?? ??
module │ 0 │
?? ??
autoriser défini │ 0 │
?? ??
│autoriser le sommet défini │ 0 │
?? ??
std │ 1 │
?? ??
globaux │ 0+ │
?? ??
│nouveaux globaux │ 0+ │
?? ??
lire les globales │ 0+ │
?? ??
│nouvelles globales de lecture │ 0+ │
?? ??
ignorer │ 0+ (sans arguments tout │
│ │ est ignoré) │
?? ??
activer │ 1+ │
?? ??
seulement │ 1+ │
?? ??

Les options qui ne prennent aucun argument peuvent être préfixées par aucune d'en inverser le sens. Par exemple
--luacheck : aucune inutilisé args désactive les avertissements d'arguments inutilisés.

Une partie du fichier affectée par l'option inline dépend de l'endroit où elle est placée. S'il y en a
code sur la ligne avec l'option, seule cette ligne est affectée ; sinon, tout jusqu'à
la fin de la fermeture actuelle est. En particulier, les options en ligne en haut du fichier
affecter tout cela :

-- luacheck : globals g1 g2, ignore foo
local foo = g1(g2) -- Aucun avertissement émis.

-- La fonction inutilisée suivante n'est pas signalée.
fonction locale f() -- luacheck : ignorer
-- luacheck : globals g3
g3() -- Pas d'avertissement.
fin

g3() -- Un avertissement est émis car l'option en ligne définissant g3 n'affecte que la fonction f.

Pour un contrôle précis de la visibilité des options en ligne, utilisez luacheck : pousser et luacheck :
pop directives :

-- luacheck : poussez ignorer foo
foo() -- Pas d'avertissement.
-- luacheck : pop
foo() -- Un avertissement est émis.

Les options en ligne peuvent être complètement désactivées en utilisant --pas de ligne option CLI ou en ligne config
option.

LUCHECK MODULE

Utilisez locales lucheck = exigent "luacheck" à importer lucheck module. Il contient le
fonctions suivantes:

· luacheck.get_report(source): une chaîne source donnée, renvoie les données d'analyse (un tableau).

· luacheck.process_reports(rapports, options): traite la gamme de rapports d'analyse et
applique des options. rapports[i] Usages Options, choix[i], option[i][1], option[i][2]...
en tant qu'options, se remplaçant dans cet ordre. La table d'options est une table avec des champs
similaire aux options de configuration ; voir les options. Rapports d'analyse avec champ fatal sont ignorés.
processus_rapports renvoie le rapport final, voir Rapport le format.

· luacheck.check_strings(sources, options): vérifie le tableau de sources à l'aide d'options, renvoie
rapport final. Tables avec champ fatal dans les sources tableau sont ignorés.

· luacheck.check_files(fichiers, options) : Vérifie le tableau de fichiers à l'aide d'options, renvoie le résultat final
rapport. Les descripteurs de fichiers ouverts peuvent être passés à la place des noms de fichiers, auquel cas ils seront
lu jusqu'à EOF et fermé.

· luacheck.get_message(problème): renvoie un message de chaîne pour un problème, voir Rapport le format.

luacheck._VERSION contient la version Luacheck sous forme de chaîne dans PATCH MAJEUR.MINEUR le format.

En utilisant lucheck en tant que fonction équivaut à appeler luacheck.check_files.

Rapport le format
Un rapport final est un tableau de rapports de fichiers et de champs avertissements, erreurs et mortels
contenant le nombre total d'avertissements, d'erreurs et d'erreurs fatales, en conséquence.

Un rapport de fichier est un ensemble de problèmes (avertissements ou erreurs). Si une erreur fatale s'est produite pendant
vérification d'un fichier, son rapport aura fatal champ contenant le type d'erreur.

Un problème est une table avec un champ code indiquant son type (voir avertissements) et les champs en ligne,
colonne et fin_colonne indiquant la source de l'avertissement. prénom le champ peut contenir le nom
de la variable relative. Les problèmes de certains types peuvent également avoir des champs supplémentaires :

??
│Codes │ Champs supplémentaires │
??
011 msg le champ contient une erreur de syntaxe │
│ message. ??
??
111 module champ indique que │
│ │ l'affectation est à un non-module │
│ variable globale. ??
??
211 fonction champ indique que inutilisé │
│ variable est une fonction. ??
??
│4.. │ ligne_précédente et colonne_précédente champs
│ │ contient l'emplacement du │
│ │ définition écrasée. ??
??

D'autres champs peuvent être présents pour des raisons internes.

Ceci est la documentation pour la version 0.13.0 de Luacheck, un linter pour Lua.

Utilisez luacheck en ligne en utilisant les services onworks.net