Carthage / Carthage

Carthage is bedoeld als de eenvoudigste manier om frameworks aan je Cocoa applicatie toe te voegen.

Carthage bouwt je dependencies en voorziet je van binaire frameworks, maar je behoudt volledige controle over je project structuur en setup. Carthage wijzigt niet automatisch uw project bestanden of uw bouw-instellingen.

• Kort begin
• Carthage installeren
• Frameworks toevoegen aan een applicatie
  • Aan de slag
    • Platform-onafhankelijke XCFrameworks
      • Migreren van een project van framework bundels naar XCFrameworks
    • Bouwen van platform-specifieke framework bundels
      • Als u bouwt voor macOS
      • Als u bouwt voor iOS, tvOS, of watchOS
    • Voor alle platforms
    • (Optioneel) Voeg bouwfase toe om te waarschuwen voor verouderde afhankelijkheden
    • Swift binary framework download compatibiliteit
  • Het uitvoeren van een project dat Carthage gebruikt
  • Het toevoegen van frameworks aan unit tests of een framework
  • Het upgraden van frameworks
    • Experimentele Resolver
  • Nested afhankelijkheden
  • Het gebruik van submodules voor afhankelijkheden
  • Automatisch herbouwen van afhankelijkheden
  • Caching builds
  • Bash/Zsh/Fish completion
• Ondersteuning van Carthage voor uw framework
  • Deel uw Xcode-schema’s
  • Oplossen van build-fouten
  • Tag stabiele releases
  • Archiveer voorgebouwde frameworks in één zip-bestand
    • Gebruik travis-ci om uw getagde prebuilt frameworks te uploaden
  • Bouw statische frameworks om de opstarttijd van uw app te versnellen
  • Geen compatibiliteit
• Bekende problemen
  • DWARFs symbool probleem
• CarthageKit
• Verschillen tussen Carthage en CocoaPods
• Licentie

Snelstart

1. Get Carthage door brew install carthage uit te voeren of kies een andere installatiemethode

2. Maak een Cartfile aan in dezelfde directory als waar uw .xcodeproj of .xcworkspace staat

3. Lijst de gewenste afhankelijkheden in de Cartfile, bijvoorbeeld:

   github "Alamofire/Alamofire" ~> 4.7.2

4. Run carthage update --use-xcframeworks

5. Er verschijnt een Cartfile.resolved bestand en een Carthage directory in dezelfde directory als waar uw .xcodeproj of .xcworkspace staat

6. Sleep de gebouwde .xcframework bundels van Carthage/Build naar de “Frameworks and Libraries” sectie van het Xcode project van uw applicatie.

7. Als u Carthage gebruikt voor een toepassing, selecteert u “Embed & Sign”, anders “Do Not Embed”.

Voor een uitgebreide handleiding, lees verder vanaf Frameworks toevoegen aan een toepassing

Carthage installeren

Er zijn meerdere opties om Carthage te installeren:

• Installer: Download het Carthage.pkg-bestand voor de laatste release en voer het uit. Volg daarna de instructies op het scherm. Als u de pkg installeert via CLI, moet u misschien eerst sudo chown -R $(whoami) /usr/local uitvoeren.

• Homebrew: U kunt Homebrew gebruiken en de carthage tool op uw systeem installeren door simpelweg brew update en brew install carthage uit te voeren. (Opmerking: als u eerder de binaire versie van Carthage hebt geïnstalleerd, moet u /Library/Frameworks/CarthageKit.framework verwijderen).

• MacPorts: U kunt MacPorts gebruiken en het hulpprogramma carthage op uw systeem installeren door eenvoudig sudo port selfupdate en sudo port install carthage uit te voeren. (Opmerking: als u eerder de binaire versie van Carthage hebt geïnstalleerd, moet u /Library/Frameworks/CarthageKit.framework verwijderen).

• Van broncode: Als u de laatste ontwikkelversie wilt gebruiken (die mogelijk zeer instabiel of incompatibel is), kloon dan de master-tak van de repository en voer make install uit. Vereist Xcode 10.0 (Swift 4.2).

Frameworks toevoegen aan een toepassing

