Carthage / Carthage

Carthage är tänkt att vara det enklaste sättet att lägga till ramverk till din Cocoa-applikation.

Carthage bygger dina beroenden och förser dig med binära ramverk, men du behåller full kontroll över din projektstruktur och inställning. Carthage ändrar inte automatiskt dina projektfiler eller dina bygginställningar.

• Snabbstart
• Installation av Carthage
• Lägga till ramverk till en applikation
  • Komma igång
    • Bygga plattform-oberoende XCFrameworks
      • Migrerar ett projekt från rampaket till XCFrameworks
    • Bygger plattformsspecifika rampaket
      • Om du bygger för macOS
      • Om du bygger för iOS, tvOS, eller watchOS
    • För alla plattformar
    • (Eventuellt) Lägg till byggfas för att varna för föråldrade beroenden
    • Hämtningskompatibilitet för det binära ramverket Swift
  • Körning av ett projekt som använder Carthage
  • Läggning av ramverk till enhetstester eller ett ramverk
  • Uppgradering av ramverk
    • Experimentell resolver
  • Nested beroenden
  • Användning av undermoduler för beroenden
  • Automatisk återuppbyggnad av beroenden
  • Caching builds
  • Bash/Zsh/Fish completion
• Stöd för Carthage för ditt ramverk
  • Dela dina Xcode-scheman
  • Lös byggfel
  • Tagga stabila utgåvor
  • Arkivera förbyggda ramverk i en zip-fil
    • Använd travis-ci för att ladda upp dina taggade förbyggda ramverk
  • Bygg statiska ramverk för att påskynda lanseringen av din app
  • Deklarera din kompatibilitet
• Kända problem
  • DWARFs symbolproblem
• CarthageKit
• Unlikheter mellan Carthage och CocoaPods
• Licens

Snabbstart

1. Hämta Carthage genom att köra brew install carthage eller välj en annan installationsmetod

2. Skapa en Cartfile i samma katalog som din .xcodeproj eller .xcworkspace är

3. Lista upp de önskade beroendena i Cartfile, till exempel:

   github "Alamofire/Alamofire" ~> 4.7.2

4. Kör carthage update --use-xcframeworks

5. En Cartfile.resolved fil och en Carthage katalog kommer att dyka upp i samma katalog som din .xcodeproj eller .xcworkspace är

6. Släpp in de byggda .xcframework paketen från Carthage/Build till avsnittet ”Frameworks and Libraries” i Xcode-projektet för din applikation.

7. Om du använder Carthage för en applikation väljer du ”Embed & Sign” (bädda in & tecken), annars ”Do Not Embed” (bädda inte in).

För en fördjupad guide kan du läsa vidare från Adding frameworks to an application

Installing Carthage

Det finns flera alternativ för att installera Carthage:

• Installer: Ladda ner och kör filen Carthage.pkg för den senaste versionen och följ sedan instruktionerna på skärmen. Om du installerar pkg via CLI kan du behöva köra sudo chown -R $(whoami) /usr/local först.

• Homebrew: Du kan använda Homebrew och installera verktyget carthage på ditt system genom att helt enkelt köra brew update och brew install carthage. (Obs: Om du tidigare installerat den binära versionen av Carthage bör du radera /Library/Frameworks/CarthageKit.framework).

• MacPorts: Du kan använda MacPorts och installera verktyget carthage på ditt system genom att helt enkelt köra sudo port selfupdate och sudo port install carthage. (Obs: om du tidigare installerat den binära versionen av Carthage bör du radera /Library/Frameworks/CarthageKit.framework).

• Från källan: Om du vill köra den senaste utvecklingsversionen (som kan vara mycket instabil eller inkompatibel) klonar du helt enkelt master-grenen i arkivet och kör sedan make install. Kräver Xcode 10.0 (Swift 4.2).

Lägga till ramverk till en applikation

När du har installerat Carthage kan du börja lägga till ramverk till ditt projekt. Observera att Carthage endast stöder dynamiska ramverk, som endast är tillgängliga på iOS 8 eller senare (eller någon version av OS X).

Komma igång

Bygga plattformsoberoende XCFrameworks (Xcode 12 och senare)

