SwiftLint
0.57.0
Una herramienta para hacer cumplir el estilo y las convenciones rápidas, basada libremente en la ahora archivada guía de estilo GitHub Swift. Swiftlint hace cumplir las reglas de la guía de estilo que generalmente aceptan la comunidad Swift. Estas reglas están bien descritas en guías de estilo populares como la guía de estilo Swift de Kodeco.
Swiftlint se conecta a Clang y SourceKit para usar la representación AST de sus archivos de origen para obtener resultados más precisos.
Swiftlint se puede usar como un complemento de comando o un complemento de herramienta de compilación.
Agregar
. package ( url : " https://github.com/SimplyDanny/SwiftLintPlugins " , from : " <version> " ) a su archivo Package.swift para consumir la última versión de Swiftlint automáticamente o fijar la dependencia a una versión específica:
. package ( url : " https://github.com/SimplyDanny/SwiftLintPlugins " , exact : " <version> " ) Allí, reemplace <version> con la versión mínima o exacta deseada.
Nota
Consumir los complementos directamente del repositorio de Swiftlint viene con varios inconvenientes. Para evitarlos y reducir la sobrecarga impuesta, se recomienda consumir los complementos del repositorio dedicado de SwiftlintPlugins, a pesar de que los complementos del repositorio de Swiftlint también son absolutamente funcionales. Si se prefieren los complementos de Swiftlint, solo use la URL https://github.com/realm/SwiftLint en las declaraciones de paquete anteriores.
Sin embargo, SwiftlintPlugins facilita la adopción de complementos masivamente. Enumera algunas de las razones que impulsan los complementos según lo dispuesto por Swiftlint muy problemático. Dado que el código de complemento y las versiones se mantienen sincronizadas, no hay diferencia en la funcionalidad entre los dos, pero te dedicas mucho tiempo y problemas usando el repositorio de complementos dedicado.
Este documento asume que confía en SwiftlintPlugins.
Use el siguiente enlace para agregar swiftlint como dependencia de un paquete a un proyecto Xcode:
https://github.com/SimplyDanny/SwiftLintPluginsbrew install swiftlint Agregue lo siguiente a su Podfile :
pod 'SwiftLint' Esto descargará los binarios y dependencias de Swiftlint en Pods/ Durante su próxima ejecución pod install y le permitirá invocarlo a través de ${PODS_ROOT}/SwiftLint/swiftlint en sus fases de construcción de script.
La instalación a través de Cocoapods también permite fijar una versión específica de Swiftlint en lugar de simplemente lo último (que es el caso con Homebrew).
Tenga en cuenta que esto agregará los binarios de Swiftlint, los binarios de sus dependencias y la distribución de la biblioteca binaria Swift a los Pods/ directorio, por lo que se desaconseja verificar en este directorio a SCM como GIT.
mint install realm/SwiftLint Pon esto en tu MODULE.bazel :
bazel_dep ( name = "swiftlint" , version = "0.52.4" , repo_name = "SwiftLint" ) O poner esto en su WORKSPACE :
load ( "@bazel_tools//tools/build_defs/repo:http.bzl" , "http_archive" )
http_archive (
name = "build_bazel_rules_apple" ,
sha256 = "390841dd5f8a85fc25776684f4793d56e21b098dfd7243cd145b9831e6ef8be6" ,
url = "https://github.com/bazelbuild/rules_apple/releases/download/2.4.1/rules_apple.2.4.1.tar.gz" ,
)
load (
"@build_bazel_rules_apple//apple:repositories.bzl" ,
"apple_rules_dependencies" ,
)
apple_rules_dependencies ()
load (
"@build_bazel_rules_swift//swift:repositories.bzl" ,
"swift_rules_dependencies" ,
)
swift_rules_dependencies ()
load (
"@build_bazel_rules_swift//swift:extras.bzl" ,
"swift_rules_extra_dependencies" ,
)
swift_rules_extra_dependencies ()
http_archive (
name = "SwiftLint" ,
sha256 = "c6ea58b9c72082cdc1ada4a2d48273ecc355896ed72204cedcc586b6ccb8aca6" ,
url = "https://github.com/realm/SwiftLint/releases/download/0.52.4/bazel.tar.gz" ,
)
load ( "@SwiftLint//bazel:repos.bzl" , "swiftlint_repos" )
swiftlint_repos ()
load ( "@SwiftLint//bazel:deps.bzl" , "swiftlint_deps" )
swiftlint_deps ()Luego puede ejecutar Swiftlint en el directorio actual con este comando:
bazel run -c opt @SwiftLint//:swiftlint Descargue SwiftLint.pkg del último lanzamiento de Github y ejecutarlo.
Asegúrese de que se instalen el bazel de la herramienta de compilación y una reciente cadena de herramientas Swift y que todas las herramientas sean descubiertas en su PATH .
Para construir Swiftlint, clone este repositorio y ejecute make install .
Importante
Si bien puede parecer intuitivo ejecutar Swiftlint antes de compilar archivos fuente Swift para salir de una compilación temprano cuando hay violaciones de pelusa, es importante comprender que Swiftlint está diseñado para analizar un código fuente válido que es compilable. El código de no competencia puede conducir muy fácilmente a resultados inesperados y confusos, especialmente cuando se ejecuta con los argumentos de línea de comandos --fix / --autocorrect .
Swiftlint se puede utilizar como un complemento de herramienta de compilación para proyectos de paquetes Swift y proyectos Xcode.
El complemento de la herramienta de compilación determina el directorio de trabajo Swiftlint al localizar el archivo de configuración superior dentro del directorio de paquete/proyecto. Si no se encuentra un archivo de configuración, el directorio de paquete/proyecto se usa como directorio de trabajo.
El complemento arroja un error cuando no puede resolver el directorio de trabajo Swiftlint. Por ejemplo, esto ocurrirá en proyectos XCode donde los archivos Swift del objetivo no se encuentran dentro del directorio del proyecto.
Para maximizar la compatibilidad con el complemento, evite las estructuras del proyecto que requieren el uso de la opción --config .
Nota
Requiere la instalación a través de Swift Package Manager.
Construir complementos de herramientas se ejecutan al construir cada objetivo. Cuando un proyecto tiene múltiples objetivos, el complemento debe agregarse a los objetivos deseados individualmente.
Para hacer esto, agregue el complemento a los objetivos para que se pelean de la siguiente manera:
. target (
...
plugins : [ . plugin ( name : " SwiftLintBuildToolPlugin " , package : " SwiftLintPlugins " ) ]
) ,Nota
Requiere la instalación a través de Swift Package Manager.
El complemento de comando habilita ejecutar swiftlint desde la línea de comando de la siguiente manera:
swift package plugin swiftlintNota
Requiere la instalación de la dependencia del paquete Xcode.
Los complementos de herramientas de compilación se ejecutan como una fase de compilación de cada objetivo. Cuando un proyecto tiene múltiples objetivos, el complemento debe agregarse a los objetivos deseados individualmente.
Para hacer esto, agregue el SwiftLintBuildToolPlugin a la fase Run Build Tool Plug-ins de las Build Phases para que los objetivos se peleen.
Consejo
Cuando use el complemento por primera vez, asegúrese de confiar y habilitarlo cuando se le solicite. Si existe una advertencia de construcción de macros, seleccione para confiar y habilitar las macros también.
Para uso desatendido (por ejemplo, CI), el complemento de paquetes y las validaciones de macro se pueden deshabilitar con cualquiera de los siguientes:
Uso de opciones xcodebuild :
-skipPackagePluginValidation
-skipMacroValidationConfiguración de Xcode predeterminados:
defaults write com.apple.dt.Xcode IDESkipPackagePluginFingerprintValidatation -bool YES
defaults write com.apple.dt.Xcode IDESkipMacroFingerprintValidation -bool YESImportante
Las opciones de uso desatendido evitan los diálogos de validación de Xcode e implícitamente confían en todos los complementos y macros, lo que tiene implicaciones de seguridad.
Las estructuras del proyecto donde el archivo de configuración de Swiftlint se encuentra fuera del directorio de paquete/proyecto no son compatibles directamente con el complemento de herramienta de compilación. Esto se debe a que no es posible pasar argumentos para crear complementos de herramientas (por ejemplo, pasar la ruta del archivo de configuración).
Si la estructura de su proyecto no funciona directamente con el complemento Build Tool, considere una de las siguientes opciones:
parent_config: path/to/.swiftlint.yml .Nota
Según el método de instalación utilizado, la sintaxis del comando shell en la fase de compilación de script de ejecución puede ser diferente o se podría requerir una configuración adicional. Consulte las instrucciones de instalación para obtener más información.
Si el complemento de la herramienta de compilación no funciona para la configuración de su proyecto o cuando se requiere una configuración personalizada adicional, Swiftlint se puede agregar como una fase de compilación de script de ejecución. Esto es útil cuando una configuración de proyecto se basa en la opción --config Swiftlint; o para pelear todos los objetivos juntos en una sola invocación swiftlint . Las inclusiones y exclusiones de archivos se pueden configurar en la configuración .swiftlint.yml .
Para hacer esto, agregue un script personalizado a una fase Run Script de las Build Phases del objetivo de la aplicación primaria, después de la fase Compile Sources . Use la siguiente implementación de script:
if command -v swiftlint > /dev/null 2>&1
then
swiftlint
else
echo " warning: ` swiftlint ` command not found - See https://github.com/realm/SwiftLint#installation for installation instructions. "
fi Si está utilizando el swiftlintplugin en un paquete Swift, puede consultar el ejecutable swiftlint de la siguiente manera:
SWIFT_PACKAGE_DIR= " ${BUILD_DIR % Build /* } SourcePackages/artifacts "
SWIFTLINT_CMD= $( ls " $SWIFT_PACKAGE_DIR " /swiftlintplugins/SwiftLintBinary/SwiftLintBinary.artifactbundle/swiftlint- * /bin/swiftlint | head -n 1 )
if test -f " $SWIFTLINT_CMD " 2>&1
then
" $SWIFTLINT_CMD "
else
echo " warning: ` swiftlint ` command not found - See https://github.com/realm/SwiftLint#installation for installation instructions. "
fi Nota
La ruta SWIFTLINT_CMD utiliza la configuración de XCode predeterminada y se ha probado en XCode 15/16. En el caso de otra configuración (por ejemplo, una ruta de paquete Swift personalizado), adapte los valores en consecuencia.
Consejo
Desactivar Based on dependency analysis para ejecutar swiftlint en todas las construcciones incrementales, suprimiendo la advertencia de salidas no especificadas.
Xcode 15 realizó un cambio significativo al establecer el valor predeterminado de la configuración de compilación ENABLE_USER_SCRIPT_SANDBOXING de NO a YES . Como resultado, Swiftlint encuentra un error relacionado con los permisos de archivo faltantes, que generalmente se manifiesta como error: Sandbox: swiftlint(19427) deny(1) file-read-data.
Para resolver este problema, es necesario establecer manualmente la configuración de ENABLE_USER_SCRIPT_SANDBOXING en NO para el objetivo específico para el que se está configurando Swiftlint.
Si instaló Swiftlint a través de Homebrew en Apple Silicon, puede experimentar esta advertencia:
warning: SwiftLint not installed, download from https://github.com/realm/SwiftLint Esto se debe a que Homebrew en Apple Silicon instala los binarios en la carpeta /opt/homebrew/bin de forma predeterminada. Para instruir a Xcode dónde encontrar Swiftlint, puede agregar /opt/homebrew/bin a la variable de entorno PATH en su fase de compilación:
if [[ " $( uname -m ) " == arm64 ]]
then
export PATH= " /opt/homebrew/bin: $PATH "
fi
if command -v swiftlint > /dev/null 2>&1
then
swiftlint
else
echo " warning: ` swiftlint ` command not found - See https://github.com/realm/SwiftLint#installation for installation instructions. "
fi O puede crear un enlace simbólico en /usr/local/bin apuntando al binario real:
ln -s /opt/homebrew/bin/swiftlint /usr/local/bin/swiftlint Si desea solucionar violaciones también, su script podría ejecutar swiftlint --fix && swiftlint en lugar de simplemente swiftlint . Esto significará que todas las violaciones correctables son fijas al tiempo que garantiza que aparezcan advertencias en su proyecto para las violaciones restantes.
Si ha instalado Swiftlint a través de Cocoapods, el script debería verse así:
" ${PODS_ROOT} /SwiftLint/swiftlint " Para integrar Swiftlint con el código Visual Studio, instale la extensión vscode-swiftlint desde el mercado.
Puede usar la acción oficial swiftlint FastLane para ejecutar Swiftlint como parte de su proceso de Fastlane.
swiftlint (
mode : :lint , # SwiftLint mode: :lint (default) or :autocorrect
executable : "Pods/SwiftLint/swiftlint" , # The SwiftLint binary path (optional). Important if you've installed it via CocoaPods
path : "/path/to/lint" , # Specify path to lint (optional)
output_file : "swiftlint.result.json" , # The path of the output file (optional)
reporter : "json" , # The custom reporter to use (optional)
config_file : ".swiftlint-ci.yml" , # The path of the configuration file (optional)
files : [ # List of files to process (optional)
"AppDelegate.swift" ,
"path/to/project/Model.swift"
] ,
ignore_exit_status : true , # Allow fastlane to continue even if SwiftLint returns a non-zero exit status (Default: false)
quiet : true , # Don't print status logs like 'Linting ' & 'Done linting' (Default: false)
strict : true # Fail on warnings? (Default: false)
) Swiftlint también está disponible como una imagen de Docker usando Ubuntu . Entonces, solo la primera vez que necesita extraer la imagen Docker usando el siguiente comando:
docker pull ghcr.io/realm/swiftlint:latest Luego, los tiempos siguientes, simplemente corres swiftlint dentro del Docker como:
docker run -it -v ` pwd ` : ` pwd ` -w ` pwd ` ghcr.io/realm/swiftlint:latest Esto ejecutará swiftlint en la carpeta donde se encuentra ahora ( pwd ), mostrando una salida como:
$ docker run -it -v ` pwd ` : ` pwd ` -w ` pwd ` ghcr.io/realm/swiftlint:latest
Linting Swift files in current working directory
Linting ' RuleDocumentation.swift ' (1/490)
...
Linting ' YamlSwiftLintTests.swift ' (490/490)
Done linting ! Found 0 violations, 0 serious in 490 files.Aquí tiene más documentación sobre el uso de imágenes de Docker.
$ swiftlint help
OVERVIEW: A tool to enforce Swift style and conventions.
USAGE: swiftlint <subcommand>
OPTIONS:
--version Show the version.
-h, --help Show help information.
SUBCOMMANDS:
analyze Run analysis rules
docs Open SwiftLint documentation website in the default web browser
generate-docs Generates markdown documentation for selected group of rules
lint (default) Print lint warnings and errors
baseline Operations on existing baselines
reporters Display the list of reporters and their identifiers
rules Display the list of rules and their identifiers
version Display the current version of SwiftLint
See 'swiftlint help <subcommand>' for detailed help. Ejecute swiftlint en el directorio que contiene los archivos Swift a la pelusa. Los directorios se buscarán recursivamente.
Para especificar una lista de archivos cuando se usa lint o analyze (como la lista de archivos modificados por Xcode especificados por el complemento ExtraBuildPhase XCode, o archivos modificados en el árbol de trabajo basado en git ls-files -m ), puede hacerlo pasando La opción --use-script-input-files y configurando las siguientes variables de instancia: SCRIPT_INPUT_FILE_COUNT y SCRIPT_INPUT_FILE_0 , SCRIPT_INPUT_FILE_1 , ..., SCRIPT_INPUT_FILE_{SCRIPT_INPUT_FILE_COUNT - 1} . Del mismo modo, los archivos se pueden leer de las listas de archivos pasando la opción --use-script-input-file-lists y configurando las siguientes variables de instancia: SCRIPT_INPUT_FILE_LIST_COUNT y SCRIPT_INPUT_FILE_LIST_0 , SCRIPT_INPUT_FILE_LIST_1 , ..., SCRIPT_INPUT_FILE_LIST_{SCRIPT_INPUT_FILE_LIST_COUNT - 1} .
Estas son las mismas variables de entorno establecidas para archivos de entrada a fases de script Xcode personalizadas.
¡Swiftlint se conecta a SourceKit para que continúe trabajando incluso cuando Swift evoluciona!
Esto también se mantiene delgada de Swiftlint, ya que no necesita enviar con un compilador Swift completo, solo se comunica con el oficial que ya ha instalado en su máquina.
Siempre debe ejecutar Swiftlint con la misma cadena de herramientas que usa para compilar su código.
Es posible que desee anular la cadena de herramientas Swift predeterminada de Swiftlint si tiene múltiples cadenas de herramientas o XCODS instalados.
Aquí está el orden en el que Swiftlint determina qué Swift Toolchain usar:
$XCODE_DEFAULT_TOOLCHAIN_OVERRIDE$TOOLCHAIN_DIR o $TOOLCHAINSxcrun -find swift/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/Applications/Xcode-beta.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain~/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain~/Applications/Xcode-beta.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain Se espera que sourcekitd.framework se encuentre en el subdirectorio usr/lib/ del valor pasado en las rutas anteriores.
También puede establecer la variable de entorno TOOLCHAINS en la notación de DNS inverso que identifica una versión de cadena de herramientas Swift:
TOOLCHAINS=com.apple.dt.toolchain.Swift_2_3 swiftlint --fix En Linux, se espera que SourceKit esté ubicado en /usr/lib/libsourcekitdInProc.so o especificado por la variable de entorno LINUX_SOURCEKIT_LIB_PATH .
pre-commit Swiftlint se puede ejecutar como un gancho precomito. Una vez instalado, agregue esto al .pre-commit-config.yaml en la raíz de su repositorio:
repos :
- repo : https://github.com/realm/SwiftLint
rev : 0.50.3
hooks :
- id : swiftlint Ajuste rev a la versión Swiftlint de su elección. pre-commit autoupdate se puede usar para actualizar la versión actual.
Swiftlint se puede configurar utilizando entry para aplicar correcciones y fallar en errores:
- repo : https://github.com/realm/SwiftLint
rev : 0.50.3
hooks :
- id : swiftlint
entry : swiftlint --fix --strict Se incluyen más de 200 reglas en Swiftlint y Swift Community (¡esa es usted!) Continúa contribuyendo más con el tiempo. Se alientan las solicitudes de extracción.
Puede encontrar una lista actualizada de reglas y más información sobre ellas aquí.
También puede verificar el directorio Source/SwiftlintBuiltInRules/Rules para ver su implementación.
opt_in_rules están deshabilitados de forma predeterminada (es decir, debe habilitarlos explícitamente en su archivo de configuración).
Directrices sobre cuándo marcar una regla como opción:
empty_count )force_unwrapping )Las reglas se pueden deshabilitar con un comentario dentro de un archivo fuente con el siguiente formato:
// swiftlint:disable <rule1> [<rule2> <rule3>...]
Las reglas se deshabilitarán hasta el final del archivo o hasta que el enlace vea un comentario de habilitación coincidente:
// swiftlint:enable <rule1> [<rule2> <rule3>...]
Por ejemplo:
// swiftlint:disable colon
let noWarning : String = " " // No warning about colons immediately after variable names!
// swiftlint:enable colon
let hasWarning : String = " " // Warning generated about colons immediately after variable names La inclusión de all la palabra clave deshabilitará todas las reglas hasta que el enlace vea un comentario de habilitación de coincidencia:
// swiftlint:disable all // swiftlint:enable all
Por ejemplo:
// swiftlint:disable all
let noWarning : String = " " // No warning about colons immediately after variable names!
let i = " " // Also no warning about short identifier names
// swiftlint:enable all
let hasWarning : String = " " // Warning generated about colons immediately after variable names
let y = " " // Warning generated about short identifier names También es posible modificar un comando disable o enable mediante la adjunta :previous ,: :this o :next para aplicar solo el comando al anterior, esta (actual) o siguiente línea respectivamente.
Por ejemplo:
// swiftlint:disable:next force_cast
let noWarning = NSNumber ( ) as! Int
let hasWarning = NSNumber ( ) as! Int
let noWarning2 = NSNumber ( ) as! Int // swiftlint:disable:this force_cast
let noWarning3 = NSNumber ( ) as! Int
// swiftlint:disable:previous force_cast Ejecute swiftlint rules para imprimir una lista de todas las reglas disponibles y sus identificadores.
Configure Swiftlint agregando un archivo .swiftlint.yml desde el directorio desde el que ejecutará Swiftlint. Se pueden configurar los siguientes parámetros:
Inclusión de reglas:
disabled_rules : deshabilitar las reglas del conjunto habilitado predeterminado predeterminado.opt_in_rules : habilitar reglas que no formen parte del conjunto predeterminado. El identificador all especial habilitará todo OPT en las reglas de la punta, excepto las que se enumeran en disabled_rules .only_rules : solo se habilitarán las reglas especificadas en esta lista. No se puede especificar junto con disabled_rules u opt_in_rules .analyzer_rules : esta es una lista completamente separada de reglas que solo son ejecutadas por el comando analyze . Todas las reglas del analizador son optadas, por lo que esta es la única lista de reglas configurable, no hay equivalentes para disabled_rules y only_rules . El identificador especial all también se puede usar aquí para habilitar todas las reglas del analizador, excepto las que se enumeran en disabled_rules . # By default, SwiftLint uses a set of sensible default rules you can adjust:
disabled_rules : # rule identifiers turned on by default to exclude from running
- colon
- comma
- control_statement
opt_in_rules : # some rules are turned off by default, so you need to opt-in
- empty_count # find all the available rules by running: `swiftlint rules`
# Alternatively, specify all rules explicitly by uncommenting this option:
# only_rules: # delete `disabled_rules` & `opt_in_rules` if using this
# - empty_parameters
# - vertical_whitespace
analyzer_rules : # rules run by `swiftlint analyze`
- explicit_self
# Case-sensitive paths to include during linting. Directory paths supplied on the
# command line will be ignored.
included :
- Sources
excluded : # case-sensitive paths to ignore during linting. Takes precedence over `included`
- Carthage
- Pods
- Sources/ExcludedFolder
- Sources/ExcludedFile.swift
- Sources/*/ExcludedFile.swift # exclude files with a wildcard
# If true, SwiftLint will not fail if no lintable files are found.
allow_zero_lintable_files : false
# If true, SwiftLint will treat all warnings as errors.
strict : false
# If true, SwiftLint will treat all errors as warnings.
lenient : false
# The path to a baseline file, which will be used to filter out detected violations.
baseline : Baseline.json
# The path to save detected violations to as a new baseline.
write_baseline : Baseline.json
# If true, SwiftLint will check for updates after linting or analyzing.
check_for_updates : true
# configurable rules can be customized from this configuration file
# binary rules can set their severity level
force_cast : warning # implicitly
force_try :
severity : warning # explicitly
# rules that have both warning and error levels, can set just the warning level
# implicitly
line_length : 110
# they can set both implicitly with an array
type_body_length :
- 300 # warning
- 400 # error
# or they can set both explicitly
file_length :
warning : 500
error : 1200
# naming rules can set warnings/errors for min_length and max_length
# additionally they can set excluded names
type_name :
min_length : 4 # only warning
max_length : # warning and error
warning : 40
error : 50
excluded : iPhone # excluded via string
allowed_symbols : ["_"] # these are allowed in type names
identifier_name :
min_length : # only min_length
error : 4 # only error
excluded : # excluded via string array
- id
- URL
- GlobalAPIKey
reporter : " xcode " # reporter type (xcode, json, csv, checkstyle, codeclimate, junit, html, emoji, sonarqube, markdown, github-actions-logging, summary) También puede usar variables de entorno en su archivo de configuración, utilizando ${SOME_VARIABLE} en una cadena.
Además de las reglas con las que se envía el proyecto Swiftlint principal, Swiftlint también puede ejecutar dos tipos de reglas personalizadas que puede definir en sus propios proyectos:
Estas reglas se escriben de la misma manera que las reglas basadas en Swift que se envían con Swiftlint para que sean rápidos, precisos, puedan aprovechar SwiftSyntax, se pueden probar la unidad y más.
El uso de estos requiere construir Swiftlint con Bazel como se describe en este video o en su código asociado en github.com/jpsim/swiftlint-bazel-example.
Puede definir reglas basadas en reglas personalizadas en su archivo de configuración utilizando la siguiente sintaxis:
custom_rules :
pirates_beat_ninjas : # rule identifier
included :
- " .* \ .swift " # regex that defines paths to include during linting. optional.
excluded :
- " .*Test \ .swift " # regex that defines paths to exclude during linting. optional
name : " Pirates Beat Ninjas " # rule name. optional.
regex : " ([nN]inja) " # matching pattern
capture_group : 0 # number of regex capture group to highlight the rule violation at. optional.
match_kinds : # SyntaxKinds to match. optional.
- comment
- identifier
message : " Pirates are better than ninjas. " # violation message. optional.
severity : error # violation severity. optional.
no_hiding_in_strings :
regex : " ([nN]inja) "
match_kinds : stringAsí es como se vería la salida:
Es importante tener en cuenta que el patrón de expresión regular se usa con los flags s y m habilitado, es decir . coincide con las líneas nuevas y ^ / $ coincide con el inicio y el final de las líneas, respectivamente. Si no quieres tener . Haga coincidir las nuevas líneas, por ejemplo, la regex puede ser preparada por (?-s) .
Puede filtrar las coincidencias proporcionando uno o más match_kinds , que rechazará las coincidencias que incluyen tipos de sintaxis que no están presentes en esta lista. Aquí están todos los tipos de sintaxis posibles:
argumentattribute.builtinattribute.idbuildconfig.idbuildconfig.keywordcommentcomment.markcomment.urldoccommentdoccomment.fieldidentifierkeywordnumberobjectliteralparameterplaceholderstringstring_interpolation_anchortypeidentifier Todos los tipos de sintaxis utilizados en un fragmento de código Swift se pueden extraer solicitando a SourceKitten. Por ejemplo, sourcekitten syntax --text "struct S {}" ofrece
source.lang.swift.syntaxtype.keyword para la palabra clave struct ysource.lang.swift.syntaxtype.identifier para su nombre S que coinciden con keyword e identifier en la lista anterior.
Si usa reglas personalizadas en combinación con only_rules , debe incluir la cadena literal custom_rules en la lista only_rules :
only_rules :
- custom_rules
custom_rules :
no_hiding_in_strings :
regex : " ([nN]inja) "
match_kinds : stringA diferencia de las reglas personalizadas de Swift, puede usar compilaciones oficiales de Swiftlint (por ejemplo, desde Homebrew) para ejecutar reglas personalizadas de Regex.
Swiftlint puede corregir automáticamente ciertas violaciones. Los archivos en el disco se sobrescriben con una versión corregida.
Asegúrese de tener copias de seguridad de estos archivos antes de ejecutar swiftlint --fix , de lo contrario, se pueden perder datos importantes.
La pelusa estándar está deshabilitada mientras se corrige debido a que la alta probabilidad de violaciones (o sus compensaciones) es incorrecta después de modificar un archivo mientras aplica correcciones.
El comando swiftlint analyze puede forjar archivos Swift utilizando el AST de tipo completo. La ruta de registro del compilador que contiene la invocación de comando de compilación Clean swiftc (las construcciones incrementales fallarán) debe pasar para analyze a través del indicador --compiler-log-path . por ejemplo , --compiler-log-path /path/to/xcodebuild.log
Esto se puede obtener por
xcodebuild -workspace {WORKSPACE}.xcworkspace -scheme {SCHEME} > xcodebuild.logswiftlint analyze --compiler-log-path xcodebuild.logLas reglas del analizador tienden a ser considerablemente más lentas que las reglas de pelusa.
Swiftlint ofrece una variedad de formas de incluir múltiples archivos de configuración. Múltiples archivos de configuración se fusionan en una sola configuración que luego se aplica al igual que se aplicaría un solo archivo de configuración.
Hay muchos casos de uso en los que usar múltiples archivos de configuración podría ser útil:
Por ejemplo, uno podría usar una configuración Swiftlint compartida en todo el equipo al tiempo que permite anulaciones en cada proyecto a través de un archivo de configuración infantil.
Configuración de todo el equipo:
disabled_rules :
- force_castConfiguración específica del proyecto:
opt_in_rules :
- force_cast Puede especificar un child_config y/o una referencia de parent_config dentro de un archivo de configuración. Estas referencias deben ser rutas locales en relación con la carpeta del archivo de configuración en el que se especifican. Esto incluso funciona de manera recursiva, siempre y cuando no haya ciclos ni ambigüedades.
Una configuración infantil se trata como un refinamiento y, por lo tanto, tiene una prioridad más alta , mientras que una configuración principal se considera una base con menor prioridad en caso de conflictos.
Aquí hay un ejemplo, suponiendo que tenga la siguiente estructura de archivo:
ProjectRoot
|_ .swiftlint.yml
|_ .swiftlint_refinement.yml
|_ Base
|_ .swiftlint_base.yml Para incluir tanto el refinamiento como el archivo base, su .swiftlint.yml debería verse así:
child_config : .swiftlint_refinement.yml
parent_config : Base/.swiftlint_base.yml Al fusionar las configuraciones de los padres y los niños, las configuraciones included y excluded se procesan cuidadosamente para tener en cuenta las diferencias en la ubicación del directorio de los archivos de configuración que contienen.
Del mismo modo que puede proporcionar referencias locales child_config / parent_config , en lugar de hacer referencia a rutas locales, puede poner URL que conducen a archivos de configuración. Para que Swiftlint detecte estas referencias remotas, deben comenzar con http:// o https:// .
Los archivos de configuración remotos referenciados pueden incluso hacer referencia recursivamente a otros archivos de configuración remota, pero no se les permite incluir referencias locales.
Usando una referencia remota, su .swiftlint.yml podría verse así:
parent_config : https://myteamserver.com/our-base-swiftlint-config.ymlCada vez que ejecuta Swiftlint y tiene una conexión a Internet, Swiftlint intenta obtener una nueva versión de cada configuración remota a la que se hace referencia. Si esta solicitud se desprende, se usa una versión en caché si está disponible. Si no hay una versión en caché disponible, Swiftlint falla, pero no se preocupe, una versión en caché debería estar allí una vez que Swiftlint se haya ejecutado con éxito al menos una vez.
Si es necesario, los tiempos de espera para la obtención de configuración remota se pueden especificar manualmente a través de los archivos de configuración utilizando los especificadores remote_timeout / remote_timeout_if_cached . Estos valores predeterminados a 2 segundos o 1 segundo, respectivamente.
En lugar de solo proporcionar un archivo de configuración cuando se ejecuta Swiftlint a través de la línea de comando, también puede pasar una jerarquía, donde la primera configuración se trata como un padre, mientras que la última se trata como el niño de mayor prioridad.
Un ejemplo simple que incluye solo dos archivos de configuración se ve así:
swiftlint --config .swiftlint.yml --config .swiftlint_child.yml
Además de una configuración principal (el archivo .swiftlint.yml en la carpeta raíz), puede colocar otros archivos de configuración llamados .swiftlint.yml en la estructura del directorio que luego se fusionan como una configuración infantil, pero solo con un efecto para aquellos archivos que están dentro del mismo directorio que la configuración o en un directorio más profundo donde no hay otro archivo de configuración. En otras palabras: las configuraciones anidadas no funcionan de manera recursiva: hay un número máximo de una configuración anidada por archivo que puede aplicarse además de la configuración principal.
.swiftlint.yml Los archivos solo se consideran como una configuración anidada si ya no se han utilizado para construir la configuración principal (por ejemplo, al haber sido referenciado a través de algo como child_config: Folder/.swiftlint.yml ). Además, las especificaciones parent_config / child_config de configuraciones anidadas se ignoran porque no tiene sentido.
Si uno (o más) archivos Swiftlint se especifica explícitamente a través del parámetro --config , esa configuración se tratará como una anulación, sin importar si existen otros archivos .swiftlint.yml en algún lugar dentro del directorio. Entonces, si desea usar configuraciones anidadas, no puede usar el parámetro --config .
MIT con licencia.
Swiftlint es mantenido y financiado por Realm Inc. Los nombres y los logotipos para Realm son marcas registradas de Realm Inc.
¡❤️ Software de código abierto! Vea nuestros otros proyectos de código abierto, lea nuestro blog o saluda en Twitter (@Realm).
Nuestro agradecimiento al MacStadium por proporcionar un Mac Mini para ejecutar nuestras pruebas de rendimiento.