Als u Carthage eenmaal hebt geïnstalleerd, kunt u beginnen met het toevoegen van frameworks aan uw project. Merk op dat Carthage alleen dynamische frameworks ondersteunt, die alleen beschikbaar zijn op iOS 8 of later (of een versie van OS X).

Aan de slag

Platformonafhankelijke XCFrameworks bouwen (Xcode 12 en hoger)

1. Maak een Cartfile waarin de frameworks staan die u in uw project wilt gebruiken.
2. Run carthage update --use-xcframeworks. Dit zal afhankelijkheden ophalen in een Carthage/Checkouts map en elk bouwen of een voorgecompileerd XCFramework downloaden.
3. Op het tabblad Algemene instellingen van uw applicatiedoelen, in de sectie Raamwerken, Bibliotheken, en Ingesloten inhoud, sleept u elk XCFramework dat u wilt gebruiken van de Carthage/Build map op schijf.

Een project migreren van framework bundels naar XCFrameworks

Wij moedigen het gebruik van XCFrameworks aan vanaf versie 0.37.0 (januari 2021), en vereisen XCFrameworks als u bouwt op een Apple Silicon Mac. Overschakelen van discrete framework bundels naar XCFrameworks vereist een paar wijzigingen in uw project:

Migratiestappen

1. Verwijder uw Carthage/Build map om alle bestaande framework bundels te verwijderen.
2. Bouw nieuwe XCFrameworks door carthage build --use-xcframeworks uit te voeren. Alle andere argumenten waarmee u bouwt, kunnen worden opgegeven zoals normaal.
3. Verwijder verwijzingen naar de oude frameworks in elk van uw targets:
   • Verwijder verwijzingen naar Carthage frameworks uit de Frameworks, Libraries, and Embedded Content sectie van de target en/of de Link Binary with Libraries build phase.
   • Verwijder verwijzingen naar Carthage frameworks uit elke Copy Files build phase.
   • Verwijder de target’s carthage copy-frameworks build phase, indien aanwezig.
4. Voeg verwijzingen naar XCFrameworks toe in elk van uw targets:
   • Voor een applicatie target: In het General settings tabblad, in de Frameworks, Libraries, and Embedded Content sectie, drag and drop elk XCFramework dat u gebruikt uit de Carthage/Build folder op schijf.
   • Voor een framework-doel: sleep op het tabblad Bouwfasen, in een Link Binary with Libraries-fase, elk XCFramework dat u gebruikt vanuit de Carthage/Build-map op schijf.

Platformspecifieke framework-bundels bouwen (standaard voor Xcode 11 en lager)

Xcode 12+ incompatibiliteit: Multi-architectuur platforms worden niet ondersteund bij het bouwen van framework bundels in Xcode 12 en hoger. Geef de voorkeur aan bouwen met XCFrameworks. Als u discrete framework-bundels moet bouwen, gebruik dan een workaround xcconfig-bestand.

Als u bouwt voor macOS

macOS-specifieke instructies

1. Maak een Cartfile met een lijst van de frameworks die u in uw project wilt gebruiken.
2. Uitvoeren carthage update --platform macOS. Dit zal afhankelijkheden ophalen in een Carthage/Checkouts map en elk bouwen of downloaden van een vooraf gecompileerde framework.
3. Op het tabblad Algemene instellingen van uw applicatie targets, in de Embedded Binaries sectie, sleep elk framework dat u wilt gebruiken van de Carthage/Build map op schijf.

Extra, moet je debug symbolen te kopiëren voor debuggen en crash rapportage op OS X.

1. Op het tabblad Instellingen Bouwfasen van uw toepassingsdoel, klik op het + pictogram en kies Nieuwe Kopieer Bestanden Fase.
2. Klik op het Bestemming drop-down menu en selecteer Producten Directory.
3. Voor elk framework dat u gebruikt, sleept u het corresponderende dSYM bestand.

Als u bouwt voor iOS, tvOS of watchOS

Platformspecifieke instructies

1. Maak een Cartfile met een lijst van de frameworks die u in uw project wilt gebruiken.