1. Skapa en Cartfile som listar de ramverk som du vill använda i ditt projekt.
2. Kör carthage update --use-xcframeworks. Detta hämtar beroenden i en Carthage/Checkouts-mapp och bygger var och en eller laddar ner en förkompilerad XCFramework.
3. På fliken Allmänna inställningar för dina programmål, i avsnittet Ramverk, bibliotek och inbäddat innehåll, drar och släpper du varje XCFramework som du vill använda från Carthage/Build-mappen på disken.

Migrera ett projekt från rampaket till XCFrameworks

Vi uppmuntrar till att använda XCFrameworks från och med version 0.37.0 (januari 2021) och kräver XCFrameworks när du bygger på en Apple Silicon Mac. Att byta från diskreta rampaket till XCFrameworks kräver några ändringar i ditt projekt:

Migreringssteg

1. Leta bort din mapp Carthage/Build för att ta bort alla befintliga rampaket.
2. Bygg nya XCFrameworks genom att köra carthage build --use-xcframeworks. Alla andra argument som du bygger med kan anges som vanligt.
3. Ta bort referenser till de gamla ramverken i vart och ett av dina mål:
   • Ta bort referenser till Carthage-ramverken från målets avsnitt Frameworks, Libraries, and Embedded Content och/eller dess Link Binary with Libraries-byggnadsfas.
   • Ta bort referenser till Carthage-ramverken från alla Copy Files-byggnadsfaser.
   • Ta bort målets carthage copy-frameworks-byggnadsfas, om den finns.
4. Lägg till referenser till XCFrameworks i vart och ett av dina mål:
   • För ett programmål: På fliken Allmänna inställningar, i avsnittet Ramverk, bibliotek och inbäddat innehåll, drar och släpper du varje XCFramework som du använder från mappen Carthage/Build på disken.
   • För ett ramverksmål: På fliken Build Phases, i en Link Binary with Libraries-fas, dra och släpp varje XCFramework som du använder från mappen Carthage/Build på disken.

Bygger plattformsspecifika ramverkspaket (standard för Xcode 11 och lägre)

Xcode 12+ inkompatibilitet: Plattformar med flera arkitekturer stöds inte när man bygger rampaket i Xcode 12 och senare. Företräcka att bygga med XCFrameworks. Om du behöver bygga diskreta rampaket använder du en avhjälpande xcconfig-fil.

Om du bygger för macOS

macOS-specifika instruktioner

1. Skapa en Cartfile som listar de ramverk du vill använda i ditt projekt.
2. Kör carthage update --platform macOS. Detta hämtar beroenden i en Carthage/Checkouts-mapp och bygger var och en eller laddar ner ett förkompilerat ramverk.
3. På fliken Allmänna inställningar för dina programmål, i avsnittet Inbäddade binärer, drar och släpper du varje ramverk som du vill använda från Carthage/Build-mappen på disken.

Det är nödvändigt att kopiera felsökningssymboler för felsökning och kraschrapportering på OS X.

1. På fliken Build Phases-inställningar för ditt programmål klickar du på +-ikonen och väljer New Copy Files Phase.
2. Klicka på rullgardinsmenyn Destination och välj Products Directory.
3. För varje ramverk du använder drar och släpper du motsvarande dSYM-fil.

Om du bygger för iOS, tvOS eller watchOS

Plattformsspecifika instruktioner

1. Skapa en Cartfile som listar de ramverk du vill använda i ditt projekt.

2. Kör carthage update. Detta hämtar beroenden till en Carthage/Checkouts-mapp och bygger sedan varje beroende eller hämtar ett förkompilerat ramverk.

3. Öppna fliken Allmänna inställningar för dina programmål. För Xcode 11.0 och senare drar du i avsnittet ”Ramverk, bibliotek och inbäddat innehåll” varje ramverk som du vill använda från mappen Carthage/Build på disken. I avsnittet ”Embed” väljer du sedan ”Do Not Embed” från rullgardinsmenyn för varje objekt som lagts till. För Xcode 10.x och lägre drar du i avsnittet ”Linked Frameworks and Libraries” (länkade ramverk och bibliotek) och släpper varje ramverk som du vill använda från mappen Carthage/Build på disken.

4. På fliken Build Phases settings (inställningar för uppbyggnadsfaser) för dina programmål klickar du på ikonen + och väljer New Run Script Phase. Skapa ett körskript där du anger ditt skal (t.ex. /bin/sh), lägg till följande innehåll i skriptområdet under skalet:

   /usr/local/bin/carthage copy-frameworks

