'
Articles

Carthage / Carthage

author
23 minutes, 19 seconds Read

Carthage est destiné à être le moyen le plus simple d’ajouter des frameworks à votre application Cocoa.

Carthage construit vos dépendances et vous fournit des frameworks binaires, mais vous conservez le contrôle total sur la structure et la configuration de votre projet. Carthage ne modifie pas automatiquement vos fichiers de projet ou vos paramètres de construction.

  • Démarrage rapide
  • Installation de Carthage
  • Ajout de frameworks à une application
    • Démarrage
      • Construction de frameworks XCFrameworks
        • indépendants de la plate-forme.indépendante de la plateforme
          • Migration d’un projet de bundles de frameworks vers XCFrameworks
        • Construction de bundles de frameworks spécifiques à la plateforme
          • Si vous construisez pour macOS
          • Si vous construisez pour iOS, tvOS, ou watchOS
        • Pour toutes les plateformes
        • (Optionnellement) Ajouter une phase de construction pour avertir des dépendances périmées
        • Compatibilité de téléchargement du framework binaire Swift

        .

      • Exécution d’un projet qui utilise Carthage
      • Ajout de frameworks aux tests unitaires ou à un framework
      • Mise à niveau des frameworks
        • Résolveur expérimental
      • Dépendances imbriquées. dépendances
      • Utilisation de submodules pour les dépendances
      • Reconstruction automatique des dépendances
      • Mise en cache des builds
      • Finalisation de Bash/Zsh/Fish
    • Prise en charge de Carthage pour votre framework
      • Partager vos schémas Xcode
      • Résoudre les échecs de construction
      • Taguer les versions stables
      • Archiver les frameworks préconstruits dans un fichier zip
        • Utiliser travis-ci pour télécharger vos frameworks préconstruits étiquetés
      • Construisez des frameworks statiques pour accélérer les temps de lancement de votre application
      • Déclarez votre compatibilité
    • Problèmes connus
      • Problème de symboles DWARFs
    • CarthageKit
    • Différences entre Carthage et CocoaPods
    • License

    Démarrage rapide

    1. Générez Carthage en exécutant brew install carthage ou choisissez une autre méthode d’installation

    2. Créer un Cartfile dans le même répertoire où se trouve votre .xcodeproj ou .xcworkspace

    3. Lister les dépendances souhaitées dans le Cartfile, par exemple :

      github "Alamofire/Alamofire" ~> 4.7.2

    4. Exécutez carthage update --use-xcframeworks

    5. Un fichier Cartfile.resolved et un répertoire Carthage apparaîtront dans le même répertoire où se trouve votre .xcodeproj ou .xcworkspace

    6. Glissez les paquets .xcframework construits de Carthage/Build dans la section « Frameworks and Libraries » du projet Xcode de votre application.

    7. Si vous utilisez Carthage pour une application, sélectionnez « Embed & Sign », sinon « Do Not Embed ».

    Pour un guide approfondi, lisez la suite de Adding frameworks to an application

    Installing Carthage

    Il existe plusieurs options pour installer Carthage:

    • Installer : Téléchargez et exécutez le fichier Carthage.pkg pour la dernière version, puis suivez les instructions à l’écran. Si vous installez le pkg via CLI, vous devrez peut-être exécuter sudo chown -R $(whoami) /usr/local d’abord.

    • Homebrew : Vous pouvez utiliser Homebrew et installer l’outil carthage sur votre système simplement en exécutant brew update et brew install carthage. (note : si vous avez précédemment installé la version binaire de Carthage, vous devez supprimer /Library/Frameworks/CarthageKit.framework).

    • MacPorts : Vous pouvez utiliser MacPorts et installer l’outil carthage sur votre système simplement en exécutant sudo port selfupdate et sudo port install carthage. (note : si vous avez précédemment installé la version binaire de Carthage, vous devez supprimer /Library/Frameworks/CarthageKit.framework).

    • Depuis la source : Si vous souhaitez exécuter la dernière version de développement (qui peut être très instable ou incompatible), il suffit de cloner la branche master du dépôt, puis d’exécuter make install. Requiert Xcode 10.0 (Swift 4.2).

    Ajouter des frameworks à une application

    Une fois que vous avez installé Carthage, vous pouvez commencer à ajouter des frameworks à votre projet. Notez que Carthage ne prend en charge que les frameworks dynamiques, qui ne sont disponibles que sur iOS 8 ou plus récent (ou toute version d’OS X).

    Début

    Construction de XCFrameworks indépendants de la plateforme (Xcode 12 et plus)

    1. Créer un Cartfile qui liste les frameworks que vous souhaitez utiliser dans votre projet.
    2. Exécuter carthage update --use-xcframeworks. Cela récupérera les dépendances dans un dossier Carthage/Checkouts et construira chacune d’entre elles ou téléchargera un XCFramework précompilé.
    3. Sur l’onglet Paramètres généraux des cibles de votre application, dans la section Cadres, bibliothèques et contenu intégré, faites glisser et déposez chaque XCFramework que vous souhaitez utiliser à partir du dossier Carthage/Build sur le disque.
    Migration d’un projet des bundles de frameworks vers XCFrameworks

    Nous encourageons l’utilisation de XCFrameworks à partir de la version 0.37.0 (janvier 2021), et nous exigeons XCFrameworks lors de la construction sur un Apple Silicon Mac. Passer des bundles de frameworks discrets à XCFrameworks nécessite quelques modifications de votre projet :

    Étapes de migration

    1. Supprimer votre dossier Carthage/Build pour supprimer tous les bundles de frameworks existants.
    2. Construire de nouveaux XCFrameworks en exécutant carthage build --use-xcframeworks. Tout autre argument avec lequel vous construisez peut être fourni comme d’habitude.
    3. Supprimez les références aux anciens frameworks dans chacune de vos cibles :
      • Supprimez les références aux frameworks Carthage de la section Frameworks, Libraries, and Embedded Content de la cible et/ou de sa phase de construction Link Binary with Libraries.
      • Supprimez les références aux frameworks Carthage de toute phase de construction Copy Files.
      • Supprimez la phase de construction carthage copy-frameworks de la cible, si elle est présente.
    4. Ajoutez des références aux XCFrameworks dans chacune de vos cibles :
      • Pour une cible d’application : dans l’onglet Paramètres généraux, dans la section Cadres, bibliothèques et contenu intégré, faites glisser et déposez chaque XCFramework que vous utilisez à partir du dossier Carthage/Build sur le disque.
      • Pour une cible de framework : dans l’onglet Phases de construction, dans une phase Lier le binaire avec les bibliothèques, faites glisser et déposez chaque XCFramework que vous utilisez depuis le dossier Carthage/Build sur le disque.

    Construction de paquets de frameworks spécifiques à une plateforme (par défaut pour Xcode 11 et inférieur)

    Incompatibilité avec Xcode 12+ : Les plateformes multi-architectures ne sont pas prises en charge lors de la construction de bundles de frameworks dans Xcode 12 et plus. Préférez la construction avec XCFrameworks. Si vous devez construire des bundles de frameworks discrets, utilisez un fichier xcconfig de contournement.

    Si vous construisez pour macOS

    instructions spécifiques à macOS

    1. Créer un Cartfile qui liste les frameworks que vous souhaitez utiliser dans votre projet.
    2. Exécuter carthage update --platform macOS. Cela récupérera les dépendances dans un dossier Carthage/Checkouts et construira chacune d’entre elles ou téléchargera un framework précompilé.
    3. Sur l’onglet Paramètres généraux de vos cibles d’application, dans la section Binaires embarqués, faites glisser et déposez chaque framework que vous souhaitez utiliser à partir du dossier Carthage/Build sur le disque.

    En outre, vous devrez copier les symboles de débogage pour le débogage et le rapport de panne sur OS X.

    1. Sur l’onglet des paramètres des phases de construction de votre cible d’application, cliquez sur l’icône + et choisissez Nouvelle phase de copie de fichiers.
    2. Cliquez sur le menu déroulant Destination et sélectionnez Répertoire des produits.
    3. Pour chaque framework que vous utilisez, faites glisser et déposez son fichier dSYM correspondant.
    Si vous construisez pour iOS, tvOS ou watchOS

    Instructions spécifiques à la plateforme

    1. Créer un Cartfile qui liste les frameworks que vous souhaitez utiliser dans votre projet.

    2. Exécuter carthage update. Cela va récupérer les dépendances dans un dossier Carthage/Checkouts, puis construire chacune d’entre elles ou télécharger un framework précompilé.

    3. Ouvrir l’onglet Paramètres généraux des cibles de votre application. Pour Xcode 11.0 et les versions ultérieures, dans la section « Cadres, bibliothèques et contenu intégré », faites glisser et déposez chaque cadre que vous souhaitez utiliser depuis le dossier Carthage/Build sur le disque. Ensuite, dans la section « Embed », sélectionnez « Do Not Embed » dans le menu déroulant pour chaque élément ajouté. Pour Xcode 10.x et inférieur, dans la section « Cadres et bibliothèques liés », faites glisser et déposez chaque cadre que vous voulez utiliser à partir du dossier Carthage/Build sur le disque.

    4. Sur l’onglet des paramètres des phases de construction de vos cibles d’application, cliquez sur l’icône + et choisissez Nouvelle phase de script d’exécution. Créez un script d’exécution dans lequel vous spécifiez votre shell (ex : /bin/sh), ajoutez le contenu suivant à la zone de script sous le shell :

      /usr/local/bin/carthage copy-frameworks

    5. Créer un fichier nommé input.xcfilelist et un fichier nommé output.xcfilelist

    6. Ajouter les chemins d’accès aux frameworks que vous voulez utiliser à votre input.xcfilelist. Par exemple:

      $(SRCROOT)/Carthage/Build/iOS/Result.framework$(SRCROOT)/Carthage/Build/iOS/ReactiveSwift.framework$(SRCROOT)/Carthage/Build/iOS/ReactiveCocoa.framework

    7. Ajoutez les chemins vers les frameworks copiés dans le output.xcfilelist. Par exemple:

      $(BUILT_PRODUCTS_DIR)/$(FRAMEWORKS_FOLDER_PATH)/Result.framework$(BUILT_PRODUCTS_DIR)/$(FRAMEWORKS_FOLDER_PATH)/ReactiveSwift.framework$(BUILT_PRODUCTS_DIR)/$(FRAMEWORKS_FOLDER_PATH)/ReactiveCocoa.framework

      Avec les fichiers de sortie spécifiés à côté des fichiers d’entrée, Xcode n’a besoin d’exécuter le script que lorsque les fichiers d’entrée ont changé ou que les fichiers de sortie sont manquants. Cela signifie que les dirty builds seront plus rapides lorsque vous n’avez pas reconstruit les frameworks avec Carthage.

    8. Ajouter le input.xcfilelist à la section « Listes de fichiers d’entrée » de la phase de script d’exécution de Carthage

    9. Ajouter le output.xcfilelist à la section « Listes de fichiers de sortie » de la phase de script d’exécution de Carthage

    Ce script contourne un bogue de soumission à l’App Store déclenché par les binaires universels et garantit que les fichiers nécessaires liés au bitcode et les dSYM sont copiés lors de l’archivage.

    Avec les informations de débogage copiées dans le répertoire des produits construits, Xcode sera capable de symboliser la trace de la pile chaque fois que vous vous arrêtez à un point d’arrêt. Cela vous permettra également d’avancer dans le code tiers dans le débogueur.

    Lorsque vous archivez votre application pour la soumettre à l’App Store ou à TestFlight, Xcode copiera également ces fichiers dans le sous-répertoire dSYMs du .xcarchive bundle de votre application.

    Pour toutes les plateformes

    En cours de route, Carthage aura créé certains artefacts de construction. Le plus important d’entre eux est le fichier Cartfile.resolved, qui liste les versions qui ont été effectivement construites pour chaque framework. Assurez-vous de commettre votre Cartfile.resolved, car toute autre personne utilisant le projet aura besoin de ce fichier pour construire les mêmes versions de frameworks.

    (Optionnellement) Ajouter une phase de construction pour avertir des dépendances périmées

    Vous pouvez ajouter une phase Run Script pour vous avertir automatiquement lorsqu’une de vos dépendances est périmée.

    1. Sur l’onglet des paramètres de vos cibles d’application Build Phases, cliquez sur l’icône + et choisissez New Run Script Phase. Créez un script d’exécution dans lequel vous spécifiez votre shell (ex : /bin/sh), ajoutez le contenu suivant dans la zone de script sous le shell :
    /usr/local/bin/carthage outdated --xcode-warnings 2>/dev/null

    Compatibilité du téléchargement du framework binaire Swift

    Carthage vérifiera que les frameworks Swift (et mixtes Objective-C/Swift) téléchargés ont été construits avec la même version de Swift qui est utilisée localement. S’il y a un décalage de version, Carthage procédera à la construction du framework à partir des sources. Si le framework ne peut pas être construit à partir des sources, Carthage échouera.

    Parce que Carthage utilise la sortie de xcrun swift --version pour déterminer la version locale de Swift, assurez-vous d’exécuter les commandes Carthage avec la chaîne d’outils Swift que vous avez l’intention d’utiliser. Pour de nombreux cas d’utilisation, rien de supplémentaire n’est nécessaire. Cependant, par exemple, si vous construisez un projet Swift 2.3 en utilisant Xcode 8.x, une approche pour spécifier votre swift par défaut pour carthage bootstrap est d’utiliser la commande suivante :

    TOOLCHAINS=com.apple.dt.toolchain.Swift_2_3 carthage bootstrap

    Exécuter un projet qui utilise Carthage

    Après avoir terminé les étapes ci-dessus et poussé vos changements, les autres utilisateurs du projet n’ont qu’à récupérer le dépôt et exécuter carthage bootstrap pour commencer à utiliser les frameworks que vous avez ajoutés.

    Ajouter des frameworks aux tests unitaires ou à un framework

    Utiliser Carthage pour les dépendances de n’importe quelle cible arbitraire est assez similaire à utiliser Carthage pour une application. La principale différence réside dans la façon dont les frameworks sont réellement configurés et liés dans Xcode.

    Parce que les cibles de tests unitaires manquent la section Linked Frameworks and Libraries dans leur onglet General settings, vous devez plutôt faire glisser les frameworks construits vers la phase de construction Link Binaries With Libraries.

    Dans la cible de test sous l’onglet Paramètres de construction, ajoutez @loader_path/Frameworks aux chemins de recherche Runpath s’ils ne sont pas déjà présents.

    Dans de rares cas, vous pouvez également copier chaque dépendance dans le produit de construction (par ex, pour intégrer les dépendances dans le framework externe, ou s’assurer que les dépendances sont présentes dans un bundle de test). Pour ce faire, créez une nouvelle phase de build Copy Files avec la destination Frameworks, puis ajoutez-y également la référence du framework. Vous ne devriez pas utiliser la commande carthage copy-frameworks puisque les bundles de test n’ont pas besoin de frameworks dépouillés, et l’exécution d’instances simultanées de copy-frameworks (avec les constructions parallèles activées) n’est pas supportée.

    Mise à niveau des frameworks

    Si vous avez modifié votre Cartfile, ou si vous voulez mettre à jour vers les versions les plus récentes de chaque framework (sous réserve des exigences que vous avez spécifiées), exécutez simplement la commande carthage update à nouveau.

    Si vous voulez seulement mettre à jour une, ou des, dépendances spécifiques, passez-les comme une liste séparée par des espaces à la commande update. par exemple 

    carthage update Box

    ou

    carthage update Box Result
    Résolveur expérimental

    Une réécriture de la logique de mise à niveau des frameworks a été faite dans le but d’augmenter la vitesse et de réduire l’utilisation de la mémoire. Il s’agit actuellement d’une fonctionnalité opt-in. Elle peut être utilisée en passant --new-resolver à la commande de mise à jour, par exemple,

    carthage update --new-resolver Box

    Si vous rencontrez des problèmes de performance lors des mises à jour, veuillez essayer le nouveau résolveur

    Dépendances imbriquées

    Si le framework que vous voulez ajouter à votre projet a des dépendances explicitement listées dans un Cartfile, Carthage les récupérera automatiquement pour vous. Vous devrez ensuite les glisser vous-même dans votre projet depuis le dossier Carthage/Build.

    Si le framework intégré dans votre projet a des dépendances vers d’autres frameworks, vous devez les lier à la cible de l’application (même si la cible de l’application n’a pas de dépendance vers ces frameworks et ne les utilise jamais).

    Utiliser des submodules pour les dépendances

    Par défaut, Carthage extraira directement les fichiers sources des dépendances dans le dossier de votre projet, vous laissant le soin de les commiter ou de les ignorer comme vous le souhaitez. Si vous souhaitez avoir des dépendances disponibles en tant que submodules Git à la place (peut-être pour que vous puissiez commiter et pousser des changements en leur sein), vous pouvez exécuter carthage update ou carthage checkout avec le drapeau --use-submodules.

    Lorsqu’il est exécuté de cette façon, Carthage écrira dans les fichiers .gitmodules et .git/config de votre dépôt, et mettra automatiquement à jour les submodules lorsque les versions des dépendances changent.

    Reconstruction automatique des dépendances

    Si vous voulez travailler sur vos dépendances pendant le développement, et que vous voulez qu’elles soient automatiquement reconstruites lorsque vous construisez votre projet parent, vous pouvez ajouter une phase de construction Run Script qui invoque Carthage comme suit:

    /usr/local/bin/carthage build --platform "$PLATFORM_NAME" --project-directory "$SRCROOT"

    Notez que vous devriez utiliser des submodules avant de faire cela, car les checkouts simples ne doivent pas être modifiés directement.

    Mise en cache des builds

    Par défaut, Carthage reconstruira une dépendance indépendamment du fait qu’il s’agisse de la même version résolue que précédemment. Passer le --cache-builds fera en sorte que carthage évite de reconstruire une dépendance s’il le peut. Voir les informations sur les fichiers de version pour plus de détails sur la façon dont Carthage effectue cette mise en cache.

    Note : Pour le moment, --cache-builds est incompatible avec --use-submodules. L’utilisation des deux aura pour résultat que la copie de travail et les modifications commises à votre dépendance de sous-module ne seront pas correctement reconstruites. Voir #1785 pour plus de détails.

    Complétion Bash/Zsh/Fish

    La complétion automatique des commandes et des options de Carthage est disponible comme documenté dans Bash/Zsh/Fish Completion.

    Prise en charge de Carthage pour votre framework

    Carthage ne prend officiellement en charge que les frameworks dynamiques. Les frameworks dynamiques peuvent être utilisés sur n’importe quelle version d’OS X, mais seulement sur iOS 8 ou plus. En outre, depuis la version 0.30.0, Carthage prend en charge les frameworks statiques.

    Parce que Carthage n’a pas de liste de paquets centralisée, ni de format de spécification de projet, la plupart des frameworks devraient se construire automatiquement.

    Les exigences spécifiques de tout projet de framework sont listées ci-dessous.

    Partagez vos schémas Xcode

    Carthage ne construira que les schémas Xcode qui sont partagés depuis votre .xcodeproj. Vous pouvez voir si tous vos schémas prévus se construisent avec succès en exécutant carthage build --no-skip-current, puis en vérifiant le dossier Carthage/Build.

    Si un schéma important n’est pas construit lorsque vous exécutez cette commande, ouvrez Xcode et assurez-vous que le schéma est marqué comme partagé, afin que Carthage puisse le découvrir.

    Résoudre les échecs de construction

    Si vous rencontrez des échecs de construction dans carthage build --no-skip-current, essayez d’exécuter xcodebuild -scheme SCHEME -workspace WORKSPACE build ou xcodebuild -scheme SCHEME -project PROJECT build (avec les valeurs réelles) et voyez si le même échec se produit là. Cela devrait, espérons-le, donner suffisamment d’informations pour résoudre le problème.

    Si vous avez plusieurs versions des outils de développement Apple installées (une bêta de Xcode, par exemple), utilisez xcode-select pour changer la version que Carthage utilise.

    Si vous n’êtes toujours pas en mesure de construire votre framework avec Carthage, veuillez ouvrir un problème et nous serons heureux de vous aider !

    Tag stable releases

    Carthage détermine quelles versions de votre framework sont disponibles en recherchant parmi les tags publiés sur le dépôt, et en essayant d’interpréter chaque nom de tag comme une version sémantique. Par exemple, dans la balise v1.2, la version sémantique est 1.2.0.

    Les balises sans aucun numéro de version, ou avec des caractères suivant le numéro de version (par ex, 1.2-alpha-1) ne sont actuellement pas prises en charge et seront ignorées.

    Archiver les frameworks préconstruits dans un fichier zip

    Carthage peut utiliser automatiquement des frameworks préconstruits, au lieu de construire à partir de zéro, s’ils sont attachés à une Release GitHub sur le dépôt de votre projet ou via un fichier de définition de projet binaire.

    Pour offrir des frameworks préconstruits pour un tag spécifique, les binaires pour toutes les plateformes supportées doivent être zippés ensemble dans une archive, et cette archive doit être attachée à une Release publiée correspondant à ce tag. La pièce jointe doit inclure .framework dans son nom (par exemple, ReactiveCocoa.framework.zip), pour indiquer à Carthage qu’elle contient des binaires. La structure de répertoire de l’archive est libre mais, les cadres ne doivent apparaître qu’une seule fois dans l’archive car ils seront copiés dans Carthage/Build/<platform> en fonction de leur nom (par exemple ReactiveCocoa.framework).

    Vous pouvez effectuer l’opération d’archivage avec carthage lui-même en utilisant:

    -carthage build --no-skip-current-carthage archive YourFrameworkName

    ou alternativement

    carthage build --archive

    Les ébauches de releases seront automatiquement ignorées, même si elles correspondent à l’étiquette souhaitée.

    Utiliser travis-ci pour télécharger vos frameworks pré-construits tagués

    Il est possible d’utiliser travis-ci afin de construire et de télécharger vos releases tagués.

    1. Installer travis CLI avec gem install travis

    2. Configurer travis-ci pour votre dépôt (étapes 1 et 2)

    3. Créer le fichier .travis.yml à la racine de votre dépôt basé sur ce modèle. Définissez FRAMEWORK_NAME à la valeur correcte.

      Remplacez PROJECT_PLACEHOLDER et SCHEME_PLACEHOLDER

      Si vous utilisez un espace de travail au lieu d’un projet, supprimez la ligne xcode_project et décommentez la ligne xcode_workspace.

      Le projet doit être au format : MonProjet.xcodeproj

      L’espace de travail doit être au format : MonEspace de Travail.xcworkspace

      N’hésitez pas à mettre à jour la valeur xcode_sdk vers un autre SDK, notez que le test sur le SDK iphoneos nécessiterait de télécharger une identité de signature de code

      Pour plus d’informations, vous pouvez visiter les docs travis pour les projets objective-c

      language: objective-cosx_image: xcode7.3xcode_project: <PROJECT_PLACEHOLDER># xcode_workspace: <WORKSPACE_PLACEHOLDER>xcode_scheme: <SCHEME_PLACEHOLDER>xcode_sdk: iphonesimulator9.3env: global: - FRAMEWORK_NAME=<THIS_IS_A_PLACEHOLDER_REPLACE_ME>before_install: - brew update - brew outdated carthage || brew upgrade carthagebefore_script: # bootstrap the dependencies for the project # you can remove if you don't have dependencies - carthage bootstrapbefore_deploy: - carthage build --no-skip-current - carthage archive $FRAMEWORK_NAME

    4. Run travis setup releases, suivez la documentation ici

      Cette commande codera vos informations d’identification GitHub dans le fichier .travis.yml afin de permettre à travis de télécharger la version sur GitHub.comLorsque l’on vous demande le fichier à télécharger, entrez $FRAMEWORK_NAME.framework.zip

    5. Mettre à jour la section de déploiement pour qu’elle soit exécutée sur les balises:

      Dans .travis.yml localiser:

      on: repo: repo/repo

      Et ajouter tags: true et skip_cleanup: true :

      skip_cleanup: trueon: repo: repo/repo tags: true

      Ceci permettra à travis de savoir qu’il faut créer un déploiement lorsqu’un nouveau tag est poussé et empêchera travis de nettoyer le fichier zip généré

    Construire des frameworks statiques pour accélérer les temps de lancement de votre app

    Si vous intégrez de nombreux frameworks dynamiques dans votre app, ses temps de lancement pré-main peuvent être assez lents. Carthage est capable d’aider à atténuer ce problème en construisant vos frameworks dynamiques comme des frameworks statiques à la place. Les frameworks statiques peuvent être liés directement à votre application ou fusionnés dans un framework dynamique plus important avec quelques modifications simples de votre flux de travail, ce qui peut entraîner des réductions spectaculaires des temps de lancement pré-main.

    Carthage 0.30.0 ou supérieur

    Depuis la version 0.30.0, le projet Carthage déploie le support des frameworks liés statiquement écrits en Swift ou Objective-C, dont le support a été introduit dans Xcode 9.4. Notez cependant qu’il est spécifiquement question de frameworks, d’où les bundles Darwin avec une extension .framework et des archives d’objets liés statiquement à l’intérieur. Carthage ne prend actuellement pas en charge les schémas de bibliothèques statiques, et il n’est pas prévu d’introduire leur prise en charge à l’avenir.

    Le flux de travail diffère à peine :

    • Vous devez toujours cocher les schémas de votre projet conforme à Carthage comme partagé dans Produit > Schéma > Gérer les schémas…, tout comme avec les binaires dynamiques
    • Vous devez toujours lier contre les .frameworks dans les phases de construction de votre projet, tout comme avec les binaires dynamiques

    Mais :

    • Dans la cible Cocoa Framework de votre projet conforme à Carthage, dans les paramètres de construction, section Liaison, définissez le type Mach-O sur Static Library
    • Vos frameworks liés statiquement seront construits à ./Carthage/Build/$(PLATFORM_NAME)/Static
    • Vous ne devez ajouter aucun des frameworks statiques comme fichiers d’entrée/sortie dans carthage copy-frameworks Build Phase

    Carthage 0.29.0 ou inférieur

    Voir la doc StaticFrameworks pour plus de détails.

    Veuillez noter que quelques mises en garde s’appliquent à cette approche :

    • Les frameworks statiques Swift ne sont pas officiellement pris en charge par Apple
    • C’est un flux de travail avancé qui n’est pas intégré à Carthage, YMMV

    Déclarez votre compatibilité

    Vous voulez annoncer que votre projet peut être utilisé avec Carthage ? Vous pouvez ajouter un badge de compatibilité:

    … à votre README, en insérant simplement le Markdown suivant:

    (https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)

    Problèmes connus

    Problème de symbole DWARFs

    Le framework préconstruit ne peut pas être débogué en utilisant l’exécution de pas sur une autre machine que celle sur laquelle le framework a été construit. Simplement carthage bootstrap/build/update --no-use-binaries devrait corriger cela, mais pour une solution de contournement plus automatisée, voir #924. Dupe rdar://23551273 si vous voulez qu’Apple corrige la cause première de ce problème.

    CarthageKit

    La plupart des fonctionnalités de l’outil de ligne de commande carthage sont en fait encapsulées dans un framework nommé CarthageKit.

    Si vous êtes intéressé par l’utilisation de Carthage dans le cadre d’un autre outil, ou peut-être par l’extension des fonctionnalités de Carthage, jetez un œil au code source de CarthageKit pour voir si l’API correspond à vos besoins.

    Différences entre Carthage et CocoaPods

    CocoaPods est un gestionnaire de dépendances de longue date pour Cocoa. Alors pourquoi Carthage a-t-il été créé ?

    Tout d’abord, CocoaPods (par défaut) crée et met à jour automatiquement un espace de travail Xcode pour votre application et toutes les dépendances. Carthage construit des binaires de framework en utilisant xcodebuild, mais laisse la responsabilité de leur intégration à l’utilisateur. L’approche de CocoaPods est plus facile à utiliser, tandis que celle de Carthage est flexible et discrète.

    Le but de CocoaPods est listé dans son README comme suit :

    … améliorer la découvrabilité et l’engagement dans les bibliothèques open-source tierces, en créant un écosystème plus centralisé.

    En revanche, Carthage a été créé comme un gestionnaire de dépendances décentralisé. Il n’y a pas de liste centrale de projets, ce qui réduit le travail de maintenance et évite tout point central de défaillance. Cependant, la découverte des projets est plus difficile – les utilisateurs doivent recourir aux pages Trending de GitHub ou à d’autres pages similaires.

    Les projets CocoaPods doivent également avoir ce que l’on appelle un fichier podspec, qui comprend des métadonnées sur le projet et spécifie comment il doit être construit. Carthage utilise xcodebuild pour construire les dépendances, au lieu de les intégrer dans un seul espace de travail, il n’a pas de fichier de spécification similaire mais vos dépendances doivent inclure leur propre projet Xcode qui décrit comment construire leurs produits.

    En fin de compte, nous avons créé Carthage parce que nous voulions l’outil le plus simple possible-un gestionnaire de dépendances qui fait le travail sans prendre la responsabilité de Xcode, et sans créer de travail supplémentaire pour les auteurs de frameworks. CocoaPods offre de nombreuses fonctionnalités étonnantes que Carthage n’aura jamais, au prix d’une complexité supplémentaire.

    Licence

    Carthage est publié sous la licence MIT.

    La photo de la toile de fond de l’en-tête est publiée sous la licence CC BY-NC-SA 2.0. Photo originale par Richard Mortel.

Similar Posts

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.