Comment utiliser les scripts Swift pour automatiser les tâches répétitives | de Riccardo Cipolleschi | janvier 2023

Un guide étape par étape pour être plus productif et efficace

Swift est une langue merveilleuse. Il peut être utilisé pour tout : applications iOS, bibliothèques, applications macOS et applications d’interface de ligne de commande (CLI). Vous pouvez également l’utiliser comme langage de script.

Cette semaine, j’ai dû faire un travail répétitif, et je ne voulais pas le faire manuellement. J’ai décidé d’écrire un script pour cela, et je l’ai écrit en utilisant Swift.

L’utilisation de Swift comme langage de script vous permet d’utiliser toutes les fonctionnalités intéressantes de Swift. Vous pouvez utiliser la complétion de code Xcode et son débogueur. Vous pouvez écrire des scripts en utilisant toutes les fonctionnalités puissantes de Swift : les énumérations, les protocoles et, par-dessus tout, les scripts, les types et la vérification des types. La sécurité de type est quelque chose que la plupart des langages de script courants (Python, Javascript, Ruby, etc.) n’ont généralement pas.

Si vous êtes un ingénieur iOS, l’utilisation de Swift dans votre flux de travail quotidien ne nécessite aucune configuration supplémentaire : Xcode est fourni avec le compilateur et nous pouvons exécuter des scripts Swift à l’aide de la commande suivante :

swift <path-to-your-script>.swift [args]

L’utilisation de Swift comme langage de script s’accompagne de certaines règles et mises en garde. Il n’y a que deux règles importantes :

1. Votre script doit commencer par un hashbang : #!/usr/bin/env swift
2. Le script entier doit rester dans le même fichier. Vous ne pouvez pas créer de fichiers séparés et les importer dans le script.

La première règle est importante si nous voulons exécuter notre script sans utiliser explicitement le swift <program_name> syntaxe. Si nous ajoutons le hashbang, notre système essaiera d’utiliser le programme spécifié dans la première ligne pour exécuter le script. Donc, après avoir votre fichier de script (disons updateFiles.swift) nous pouvons modifier ses droits d’accès avec

chmod +x updateFiles.swift

et, après cette commande, nous pouvons l’invoquer directement avec

./updateFiles.swift [args]

sans exécuter explicitement le swift commande.

La deuxième règle est liée à l’une des différences les plus importantes entre le génie logiciel et le codage (ou le développement de logiciels) :

Le génie logiciel se concentre sur l’écriture de code qui doit vivre longtemps. Le code produit par de bonnes pratiques d’ingénierie logicielle est maintenable, extensible et facile à collaborer.

Le développement logiciel (ou codage) n’est que l’acte d’écrire un logiciel. Cela n’implique pas que toutes les bonnes techniques de génie logiciel soient appliquées. Si vous avez besoin d’écrire du code nécessaire pour une tâche très spécifique, qui ne durera pas longtemps et que vous ne serez qu’un utilisateur, vous pouvez simplement écrire du code qui fonctionne.

La limitation d’avoir tout le code dans un seul fichier pousse les scripts Swift à l’encontre des bonnes pratiques d’ingénierie logicielle. Mais ce n’est pas grave si vous savez que vous n’aurez besoin de ce script que pour quelques jours.

Si vous commencez à écrire un script qui devient de plus en plus complexe, un seul script n’est probablement pas le bon outil pour ce travail. Vous avez probablement besoin d’une application de ligne de commande à part entière (ou application CLI).

Les cas d’utilisation entre une CLI et un script sont très différents :

• Un script est bon pour automatiser un travail répétitif dont vous n’avez besoin qu’une seule fois. Vous pouvez écrire un script d’une manière rapide et sale. Le faire de cette manière vous permet d’éviter la gestion des erreurs, bang trys, et faites toutes les choses désagréables dont vous avez besoin pour faire le travail. Personne ne verra votre code et il sera supprimé juste après le travail.
• Une CLI (ou toute autre application) peut être utilisée à plusieurs reprises. D’autres personnes peuvent l’utiliser, et d’autres fonctionnalités pourraient être implémentées pour l’étendre. Dans ce cas, vous devez vous soucier des erreurs et des bonnes pratiques pour faciliter la vie de celui qui viendra après vous.