5. Skapa en fil som heter input.xcfilelist och en fil som heter output.xcfilelist

6. Lägg till sökvägarna till de ramverk som du vill använda till din input.xcfilelist. Till exempel:

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

7. För att lägga till sökvägarna till de kopierade ramverken i output.xcfilelist. Till exempel:

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

   Med utgångsfiler som anges tillsammans med inmatningsfilerna behöver Xcode bara köra skriptet när inmatningsfilerna har ändrats eller när utgångsfilerna saknas. Detta innebär att dirty builds blir snabbare när du inte har byggt om ramverk med Carthage.

8. Lägg till input.xcfilelist i avsnittet ”Input File Lists” i Carthage run script phase

9. Lägg till output.xcfilelist i avsnittet ”Output File Lists” i Carthage run script phase

Det här skriptet kringgår ett fel i App Store-ansökan som utlöses av universella binärfiler och säkerställer att nödvändiga bitcode-relaterade filer och dSYM:er kopieras vid arkivering.

Med felsökningsinformationen kopierad till katalogen för byggda produkter kommer Xcode att kunna symbolisera stacktrace när du stannar vid en brytpunkt. På så sätt kan du också gå igenom tredjepartskod i felsökaren.

När du arkiverar din applikation för inlämning till App Store eller TestFlight kommer Xcode också att kopiera dessa filer till underkatalogen dSYMs i applikationens .xcarchive bundle.

För alla plattformar

Under tiden kommer Carthage att ha skapat en del byggartefakter. Den viktigaste av dessa är filen Cartfile.resolved, som listar de versioner som faktiskt byggdes för varje ramverk. Se till att du lägger in din Cartfile.resolved, eftersom alla andra som använder projektet kommer att behöva den filen för att bygga samma ramverksversioner.

(Valfritt) Lägg till byggfas för att varna för föråldrade beroenden

Du kan lägga till en Run Script-fas för att automatiskt varna dig när ett av dina beroenden är föråldrat.

1. På fliken Build Phasesinställningar för dina applikationsmål klickar du på +-ikonen och väljer New Run Script Phase. Skapa ett körskript där du anger ditt skal (t.ex. /bin/sh), lägg till följande innehåll i skriptområdet under skalet:

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

Kompatibilitet för nedladdning av binära Swift-ramverk

Carthage kontrollerar att nedladdade Swift-ramverk (och blandade Objective-C/Swift-ramverk) har byggts med samma version av Swift som används lokalt. Om det finns en version som inte stämmer överens kommer Carthage att fortsätta att bygga ramverket från källkoden. Om ramverket inte kan byggas från källkod kommer Carthage att misslyckas.

Om Carthage använder utdata från xcrun swift --version för att bestämma den lokala Swift-versionen, se till att köra Carthage-kommandon med den Swift-verktygskedja som du tänker använda. För många användningsfall behövs inget ytterligare. Men om du till exempel bygger ett Swift 2.3-projekt med Xcode 8.x är ett tillvägagångssätt för att ange ditt standard swift för carthage bootstrap att använda följande kommando:

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

Running a project that uses Carthage

När du har avslutat ovanstående steg och skjutit dina ändringar behöver andra användare av projektet bara hämta repositoriet och köra carthage bootstrap för att komma igång med de ramar du har lagt till.

Lägga till ramverk till enhetstester eller ett ramverk

Att använda Carthage för beroenden för ett godtyckligt mål är ganska likt att använda Carthage för en applikation. Den största skillnaden ligger i hur ramverken faktiskt konfigureras och länkas i Xcode.

Eftersom enhetstestmålen saknar avsnittet Länkade ramverk och bibliotek i fliken Allmänna inställningar måste du istället dra de byggda ramverken till byggfasen Länka binärer med bibliotek.

I testmålet under fliken Build Settings lägger du till @loader_path/Frameworks i Runpath Search Paths om det inte redan finns där.

I sällsynta fall kanske du också vill kopiera varje beroende till byggprodukten (t.ex, för att bädda in beroenden i det yttre ramverket, eller för att se till att beroenden finns i ett testpaket). För att göra detta skapar du en ny Copy Files-byggfas med destinationen Frameworks och lägger sedan till ramreferensen där också. Du bör inte använda kommandot carthage copy-frameworks eftersom testpaket inte behöver ramverk strippade, och körning av samtidiga instanser av copy-frameworks (med parallella byggen aktiverade) stöds inte.