2. Run carthage update. Hiermee worden afhankelijkheden opgehaald in een map Carthage/Checkouts, waarna elk framework wordt gebouwd of een vooraf gecompileerd framework wordt gedownload.

3. Open het tabblad Algemene instellingen van uw toepassingsdoelen. Voor Xcode 11.0 en hoger sleept u in de sectie “Frameworks, Libraries, and Embedded Content” elk framework dat u wilt gebruiken vanuit de map Carthage/Build op schijf en zet u het neer. Selecteer vervolgens in de “Embed” sectie “Do Not Embed” uit het pulldown menu voor elk toegevoegd item. Voor Xcode 10.x en lager sleept u in de sectie “Linked Frameworks and Libraries” (Gekoppelde raamwerken en bibliotheken) elk raamwerk dat u wilt gebruiken vanuit de map Carthage/Build op schijf.

4. Op het tabblad Instellingen bouwfasen van uw toepassingsdoelen klikt u op het +-pictogram en kiest u Nieuwe run-scriptfase. Maak een Run Script waarin u uw shell specificeert (ex: /bin/sh), voeg de volgende inhoud toe aan het scriptgebied onder de shell:

   /usr/local/bin/carthage copy-frameworks

5. Maak een bestand met de naam input.xcfilelist en een bestand met de naam output.xcfilelist

6. Voeg de paden naar de frameworks die u wilt gebruiken toe aan uw input.xcfilelist. Bijvoorbeeld:

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

7. Voeg de paden naar de gekopieerde frameworks toe aan de output.xcfilelist. Bijvoorbeeld:

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

   Met uitvoerbestanden gespecificeerd naast de invoerbestanden, hoeft Xcode het script alleen uit te voeren als de invoerbestanden zijn gewijzigd of als de uitvoerbestanden ontbreken. Dit betekent dat dirty builds sneller zullen zijn wanneer je geen frameworks hebt herbouwd met Carthage.

8. input.xcfilelist toevoegen aan de sectie “Input File Lists” van de Carthage-runningscriptfase

9. output.xcfilelist toevoegen aan de sectie “Output File Lists” van de Carthage-runningscriptfase

Dit script omzeilt een App Store-indieningsfout die wordt veroorzaakt door universele binaries en zorgt ervoor dat de noodzakelijke bitcode-gerelateerde bestanden en dSYM’s worden gekopieerd bij het archiveren.

Met de debug informatie gekopieerd naar de gebouwde producten directory, zal Xcode in staat zijn om de stack trace te symboliseren wanneer u stopt bij een breakpoint. Dit stelt u ook in staat om door third-party code te stappen in de debugger.

Bij het archiveren van uw applicatie voor indiening bij de App Store of TestFlight, zal Xcode deze bestanden ook kopiëren naar de dSYMs subdirectory van de .xcarchive bundel van uw applicatie.

Voor alle platformen

Gaandeweg zal Carthage een aantal build artefacten hebben gemaakt. De belangrijkste hiervan is het Cartfile.resolved bestand, dat de versies weergeeft die daadwerkelijk gebouwd zijn voor ieder raamwerk. Zorg ervoor dat u uw Cartfile.resolved commit, omdat iedereen die het project gebruikt dat bestand nodig heeft om dezelfde framework-versies te bouwen.

(Optioneel) Voeg build-fase toe om te waarschuwen voor verouderde afhankelijkheden

U kunt een Run Script-fase toevoegen om u automatisch te waarschuwen wanneer een van uw afhankelijkheden verouderd is.

1. Op het Build Phases-instellingentabblad van uw applicatiedoelen klikt u op het +-pictogram en kiest u New Run Script Phase. Maak een Run Script waarin u uw shell specificeert (bijv. /bin/sh), voeg de volgende inhoud toe aan het scriptgebied onder de shell:

/usr/local/bin/carthage outdated --xcode-warnings 2>/dev/null

Swift binary framework download compatibiliteit

Carthage zal controleren of gedownloade Swift (en gemengde Objective-C/Swift) frameworks zijn gebouwd met dezelfde versie van Swift die lokaal in gebruik is. Als er een versie mismatch is, zal Carthage doorgaan met het bouwen van het raamwerk vanaf broncode. Als het framework niet vanaf broncode kan worden gebouwd, zal Carthage falen.