Ma façon préférée d’écrire un script dans Swift est de commencer avec un terrain de jeu Xcode. La création d’un terrain de jeu Xcode vous permet d’accéder à toutes les fonctionnalités intéressantes de Xcode, y compris le débogage et l’achèvement du code. Ceci est extrêmement utile pour développer le script plus rapidement, sans le cycle douloureux de mise à jour du script, de son exécution, de lecture des erreurs et de tout répéter.

Pour démarrer avec un Playground, vous pouvez :

1. Ouvrir Xcode
2. Fichier -> Nouveau -> Playground
3. Choisissez le modèle vierge
4. Donnez-lui un nom (par exemple, Scripting)

Xcode ouvrira l’écran Playground par défaut. Avec un Playground, le fichier Swift s’appellerait Content.swift. Une fois le script terminé, vous pouvez le renommer et l’éloigner du Playground.

Notez que si vous ajoutez le hashbang en haut du fichier et essayez d’exécuter le script, il renverra une erreur. Lors de l’écriture du script dans Xcode, vous pouvez commenter ou supprimer le hashbang.

Lors de l’exécution d’un script, Swift exécutera chaque ligne du script dans l’ordre dans lequel vous l’avez écrit. En ce sens, vous pouvez y penser comme s’il allait être interprété plutôt que compilé.

Mais ne vous y trompez pas, le script sera compilé !

La structure que je suggère de suivre consiste à écrire vos fonctions d’assistance au-dessus du script et l’instruction pour l’exécuter à la fin.

Mieux encore, enveloppez ces déclarations dans un func main() fonction et invoquez cela!

Un exemple de structure ressemblerait à ceci :

#!/usr/bin/env swift
// MARK: - Helpers
func helperFoo() -> String {
// ... do something ...
}
func helperBar(param: String) -> Int {
// ... do something else ...
}
// MARK: - Main
func main() {
let aString = helperFoo()
let anInt = helperBar(param: aString)
print(anInt)
}
// MARK: - Execution
main()

L’organisation de votre code est toujours importante, même dans un script : cela permet d’isoler facilement les fonctionnalités pour une meilleure expérience de débogage. De plus, plus vous utilisez le script, plus vous verrez une infrastructure de base qui ne change pas, même si vous devez exécuter différentes opérations au-dessus de cette structure.

Organiser correctement le script peut vous permettre d’échanger facilement les fonctionnalités et de n’implémenter que la nouvelle logique dont vous avez besoin. Personne ne veut réimplémenter l’analyse d’arguments et l’exploration de fichiers encore et encore.

Analyse des arguments

Une partie importante du script consiste à recevoir des arguments de la ligne de commande pour réutiliser le même script avec différents paramètres ou pour l’exécuter sur différents dossiers.

Pour accéder aux arguments, Swift fournit un objet appelé CommandLine avec quelques propriétés statiques : argcqui renvoie le nombre d’arguments passés au script, et argumentsun tableau de chaînes avec les arguments.

Rappelez-vous que arguments[0] sera toujours le chemin d’accès au programme, y compris le nom du fichier Swift (par exemple : ~/Desktop/Script/updateFiles.swift).

Cette semaine, j’ai dû mettre à jour des centaines de include instructions dans un ensemble de fichiers C++. La tâche est ennuyeuse à faire manuellement, alors je l’ai scriptée en utilisant Swift.

Je ne peux pas partager le code exact, mais je peux partager la structure que j’ai utilisée et le processus que j’ai suivi pour le créer.

j’ai commencé à créer mon main fonction et l’invoquer, car c’est la base de tout script :

import Foundation
func main() {
}
main()

Ensuite, j’avais besoin du chemin d’accès à un dossier contenant des fichiers C++. J’ai ajouté une analyse d’arguments pour m’assurer que le script a tout ce dont il a besoin pour fonctionner correctement :

func main() {
if CommandLine.argc != 2 {
let help = "Invoke the script with `swift updateFiles <path_to_the_folder>`"
print("Wrong number of arguments.n(help)")
exit(1)
}
let args = CommandLine.arguments
let path = args[1]
}
main()

Le code vérifie le nombre de paramètres et s’il est incorrect, il imprime une erreur significative. Même si je suis le seul client de ce script, je ne veux pas perdre des heures interminables à le déboguer : des messages d’erreur significatifs sont toujours utiles !

L’étape suivante consistait à utiliser le dossier passé comme path paramètre. Je voulais lister tous les fichiers contenus dans le dossier puis les traiter un par un :