Uppgradering av ramverk

Om du har ändrat din Cartfile, eller om du vill uppdatera till de nyaste versionerna av varje ramverk (med förbehåll för de krav som du har angett), kör du bara kommandot carthage update igen.

Om du bara vill uppdatera ett, eller specifika, beroende, skickar du dem som en mellanslagsseparerad lista till kommandot update. t.ex.

carthage update Box

eller

carthage update Box Result

Experimental Resolver

En omskrivning av logiken för uppgradering av ramverk gjordes med målet att öka hastigheten och minska minnesanvändningen. Det är för närvarande en opt-in-funktion. Den kan användas genom att skicka --new-resolver till uppdateringskommandot, t.ex.

carthage update --new-resolver Box

Om du upplever prestandaproblem under uppdateringar, ge den nya resolvern ett försök

Nested dependencies

Om det ramverk som du vill lägga till i ditt projekt har beroenden som uttryckligen listas i en Cartfile, kommer Carthage automatiskt att hämta dem åt dig. Du måste sedan själv dra dem till ditt projekt från mappen Carthage/Build.

Om det inbäddade ramverket i ditt projekt har beroenden till andra ramverk måste du länka dem till applikationsmålet (även om applikationsmålet inte har några beroenden till dessa ramverk och aldrig använder dem).

Användning av undermoduler för beroenden

Som standard kommer Carthage att checka ut beroendens källfiler direkt till din projektmapp, så att du kan lägga in eller ignorera dem som du vill. Om du vill ha beroenden tillgängliga som Git-submoduler istället (kanske så att du kan lägga in och skjuta ändringar i dem) kan du köra carthage update eller carthage checkout med flaggan --use-submodules.

När du körs på det här sättet kommer Carthage att skriva till ditt repositoriums .gitmodules– och .git/config-filer, och automatiskt uppdatera submoduler när beroendenas versioner ändras.

Automatiskt bygga om beroenden

Om du vill arbeta med dina beroenden under utvecklingen och vill att de ska byggas om automatiskt när du bygger ditt överordnade projekt, kan du lägga till en Run Script-byggfas som anropar Carthage på följande sätt:

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

Notera att du bör använda dig av undermoduler innan du gör det här, eftersom enkla checkouts inte bör ändras direkt.

Caching builds

Som standard kommer Carthage att bygga om ett beroende oavsett om det är samma upplösta version som tidigare. Om --cache-builds passeras kommer carthage att undvika att bygga om ett beroende om det är möjligt. Se information om versionsfiler för detaljer om hur Carthage utför denna cachelagring.

Notera: För närvarande är --cache-builds inkompatibelt med --use-submodules. Användning av båda kommer att resultera i att arbetskopior och bekräftade ändringar i ditt undermodulberoende inte byggs om på rätt sätt. Se #1785 för mer information.

Bash/Zsh/Fish completion

Autokomplettering av Carthage-kommandon och -alternativ finns tillgängliga enligt dokumentationen i Bash/Zsh/Fish Completion.

Stöd för Carthage för ditt ramverk

Carthage har endast officiellt stöd för dynamiska ramverk. Dynamiska ramverk kan användas på alla versioner av OS X, men endast på iOS 8 eller senare. Sedan version 0.30.0 stöder Carthage dessutom statiska ramverk.

Då Carthage inte har någon centraliserad paketlista och inget projektspecifikationsformat bör de flesta ramverk byggas automatiskt.

De specifika kraven för ett ramverksprojekt listas nedan.

Dela dina Xcode-scheman

Carthage kommer endast att bygga Xcode-scheman som delas från din .xcodeproj. Du kan se om alla dina avsedda scheman byggs framgångsrikt genom att köra carthage build --no-skip-current och sedan kontrollera mappen Carthage/Build.

Om ett viktigt schema inte byggs när du kör det kommandot öppnar du Xcode och ser till att schemat är markerat som Shared, så att Carthage kan upptäcka det.

Lös byggfel

Om du stöter på byggfel i carthage build --no-skip-current, prova att köra xcodebuild -scheme SCHEME -workspace WORKSPACE build eller xcodebuild -scheme SCHEME -project PROJECT build (med de faktiska värdena) och se om samma fel uppstår där. Detta bör förhoppningsvis ge tillräckligt med information för att lösa problemet.