Omdat Carthage de uitvoer van xcrun swift --version gebruikt om de lokale Swift-versie te bepalen, moet je ervoor zorgen dat je Carthage commando’s uitvoert met de Swift-toolchain die je van plan bent te gebruiken. Voor veel toepassingen is niets extra’s nodig. Echter, als u bijvoorbeeld een Swift 2.3 project bouwt met Xcode 8.x, is een aanpak voor het specificeren van uw standaard swift voor carthage bootstrap het volgende commando:

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

Een project uitvoeren dat Carthage gebruikt

Nadat u de bovenstaande stappen hebt voltooid en uw wijzigingen hebt gepushed, hoeven andere gebruikers van het project alleen de repository op te halen en carthage bootstrap uit te voeren om aan de slag te gaan met de frameworks die u hebt toegevoegd.

Raamwerken toevoegen aan unit tests of een raamwerk

Het gebruik van Carthage voor de afhankelijkheden van een willekeurig doel is redelijk vergelijkbaar met het gebruik van Carthage voor een applicatie. Het belangrijkste verschil ligt in hoe de frameworks daadwerkelijk worden opgezet en gekoppeld in Xcode.

Omdat unit test targets de Linked Frameworks and Libraries sectie missen in hun General settings tab, moet je in plaats daarvan de gebouwde frameworks slepen naar de Link Binaries With Libraries build fase.

In het Testdoel onder het tabblad Bouwinstellingen, voeg @loader_path/Frameworks toe aan het Runpath Zoekpaden als het nog niet aanwezig is.

In zeldzame gevallen, wilt u misschien ook elke dependency kopiëren naar het bouwproduct (bijv, om afhankelijkheden in te bedden in het buitenste raamwerk, of om er zeker van te zijn dat afhankelijkheden aanwezig zijn in een test bundel). Om dit te doen, maak je een nieuwe Copy Files bouwfase met de bestemming Frameworks, en voeg je daar ook de framework referentie aan toe. Je zou het carthage copy-frameworks commando niet moeten gebruiken, omdat test bundels geen gestripte frameworks nodig hebben, en het draaien van gelijktijdige instanties van copy-frameworks (met parallelle builds aan) wordt niet ondersteund.

Opwaarderen van frameworks

Als je je Cartfile hebt aangepast, of je wilt updaten naar de nieuwste versies van elk framework (met inachtneming van de vereisten die je hebt opgegeven), voer dan gewoon het carthage update commando opnieuw uit.

Als u slechts een, of specifieke, afhankelijkheden wilt updaten, geef ze dan als een door spaties gescheiden lijst door aan het update commando. bijv.

carthage update Box

of

carthage update Box Result

Experimental Resolver

Een herschrijving van de logica voor het upgraden van frameworks is gedaan met het doel om de snelheid te verhogen en het geheugengebruik te verminderen. Het is momenteel een opt-in functie. Het kan gebruikt worden door --new-resolver mee te geven aan het update commando, b.v.,

carthage update --new-resolver Box

Als u prestatie problemen ondervindt tijdens updates, probeer dan de nieuwe resolver eens

Geneste afhankelijkheden

Als het framework dat u aan uw project wilt toevoegen afhankelijkheden heeft die expliciet in een Cartfile staan, zal Carthage ze automatisch voor u ophalen. Je moet ze dan zelf naar je project slepen vanuit de Carthage/Build folder.

Als het embedded framework in je project afhankelijkheden heeft naar andere frameworks moet je ze koppelen aan het applicatie doel (zelfs als het applicatie doel geen afhankelijkheid heeft naar die frameworks en ze nooit gebruikt).

Submodules gebruiken voor afhankelijkheden

Standaard zal Carthage de bronbestanden van afhankelijkheden direct in uw projectmap uitchecken, zodat u ze naar eigen keuze kunt vastleggen of negeren. Als je in plaats daarvan afhankelijkheden beschikbaar wilt hebben als Git submodules (misschien zodat je wijzigingen daarin kunt committen en pushen), kun je carthage update of carthage checkout met de --use-submodules vlag uitvoeren.