func main() {
if CommandLine.argc != 2 {
let help = "Invoke the script with `swift updateFiles <path_to_the_folder>`"
print("Wrong number of arguments.n(help)")
exit(1)
}
let args = CommandLine.arguments
let path = args[1]
let fm = FileManager.default
let files = try! fm.contentsOfDirectory(atPath: path)
files.forEach { file in
do {
} catch {
print("Failed to process file: (file). The error is (error)")
}
}
}
main()

Le script récupère une référence à la valeur par défaut FileManager, une classe fournie par le framework Foundation pour gérer le système de fichiers. A l’aide de ses méthodes, le code récupère le contenu du répertoire passé par l’utilisateur.

Le script frappe le try. Dans ce cas, il est acceptable d’échouer durement si le chemin transmis n’est pas un dossier valide. L’erreur serait imprimée dans la console avec sa trace de pile.

Enfin, j’avais besoin de traiter ces fichiers. j’ai préparé un do-catch clause pour invoquer une fonction d’assistance pour ma logique. De cette façon, la logique métier du script peut être séparée du code d’infrastructure.

func processFile(
path: String,
fileName: String,
using fm: FileManager
) throws {
// Read
let file = "(path)/(fileName)"
guard file.hasSuffix(".h") || file.hasSuffix(".cpp") || file.hasSuffix(".mm") else {
return []
}
let content = try String(contentsOfFile: file)
let lines = content.split(separator: "n", omittingEmptySubsequences: false).map(String.init)
// Do your stuff
let (newLines, shouldUpdateFile) = replaceIncludeDirectives(lines: lines)
guard shouldUpdateFile else { return [] }
// Write
let newFileContent = newLines.joined(separator: "n")
try fm.moveItem(atPath: file, toPath: "(path)/old_(fileName)")
try newFileContent.write(to: URL(fileURLWithPath: file), atomically: true, encoding: .utf8)
}
func main() {
if CommandLine.argc != 2 {
let help = "Invoke the script with `swift updateFiles <path_to_the_folder>`"
print("Wrong number of arguments.n(help)")
exit(1)
}
let args = CommandLine.arguments
let path = args[1]
let fm = FileManager.default
let files = try! fm.contentsOfDirectory(atPath: path)
files.forEach { file in
do {
try processFile(path: path, fileName: file, using: fm)
} catch {
print("Failed to process file: (file). The error is (error)")
}
}
}
main()

Cet extrait ajoute un processFile fonction sur le dessus (suivant la structure suggérée) qui :

1. Vérifie que le fichier existe et qu’il est du type correct.
2. Lit le fichier.
3. Le divise en lignes.
4. Invoque une autre fonction utilitaire pour exécuter le traitement réel.
5. Sauvegarde l’ancien fichier.
6. Écrit le nouveau fichier sur le disque.

Notez que cette méthode a une structure similaire de la main dossier:

• Validation (existence du fichier et filtrage)
• Préparation (lisez le fichier et divisez-le en lignes)
• Délégation (utiliser une méthode d’assistance pour la logique métier)
• Post-traitement (écrire le fichier)

Bien que les scripts soient moins élaborés que les logiciels appropriés, ils pourraient bénéficier des principes que nous devrions appliquer lorsque nous traitons avec des logiciels qui doivent vivre longtemps. Dans ce cas, chaque fonction de script a une responsabilité spécifique (suivant le Principe de responsabilité unique) : exécutez le programme principal ou les opérations d’E/S sur un seul fichier.

Le code de replaceIncludeDirectives ne seront pas présentés, mais ce n’est pas pertinent pour l’article. Vous pouvez remplacer cette méthode par n’importe quelle logique que vous devez implémenter pour modifier réellement un fichier.

Aujourd’hui, vous avez appris à utiliser Swift pour écrire des scripts. C’est une compétence utile pour automatiser les tâches manuelles ennuyeuses qui se produisent de temps en temps au travail. Ce script simple a nécessité quelques heures pour être écrit et testé, mais il m’a épargné une semaine de travail manuel et fastidieux.

Nous avons utilisé ce cas d’utilisation pour discuter des principales différences entre le génie logiciel et le développement de logiciels, en remarquant que le scripting ne nécessite pas de suivre toutes les bonnes pratiques du génie logiciel. Mais une structure appropriée et d’autres pratiques sont toujours utiles, même pour les scripts.

J’ai vraiment aimé utiliser Swift comme langage de script, et c’est un moyen incroyable d’accélérer les tâches répétitives pour être plus productif et efficace.