Om du har flera versioner av Apples utvecklarverktyg installerade (t.ex. en betaversion av Xcode) kan du använda xcode-select för att ändra vilken version som Carthage använder.

Om du fortfarande inte kan bygga ditt ramverk med Carthage, öppna ett problem så hjälper vi dig gärna!

Tagga stabila utgåvor

Carthage bestämmer vilka versioner av ditt ramverk som finns tillgängliga genom att söka igenom de taggar som publicerats i arkivet och försöka tolka varje taggnamn som en semantisk version. Till exempel, i taggen v1.2 är den semantiska versionen 1.2.0.

Taggar utan versionsnummer eller med tecken efter versionsnumret (t.ex, 1.2-alpha-1) har för närvarande inget stöd och kommer att ignoreras.

Arkivera förbyggda ramverk i en zip-fil

Carthage kan automatiskt använda förbyggda ramverk, i stället för att bygga från grunden, om de är bifogade till en GitHub-utgåva i ditt projektrepositorium eller via en binär projektdefinitionsfil.

För att erbjuda förbyggda ramverk för en specifik tagg ska binärerna för alla plattformar som stöds zippas ihop till ett arkiv, och det arkivet ska bifogas en publicerad Release som motsvarar den taggen. Bilagan bör innehålla .framework i sitt namn (t.ex. ReactiveCocoa.framework.zip) för att ange för Carthage att den innehåller binärer. Arkivets katalogstruktur är fri, men ramverk bör endast förekomma en gång i arkivet eftersom de kommer att kopieras till Carthage/Build/<platform> baserat på deras namn (t.ex. ReactiveCocoa.framework).

Du kan utföra arkiveringen med Carthage självt genom att använda:

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

eller alternativt

carthage build --archive

Utkast till publikationer kommer automatiskt att ignoreras, även om de motsvarar den önskade taggen.

Använd travis-ci för att ladda upp dina taggade förbyggda ramverk

Det är möjligt att använda travis-ci för att bygga och ladda upp dina taggade utgåvor.

1. Installera travis CLI med gem install travis

2. Installera travis-ci för ditt arkiv (steg 1 och 2)

3. Skapa .travis.ymlfilen vid roten av ditt arkiv baserat på denna mall. Ställ in FRAMEWORK_NAME till rätt värde.

   Sätt om PROJECT_PLACEHOLDER och SCHEME_PLACEHOLDER

   Om du använder en arbetsyta istället för ett projekt tar du bort xcode_project-linjen och tar bort xcode_workspace-linjen.

   Projektet ska ha formatet: MyProject.xcodeproj

   Arbetsutrymmet ska vara i formatet: MyWorkspace.xcworkspace

   Följ dig fri att uppdatera xcode_sdk-värdet till en annan SDK, observera att testning på iphoneos SDK skulle kräva att du laddar upp en kodsigneringsidentitet

   För mer information kan du besöka 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. Kör travis setup releases, följ dokumentationen här

   Detta kommando kommer att koda dina GitHub-uppgifter i .travis.yml-filen så att travis kan ladda upp utgåvan till GitHub.comNär du uppmanas att ange filen som ska laddas upp anger du $FRAMEWORK_NAME.framework.zip

5. Uppdatera deploy-sektionen så att den körs på taggar:

   I .travis.yml letar du upp:

   on: repo: repo/repo

   och lägger till tags: true och skip_cleanup: true:

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

   Detta kommer att låta travis veta att skapa en utplacering när en ny tagg läggs ut och förhindra att travis städar upp den genererade zip-filen

Bygg statiska ramverk för att snabba upp lanseringstiderna för din app

Om du bäddar in många dynamiska ramverk i din app kan lanseringstiderna före huvudprogrammet vara ganska långsamma. Carthage kan hjälpa till att mildra detta genom att bygga dina dynamiska ramverk som statiska ramverk istället. Statiska ramverk kan länkas direkt i din applikation eller slås samman till ett större dynamiskt ramverk med några enkla ändringar i ditt arbetsflöde, vilket kan resultera i dramatiska minskningar av starttiderna före start.

Carthage 0.30.0 eller senare