Wanneer je ze op deze manier uitvoert, zal Carthage naar de .gitmodules en .git/config bestanden van je repository schrijven, en automatisch de submodules bijwerken wanneer de versies van de afhankelijkheden veranderen.

Automatisch herbouwen van afhankelijkheden

Als u aan uw afhankelijkheden wilt werken tijdens de ontwikkeling, en u wilt dat ze automatisch herbouwd worden als u uw bovenliggend project bouwt, dan kunt u een Run Script build fase toevoegen die Carthage aanroept als volgt:

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

Merk op dat u submodules moet gebruiken voor u dit doet, omdat gewone checkouts niet rechtstreeks mogen worden gewijzigd.

Caching builds

Het is standaard dat Carthage een afhankelijkheid opnieuw opbouwt, ongeacht of het dezelfde opgeloste versie is als voorheen. Het doorgeven van --cache-builds zal ervoor zorgen dat carthage het herbouwen van een afhankelijkheid vermijdt als het kan. Zie de informatie over versiebestanden voor details over hoe Carthage deze caching uitvoert.

Note: Op dit moment is --cache-builds niet compatibel met --use-submodules. Het gebruik van beide zal resulteren in een werkkopie en gecommitteerde wijzigingen in uw submodule afhankelijkheid die niet correct worden herbouwd. Zie #1785 voor details.

Bash/Zsh/Fish completion

Auto completering van Carthage commando’s en opties zijn beschikbaar zoals gedocumenteerd in Bash/Zsh/Fish Completion.

Ondersteuning van Carthage voor uw framework

Carthage ondersteunt alleen officieel dynamische frameworks. Dynamische frameworks kunnen op elke versie van OS X gebruikt worden, maar alleen op iOS 8 of later. Daarnaast ondersteunt Carthage sinds versie 0.30.0 statische frameworks.

Omdat Carthage geen gecentraliseerde pakketlijst heeft, en geen project specificatie formaat, zouden de meeste frameworks automatisch moeten bouwen.

De specifieke vereisten van elk framework project staan hieronder vermeld.

Deel uw Xcode schema’s

Carthage zal alleen Xcode schema’s bouwen die worden gedeeld vanuit uw .xcodeproj. U kunt zien of al uw bedoelde schema’s succesvol bouwen door het uitvoeren van carthage build --no-skip-current, controleer dan de Carthage/Build map.

Als een belangrijk schema niet wordt gebouwd wanneer u dat commando uitvoert, opent u Xcode en zorg ervoor dat het schema is gemarkeerd als Shared, zodat Carthage het kan ontdekken.

Oplossen van bouwfouten

Als u bouwfouten tegenkomt in carthage build --no-skip-current, probeer dan xcodebuild -scheme SCHEME -workspace WORKSPACE build of xcodebuild -scheme SCHEME -project PROJECT build (met de werkelijke waarden) uit te voeren en kijk of dezelfde fout zich daar voordoet. Dit zou hopelijk genoeg informatie moeten opleveren om het probleem op te lossen.

Als u meerdere versies van de Apple ontwikkelaars tools heeft geïnstalleerd (een Xcode beta, bijvoorbeeld), gebruik dan xcode-select om te veranderen welke versie Carthage gebruikt.

Als het nog steeds niet lukt om je framework met Carthage te bouwen, open dan een issue en we helpen je graag!

Tag stable releases

Carthage bepaalt welke versies van je framework beschikbaar zijn door te zoeken in de tags die op de repository gepubliceerd zijn, en probeert elke tag naam te interpreteren als een semantische versie. Bijvoorbeeld, in de tag v1.2, de semantische versie is 1.2.0.

Tags zonder enig versienummer, of met tekens na het versienummer (bijv, 1.2-alpha-1) worden momenteel niet ondersteund, en zullen worden genegeerd.

Archiveer voorgebouwde frameworks in een zip-bestand

Carthage kan automatisch voorgebouwde frameworks gebruiken, in plaats van vanaf nul te bouwen, als ze zijn gekoppeld aan een GitHub Release op de repository van uw project of via een binair projectdefinitiebestand.

Om voorgebouwde frameworks voor een specifieke tag aan te bieden, moeten de binaries voor alle ondersteunde platforms samen in één archief worden gezipt, en dat archief moet worden toegevoegd aan een gepubliceerde Release die overeenkomt met die tag. De bijlage moet .framework in zijn naam bevatten (b.v. ReactiveCocoa.framework.zip), om aan Carthage aan te geven dat het binaire bestanden bevat. De mappenstructuur van het archief is vrij, maar kaders mogen slechts eenmaal in het archief voorkomen, omdat ze op basis van hun naam (bijv. ReactiveCocoa.framework) naar Carthage/Build/<platform> zullen worden gekopieerd.

U kunt de archiveringsoperatie met carthage zelf uitvoeren met:

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

of als alternatief

carthage build --archive

Ontwerpreleases worden automatisch genegeerd, zelfs als ze overeenkomen met de gewenste tag.

Gebruik travis-ci om uw getagde voorgebouwde frameworks te uploaden

Het is mogelijk om travis-ci te gebruiken om uw getagde releases te bouwen en te uploaden.

1. Installeer travis CLI met gem install travis

2. Stel travis-ci in voor je repository (Stap 1 en 2)

3. Maak .travis.yml bestand aan in de root van je repository gebaseerd op dat sjabloon. Zet FRAMEWORK_NAME op de juiste waarde.

   Vervang PROJECT_PLACEHOLDER en SCHEME_PLACEHOLDER

   Als u een werkruimte gebruikt in plaats van een project, verwijder dan de xcode_project regel en verwijder het commentaar van de xcode_workspace regel.

   Het project moet het volgende formaat hebben: MyProject.xcodeproj

   De werkruimte moet het formaat hebben: MyWorkspace.xcworkspace

   Voel u vrij om de xcode_sdk waarde te updaten naar een andere SDK, merk op dat testen op iphoneos SDK zou vereisen dat u een code signing identity

   Voor meer informatie kunt u travis docs for objective-c projects

   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, volg de documentatie hier

   Dit commando codeert uw GitHub-referenties in het .travis.yml-bestand, zodat travis de release naar GitHub kan uploaden.comWanneer u om het te uploaden bestand wordt gevraagd, voert u $FRAMEWORK_NAME.framework.zip

5. Update the deploy section to run on tags:

   In .travis.yml locate:

   on: repo: repo/repo

   En voeg tags: true en skip_cleanup: true toe:

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

   Dit laat travis weten dat er een implementatie moet worden gemaakt wanneer er een nieuwe tag wordt gepushed en voorkomt dat travis het gegenereerde zip-bestand moet opschonen

Bouw statische frameworks om de starttijd van uw app te versnellen

Als u veel dynamische frameworks in uw app inbedt, kan de starttijd voor de app behoorlijk traag zijn. Carthage kan dit verhelpen door uw dynamische frameworks als statische frameworks te bouwen. Statische frameworks kunnen direct in je applicatie worden gekoppeld of worden samengevoegd in een groter dynamisch framework met een paar eenvoudige aanpassingen in je workflow, wat kan resulteren in dramatische reducties in pre-main starttijden.

Carthage 0.30.0 of hoger

Sinds versie 0.30.0 rolt Carthage project ondersteuning uit voor statisch gekoppelde frameworks geschreven in Swift of Objective-C, ondersteuning hiervoor is geïntroduceerd in Xcode 9.4. Merk echter op dat er specifiek staat frameworks, vandaar Darwin bundels met .framework extensie en statisch gekoppelde object archieven binnen. Carthage ondersteunt momenteel geen statische bibliotheekschema’s, noch zijn er plannen om hun ondersteuning in de toekomst te introduceren.

De workflow verschilt nauwelijks:

• U moet nog steeds de schema’s van uw Carthage-compliant project aanvinken als gedeeld in Product > Scheme > Manage Schemes…, net als bij dynamische binaries
• U moet nog steeds linken tegen statische .frameworks in uw project’s Build Phases net als met dynamische binaries