Sedan version 0.30.0 rullar Carthage-projektet ut stöd för statiskt länkade ramverk som är skrivna i Swift eller Objective-C, stöd för dessa har införts i Xcode 9.4. Observera dock att det specifikt står ramverk, därav Darwin-paket med .framework-tillägg och statiskt länkade objektarkiv inuti. Carthage har för närvarande inte stöd för statiska biblioteksscheman och det finns inte heller några planer på att införa stöd för dem i framtiden.

Arbetsflödet skiljer sig knappt åt:

• Du måste fortfarande kryssa för ditt Carthage-kompatibla projekts scheman som delas i Produkt > Schema > Hantera scheman…, precis som med dynamiska binärfiler
• Du måste fortfarande länka mot statiska .ramverk i projektets byggnadsfaser precis som med dynamiska binärer

Hursomhelst:

• I ditt Carthage-kompatibla projekts Cocoa Framework-måls byggnadsinställningar, avsnittet Länkning, ställer du in Mach-O Type till Static Library
• Dina statiskt länkade ramverk kommer att byggas vid ./Carthage/Build/$(PLATFORM_NAME)/Static
• Du bör inte lägga till något av de statiska ramverken som ingångs-/utgångsfiler i carthage copy-frameworks Build Phase

Carthage 0.29.0 eller lägre

Se dokumentationen StaticFrameworks för detaljer.

Observera att några förbehåll gäller för detta tillvägagångssätt:

• Swift static frameworks stöds inte officiellt av Apple
• Detta är ett avancerat arbetsflöde som inte är inbyggt i Carthage, YMMV

Deklarera din kompatibilitet

Vill du annonsera att ditt projekt kan användas med Carthage? Du kan lägga till ett kompatibilitetsmärke:

… till din README, genom att helt enkelt infoga följande Markdown:

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

Kända problem

DWARFs symbolproblem

Framställt ramverk kan inte felsökas med hjälp av step-exekvering på en annan maskin än den som ramverket byggdes på. Bara carthage bootstrap/build/update --no-use-binaries bör åtgärda detta, men för en mer automatiserad lösning, se #924. Dupera rdar://23551273 om du vill att Apple ska åtgärda grundorsaken till detta problem.

CarthageKit

De flesta funktionerna i kommandoradsverktyget carthage är faktiskt inkapslade i ett ramverk som heter CarthageKit.

Om du är intresserad av att använda Carthage som en del av ett annat verktyg, eller kanske utöka Carthages funktionalitet, ta en titt på CarthageKit-källkoden för att se om API:et passar dina behov.

Skillnader mellan Carthage och CocoaPods

CocoaPods är en sedan länge existerande beroendehanterare för Cocoa. Så varför skapades Carthage?

För det första skapar och uppdaterar CocoaPods (som standard) automatiskt en Xcode-arbetsyta för din applikation och alla beroenden. Carthage bygger rambinarier med hjälp av xcodebuild, men överlåter ansvaret för att integrera dem till användaren. CocoaPods tillvägagångssätt är enklare att använda, medan Carthages är flexibelt och oinskränkbart.

Målet med CocoaPods anges i README på följande sätt:

… att förbättra upptäckbarheten av, och engagemanget i, tredje parters öppenkällkodsbibliotek, genom att skapa ett mer centraliserat ekosystem.

Carthage har däremot skapats som en decentraliserad beroendestyrare. Det finns ingen central lista över projekt, vilket minskar underhållsarbetet och undviker en central felpunkt. Det är dock svårare att hitta projekt – användarna måste ta till GitHubs Trending pages eller liknande.

CocoaPods-projekt måste också ha en så kallad podspec-fil, som innehåller metadata om projektet och anger hur det ska byggas. Carthage använder xcodebuild för att bygga beroenden, istället för att integrera dem i en enda arbetsyta, den har ingen liknande specifikationsfil men dina beroenden måste innehålla ett eget Xcode-projekt som beskriver hur deras produkter ska byggas.

I slutändan skapade vi Carthage för att vi ville ha ett så enkelt verktyg som möjligt – en beroendehanterare som får jobbet gjort utan att ta över Xcodes ansvar och utan att skapa extra arbete för ramverksförfattare. CocoaPods erbjuder många fantastiska funktioner som Carthage aldrig kommer att ha, på bekostnad av ytterligare komplexitet.

Licens

Carthage släpps under MIT-licensen.

Fotot på huvudbakgrunden släpps under CC BY-NC-SA 2.0-licensen. Originalfoto av Richard Mortel.