Hoewel:

• In uw Carthage-compliant project’s Cocoa Framework target’s Build Settings, Linking section, set Mach-O Type to Static Library
• Uw statisch gelinkte frameworks zullen worden gebouwd op ./Carthage/Build/$(PLATFORM_NAME)/Static
• U moet geen van statische frameworks toevoegen als input/output bestanden in carthage copy-frameworks Build Phase

Carthage 0.29.0 of lager

Zie de StaticFrameworks doc voor details.

Merk op dat er een paar voorbehouden gelden voor deze aanpak:

• Swift statische frameworks worden niet officieel ondersteund door Apple
• Dit is een geavanceerde workflow die niet is ingebouwd in Carthage, YMMV

Verklaar uw compatibiliteit

Wilt u adverteren dat uw project kan worden gebruikt met Carthage? U kunt een compatibiliteitsbadge toevoegen:

… aan uw README, door eenvoudig de volgende Markdown in te voegen:

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

Bekende problemen

DWARFs symbool probleem

Gebouwd framework kan niet worden gedebugged met step executie op een andere machine dan waarop het framework is gebouwd. Gewoon carthage bootstrap/build/update --no-use-binaries zou dit moeten oplossen, maar voor een meer geautomatiseerde workaround, zie #924. Dupe rdar://23551273 als u wilt dat Apple de oorzaak van dit probleem oplost.

CarthageKit

Het grootste deel van de functionaliteit van de carthage command line tool is eigenlijk ingekapseld in een framework met de naam CarthageKit.

Als je geïnteresseerd bent in het gebruik van Carthage als onderdeel van een andere tool, of misschien het uitbreiden van de functionaliteit van Carthage, kijk dan eens naar de CarthageKit broncode om te zien of de API aan je behoeften voldoet.

Verschillen tussen Carthage en CocoaPods

CocoaPods is een al lang bestaande dependency manager voor Cocoa. Dus waarom is Carthage gemaakt?

Ten eerste, CocoaPods (standaard) maakt en update automatisch een Xcode werkruimte voor uw applicatie en alle afhankelijkheden. Carthage bouwt framework binaries met behulp van xcodebuild, maar laat de verantwoordelijkheid van de integratie van hen aan de gebruiker. CocoaPods’ aanpak is eenvoudiger te gebruiken, terwijl Carthage’s flexibel en niet opdringerig is.

Het doel van CocoaPods wordt in de README als volgt genoemd:

… om de vindbaarheid van, en betrokkenheid bij, open-source bibliotheken van derden te verbeteren, door het creëren van een meer gecentraliseerd ecosysteem.

Carthage daarentegen is gemaakt als een gedecentraliseerde afhankelijkhedenmanager. Er is geen centrale lijst van projecten, wat het onderhoud vermindert en een centraal punt van mislukking vermijdt. Projectontdekking is echter moeilijker-gebruikers moeten hun toevlucht nemen tot GitHub’s Trending-pagina’s of iets dergelijks.

CocoaPods-projecten moeten ook een zogenaamd podspec-bestand hebben, dat metadata over het project bevat en specificeert hoe het moet worden gebouwd. Carthage gebruikt xcodebuild om afhankelijkheden te bouwen, in plaats van ze te integreren in een enkele werkruimte, het heeft geen soortgelijk specificatiebestand, maar uw afhankelijkheden moeten hun eigen Xcode-project omvatten dat beschrijft hoe hun producten moeten worden gebouwd.

Uiteindelijk hebben we Carthage gemaakt omdat we de eenvoudigst mogelijke tool wilden-een dependency manager die de klus klaart zonder de verantwoordelijkheid van Xcode over te nemen, en zonder extra werk te creëren voor framework-auteurs. CocoaPods biedt veel geweldige functies die Carthage nooit zal hebben, ten koste van extra complexiteit.

Licentie

Carthage is vrijgegeven onder de MIT-licentie.

Header backdrop foto is vrijgegeven onder de CC BY-NC-SA 2.0 licentie. Originele foto door Richard Mortel.