Carthage / Carthage

Carthage vuole essere il modo più semplice per aggiungere framework alla tua applicazione Cocoa.

Carthage costruisce le tue dipendenze e ti fornisce i framework binari, ma tu mantieni il pieno controllo sulla struttura e la configurazione del tuo progetto. Carthage non modifica automaticamente i vostri file di progetto o le vostre impostazioni di compilazione.

• Quick Start
• Installazione di Carthage
• Aggiungere framework a un’applicazione
  • Iniziare
    • Costruire framework indipendenti dalla piattaformaXCFrameworks
      • Migrare un progetto dai bundle di framework a XCFrameworks
    • Costruire bundle di framework specifici per una piattaforma
      • Se stai costruendo per macOS
      • Se stai costruendo per iOS, tvOS, o watchOS
    • Per tutte le piattaforme
    • (Opzionalmente) Aggiungi la fase di compilazione per avvertire delle dipendenze obsolete
    • Compatibilità del download del framework binario Swift
  • Eseguire un progetto che usa Carthage
  • Aggiungimento di framework ai test unitari o a un framework
  • Aggiornamento di framework
    • Risolutore sperimentale
  • Nestrati dipendenze
  • Utilizzo di sottomoduli per le dipendenze
  • Ricostruzione automatica delle dipendenze
  • Caching delle build
  • Completamento Bash/Zsh/Fish
• Supporto di Carthage per il tuo framework
  • Condividi i tuoi schemi Xcode
  • Risolvi gli errori di compilazione
  • Tagga le release stabili
  • Archivia i framework precostruiti in un file zip
    • Usa travis-ci per caricare i tuoi framework pre-costruiti con tag
  • Costruisci framework statici per accelerare i tempi di lancio della tua app
  • Dichiara la tua compatibilità
• Problemi noti
  • Problema del simbolo DWARFs
• CarthageKit
• Differenze tra Carthage e CocoaPods
• License

Quick Start

1. Prendi Carthage eseguendo brew install carthage o scegli un altro metodo di installazione

2. Crea un Cartfile nella stessa directory dove si trova il tuo .xcodeproj o .xcworkspace

3. Lista le dipendenze desiderate nel Cartfile, per esempio:

   github "Alamofire/Alamofire" ~> 4.7.2

4. Esegui carthage update --use-xcframeworks

5. Un file Cartfile.resolved e una directory Carthage appariranno nella stessa directory dove si trova il tuo .xcodeproj o .xcworkspace

6. Trascina i bundle .xcframework costruiti da Carthage/Build nella sezione “Frameworks and Libraries” del progetto Xcode della tua applicazione.

7. Se stai usando Carthage per un’applicazione, seleziona “Embed & Sign”, altrimenti “Do Not Embed”.

Per una guida approfondita, continua a leggere da Aggiungere framework a un’applicazione

Installare Carthage

Ci sono diverse opzioni per installare Carthage:

• Installer: Scarica ed esegui il file Carthage.pkg per l’ultima versione, poi segui le istruzioni sullo schermo. Se stai installando il pkg via CLI, potresti aver bisogno di eseguire prima sudo chown -R $(whoami) /usr/local.

• Homebrew: Puoi usare Homebrew e installare lo strumento carthage sul tuo sistema semplicemente eseguendo brew update e brew install carthage. (nota: se hai precedentemente installato la versione binaria di Carthage, dovresti cancellare /Library/Frameworks/CarthageKit.framework).

• MacPorts: Puoi usare MacPorts e installare lo strumento carthage sul tuo sistema semplicemente eseguendo sudo port selfupdate e sudo port install carthage. (nota: se hai precedentemente installato la versione binaria di Carthage, dovresti cancellare /Library/Frameworks/CarthageKit.framework).

• Dalla fonte: Se vuoi eseguire l’ultima versione di sviluppo (che potrebbe essere altamente instabile o incompatibile), semplicemente clona il ramo master del repository, poi esegui make install. Richiede Xcode 10.0 (Swift 4.2).

Aggiungere framework a un’applicazione

Una volta installato Carthage, potete iniziare ad aggiungere framework al vostro progetto. Nota che Carthage supporta solo i framework dinamici, che sono disponibili solo su iOS 8 o successivi (o qualsiasi versione di OS X).

Per iniziare

Costruire XCFrameworks indipendenti dalla piattaforma (Xcode 12 e superiori)

1. Crea un Cartfile che elenca i framework che vorresti usare nel tuo progetto.
2. Esegui carthage update --use-xcframeworks. Questo recupererà le dipendenze in una cartella Carthage/Checkouts e costruirà ognuna di esse o scaricherà un XCFramework precompilato.
3. Sulla scheda General settings della tua applicazione target, nella sezione Frameworks, Libraries, and Embedded Content, trascina ogni XCFramework che vuoi usare dalla cartella Carthage/Build sul disco.

Migrare un progetto dai bundle di framework a XCFrameworks

Invitiamo a usare XCFrameworks a partire dalla versione 0.37.0 (gennaio 2021), e richiediamo XCFrameworks quando si costruisce su un Apple Silicon Mac. Passare da bundle di framework discreti a XCFrameworks richiede alcune modifiche al tuo progetto:

Passi di migrazione

1. Cancellare la cartella Carthage/Build per rimuovere qualsiasi bundle di framework esistente.
2. Costruire nuovi XCFrameworks eseguendo carthage build --use-xcframeworks. Qualsiasi altro argomento con cui costruisci può essere fornito normalmente.
3. Rimuovi i riferimenti ai vecchi framework in ciascuno dei tuoi obiettivi:
   • Elimina i riferimenti ai framework Carthage dalla sezione Frameworks, Libraries, and Embedded Content dell’obiettivo e/o dalla sua fase di build Link Binary with Libraries.
   • Elimina i riferimenti ai framework Carthage da qualsiasi fase di build Copy Files.
   • Elimina la fase di build carthage copy-frameworks del target, se presente.
4. Aggiungi riferimenti a XCFrameworks in ciascuno dei tuoi obiettivi:
   • Per un obiettivo di applicazione: nella scheda Impostazioni generali, nella sezione Frameworks, librerie e contenuto incorporato, trascina ogni XCFramework che usi dalla cartella Carthage/Build sul disco.
   • Per un obiettivo framework: nella scheda Build Phases, in una fase Link Binary with Libraries, trascina e rilascia ogni XCFramework che usi dalla cartella Carthage/Build sul disco.

Costruire bundle di framework specifici per piattaforma (predefinito per Xcode 11 e inferiori)

Xcode 12+ incompatibilità: Le piattaforme multi-architettura non sono supportate quando si costruiscono bundle di framework in Xcode 12 e superiori. Preferisci costruire con XCFrameworks. Se hai bisogno di costruire bundle di framework discreti, usa un file xcconfig di workaround.

Se stai costruendo per macOS

istruzioni specifiche per macOS

1. Crea un Cartfile che elenca i framework che vorresti usare nel tuo progetto.
2. Esegui carthage update --platform macOS. Questo recupererà le dipendenze in una cartella Carthage/Checkouts e costruirà ognuna di esse o scaricherà un framework precompilato.
3. Nella scheda delle impostazioni generali della tua applicazione, nella sezione Embedded Binaries, trascina e rilascia ogni framework che vuoi usare dalla cartella Carthage/Build sul disco.

Inoltre, dovrai copiare i simboli di debug per il debug e la segnalazione di crash su OS X.

1. Nella scheda delle impostazioni di Build Phases della tua applicazione target, fai clic sull’icona + e scegli New Copy Files Phase.
2. Fai clic sul menu a discesa Destination e seleziona Products Directory.
3. Per ogni framework che stai usando, trascina il suo file dSYM corrispondente.

Se stai costruendo per iOS, tvOS, o watchOS

Istruzioni specifiche della piattaforma

1. Crea un Cartfile che elenca i framework che vorresti usare nel tuo progetto.

2. Esegui carthage update. Questo recupererà le dipendenze in una cartella Carthage/Checkouts, poi costruirà ciascuna di esse o scaricherà un framework precompilato.

3. Apri la scheda delle impostazioni generali degli obiettivi dell’applicazione. Per Xcode 11.0 e successivi, nella sezione “Frameworks, Libraries, and Embedded Content”, trascina ogni framework che vuoi usare dalla cartella Carthage/Build sul disco. Poi, nella sezione “Embed”, seleziona “Do Not Embed” dal menu a tendina per ogni elemento aggiunto. Per Xcode 10.x e inferiori, nella sezione “Linked Frameworks and Libraries”, trascina ogni framework che vuoi usare dalla cartella Carthage/Build sul disco.

4. Nella scheda delle impostazioni Build Phases degli obiettivi dell’applicazione, clicca sull’icona + e scegli New Run Script Phase. Crea un Run Script in cui specifichi la tua shell (es: /bin/sh), aggiungi i seguenti contenuti all’area dello script sotto la shell:

   /usr/local/bin/carthage copy-frameworks

5. Crea un file chiamato input.xcfilelist e un file chiamato output.xcfilelist

6. Aggiungi i percorsi dei framework che vuoi usare al tuo input.xcfilelist. Per esempio:

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

7. Aggiungi i percorsi ai framework copiati al output.xcfilelist. Per esempio:

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

   Con i file di output specificati accanto ai file di input, Xcode ha solo bisogno di eseguire lo script quando i file di input sono cambiati o i file di output sono mancanti. Questo significa che le build sporche saranno più veloci quando non hai ricostruito i framework con Carthage.

8. Aggiungi il input.xcfilelist alla sezione “Input File Lists” della fase di esecuzione dello script Carthage

9. Aggiungi il output.xcfilelist alla sezione “Output File Lists” della fase di esecuzione dello script Carthage

Questo script aggira un bug di invio dell’App Store innescato dai binari universali e assicura che i file e i dSYM necessari al bitcode siano copiati durante l’archiviazione.

Con le informazioni di debug copiate nella directory dei prodotti costruiti, Xcode sarà in grado di simboleggiare lo stack trace ogni volta che ci si ferma a un punto di interruzione. Questo ti permetterà anche di passare attraverso il codice di terze parti nel debugger.

Quando archivi la tua applicazione per l’invio all’App Store o a TestFlight, Xcode copierà anche questi file nella sottodirectory dSYMs del bundle .xcarchive della tua applicazione.

Per tutte le piattaforme

Durante il percorso, Carthage avrà creato alcuni artefatti di build. Il più importante di questi è il file Cartfile.resolved, che elenca le versioni che sono state effettivamente costruite per ogni framework. Assicurati di fare il commit del Cartfile.resolved, perché chiunque altro usi il progetto avrà bisogno di quel file per costruire le stesse versioni del framework.

(Opzionalmente) Aggiungi una fase di compilazione per avvertire delle dipendenze obsolete

Puoi aggiungere una fase di Run Script per avvertirti automaticamente quando una delle tue dipendenze non è aggiornata.

1. Nella scheda delle impostazioni Build Phases degli obiettivi della tua applicazione, clicca sull’icona + e scegli New Run Script Phase. Crea un Run Script in cui specifichi la tua shell (es: /bin/sh), aggiungi il seguente contenuto all’area dello script sotto la shell:

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

Compatibilità del download del framework binario Swift

Carthage controllerà per assicurarsi che i framework Swift (e Objective-C/Swift misti) scaricati siano stati costruiti con la stessa versione di Swift che è in uso localmente. Se c’è una discrepanza di versione, Carthage procederà a costruire il framework dai sorgenti. Se il framework non può essere costruito dai sorgenti, Carthage fallirà.

Perché Carthage usa l’output di xcrun swift --version per determinare la versione locale di Swift, assicurati di eseguire i comandi di Carthage con la toolchain Swift che intendi usare. Per molti casi d’uso, non è necessario nulla di aggiuntivo. Tuttavia, per esempio, se state costruendo un progetto Swift 2.3 usando Xcode 8.x, un approccio per specificare il vostro swift predefinito per carthage bootstrap è quello di usare il seguente comando:

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

Eseguire un progetto che usa Carthage

Dopo che avete terminato i passi precedenti e spinto le vostre modifiche, gli altri utenti del progetto devono solo recuperare il repository ed eseguire carthage bootstrap per iniziare con i framework che avete aggiunto.

Aggiungere framework ai test unitari o a un framework

Utilizzare Carthage per le dipendenze di qualsiasi obiettivo arbitrario è abbastanza simile a usare Carthage per un’applicazione. La differenza principale sta nel modo in cui i framework sono effettivamente impostati e collegati in Xcode.

Perché gli obiettivi dei test unitari mancano della sezione Linked Frameworks and Libraries nella loro scheda General settings, devi invece trascinare i framework costruiti nella fase di costruzione Link Binaries With Libraries.

Nel target di test sotto la scheda Build Settings, aggiungi @loader_path/Frameworks al Runpath Search Paths se non è già presente.

In rari casi, potresti voler copiare anche ogni dipendenza nel prodotto di build (es, per incorporare le dipendenze all’interno del framework esterno, o assicurarsi che le dipendenze siano presenti in un bundle di test). Per fare questo, creare una nuova fase di compilazione Copy Files con la destinazione Frameworks, quindi aggiungere anche lì il riferimento al framework. Non dovresti usare il comando carthage copy-frameworks poiché i bundle di test non hanno bisogno di framework spogliati, e l’esecuzione di istanze concorrenti di copy-frameworks (con le build parallele attivate) non è supportata.

Aggiornare i framework

Se hai modificato il tuo Cartfile, o vuoi aggiornare alle versioni più recenti di ogni framework (soggetto ai requisiti che hai specificato), esegui semplicemente il comando carthage update nuovamente.

Se vuoi aggiornare solo una, o specifiche, dipendenze, passale come lista separata da spazi al comando update. es.

carthage update Box

o

carthage update Box Result

Experimental Resolver

È stata fatta una riscrittura della logica di aggiornamento dei framework allo scopo di aumentare la velocità e ridurre l’uso della memoria. Attualmente è una caratteristica opt-in. Può essere usata passando --new-resolver al comando update, ad esempio

carthage update --new-resolver Box

Se stai riscontrando problemi di prestazioni durante gli aggiornamenti, prova il nuovo resolver

Dipendenze annidate

Se il framework che vuoi aggiungere al tuo progetto ha dipendenze esplicitamente elencate in un Cartfile, Carthage le recupererà automaticamente per te. Dovrai poi trascinarli tu stesso nel tuo progetto dalla cartella Carthage/Build.

Se il framework incorporato nel tuo progetto ha dipendenze da altri framework devi collegarli al target dell’applicazione (anche se il target dell’applicazione non ha dipendenze da quei framework e non li usa mai).

Usare i sottomoduli per le dipendenze

Per impostazione predefinita, Carthage esegue direttamente il checkout dei file sorgente delle dipendenze nella cartella del progetto, lasciandoti la possibilità di impegnarli o ignorarli a tua scelta. Se invece vuoi avere le dipendenze disponibili come sottomoduli Git (magari in modo da poter fare il commit e il push delle modifiche al loro interno), puoi eseguire carthage update o carthage checkout con il flag --use-submodules.

Quando viene eseguito in questo modo, Carthage scriverà nei file .gitmodules e .git/config del tuo repository, e aggiornerà automaticamente i sottomoduli quando la versione delle dipendenze cambia.

Ricostruire automaticamente le dipendenze

Se vuoi lavorare sulle tue dipendenze durante lo sviluppo, e vuoi che vengano ricostruite automaticamente quando costruisci il tuo progetto padre, puoi aggiungere una fase di build Run Script che invoca Carthage in questo modo:

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

Nota che dovresti usare i sottomoduli prima di fare questo, perché i checkout semplici non dovrebbero essere modificati direttamente.

Caching builds

Di default Carthage ricostruirà una dipendenza indipendentemente dal fatto che sia la stessa versione risolta di prima. Passando il --cache-builds farà sì che Carthage eviti di ricostruire una dipendenza se può. Vedere le informazioni sui file di versione per i dettagli su come Carthage esegue questo caching.

Nota: In questo momento --cache-builds è incompatibile con --use-submodules. L’utilizzo di entrambi avrà come risultato che la copia di lavoro e le modifiche commesse alla tua dipendenza del sottomodulo non saranno ricostruite correttamente. Vedi #1785 per i dettagli.

Completamento Bash/Zsh/Fish

Il completamento automatico dei comandi e delle opzioni di Carthage è disponibile come documentato in Bash/Zsh/Fish Completion.

Supporto di Carthage per il tuo framework

Carthage supporta ufficialmente solo framework dinamici. I framework dinamici possono essere usati su qualsiasi versione di OS X, ma solo su iOS 8 o successivo. Inoltre, dalla versione 0.30.0 Carthage supporta i framework statici.

Perché Carthage non ha un elenco centralizzato di pacchetti e nessun formato di specifiche di progetto, la maggior parte dei framework dovrebbe essere costruita automaticamente.

I requisiti specifici di ogni progetto framework sono elencati di seguito.

Condividi i tuoi schemi Xcode

Carthage costruirà solo schemi Xcode che sono condivisi dal tuo .xcodeproj. Puoi vedere se tutti i tuoi schemi previsti vengono costruiti con successo eseguendo carthage build --no-skip-current, poi controllando la cartella Carthage/Build.

Se uno schema importante non viene costruito quando esegui quel comando, apri Xcode e assicurati che lo schema sia segnato come Shared, così Carthage lo può scoprire.

Risolvi i fallimenti di compilazione

Se incontri fallimenti di compilazione in carthage build --no-skip-current, prova ad eseguire xcodebuild -scheme SCHEME -workspace WORKSPACE build o xcodebuild -scheme SCHEME -project PROJECT build (con i valori reali) e vedi se lo stesso fallimento si verifica lì. Questo dovrebbe fornire abbastanza informazioni per risolvere il problema.

Se avete più versioni degli strumenti di sviluppo Apple installate (una beta di Xcode, per esempio), usate xcode-select per cambiare quale versione usa Carthage.

Se non sei ancora in grado di costruire il tuo framework con Carthage, apri un problema e saremo felici di aiutarti!

Tag stable releases

Carthage determina quali versioni del tuo framework sono disponibili cercando tra i tag pubblicati sul repository, e cercando di interpretare ogni nome di tag come una versione semantica. Per esempio, nel tag v1.2, la versione semantica è 1.2.0.

I tag senza alcun numero di versione, o con caratteri che seguono il numero di versione (es, 1.2-alpha-1) non sono attualmente supportati e saranno ignorati.

Archivia i framework precostruiti in un file zip

Carthage può utilizzare automaticamente i framework precostruiti, invece di costruirli da zero, se sono allegati a una release GitHub sul repository del tuo progetto o tramite un file di definizione del progetto binario.

Per offrire framework precostruiti per un tag specifico, i binari per tutte le piattaforme supportate dovrebbero essere zippati insieme in un archivio, e tale archivio dovrebbe essere allegato a una release pubblicata corrispondente a quel tag. L’allegato dovrebbe includere .framework nel suo nome (ad esempio, ReactiveCocoa.framework.zip), per indicare a Carthage che contiene i binari. La struttura della directory dell’archivio è a forma libera, ma i framework dovrebbero apparire solo una volta nell’archivio, poiché saranno copiati in Carthage/Build/<platform> in base al loro nome (ad esempio ReactiveCocoa.framework).

Puoi eseguire l’operazione di archiviazione con carthage stesso usando:

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

o in alternativa

carthage build --archive

Le release provvisorie saranno automaticamente ignorate, anche se corrispondono al tag desiderato.

Usare travis-ci per caricare i propri framework pre-costruiti con tag

È possibile usare travis-ci per costruire e caricare le proprie release con tag.

1. Installa travis CLI con gem install travis

2. Imposta travis-ci per il tuo repository (Passi 1 e 2)

3. Crea .travis.yml file nella root del tuo repository basato su quel template. Imposta FRAMEWORK_NAME al valore corretto.

   Sostituisci PROJECT_PLACEHOLDER e SCHEME_PLACEHOLDER

   Se stai usando uno spazio di lavoro invece di un progetto rimuovi la linea xcode_project e decommenta la linea xcode_workspace.

   Il progetto dovrebbe essere nel formato: MyProject.xcodeproj

   Lo spazio di lavoro dovrebbe essere nel formato: MyWorkspace.xcworkspace

   Sentitevi liberi di aggiornare il valore xcode_sdk ad un altro SDK, notate che il test su iphoneos SDK richiederebbe di caricare un’identità per la firma del codice

   Per maggiori informazioni potete visitare la documentazione di travis per progetti 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. Eseguite travis setup releases, segui la documentazione qui

   Questo comando codificherà le tue credenziali GitHub nel file .travis.yml per permettere a travis di caricare la release su GitHub.comQuando viene richiesto il file da caricare, inserire $FRAMEWORK_NAME.framework.zip

5. Aggiornare la sezione deploy per eseguire sui tag:

   In .travis.yml individuare:

   on: repo: repo/repo

   E aggiungere tags: true e skip_cleanup: true:

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

   Questo permetterà a travis di sapere di creare un deployment quando un nuovo tag viene spinto e impedirà a travis di pulire il file zip generato

Costruisci framework statici per accelerare i tempi di lancio della tua app

Se incorpori molti framework dinamici nella tua app, i suoi tempi di lancio pre-main possono essere piuttosto lenti. Carthage è in grado di aiutare a mitigare questo problema costruendo i vostri framework dinamici come framework statici. I framework statici possono essere collegati direttamente nella vostra applicazione o fusi insieme in un framework dinamico più grande con alcune semplici modifiche al vostro flusso di lavoro, il che può portare a drastiche riduzioni dei tempi di lancio pre-main.

Carthage 0.30.0 o superiore

Dalla versione 0.30.0 il progetto Carthage offre supporto ai framework collegati staticamente scritti in Swift o Objective-C, supporto che è stato introdotto in Xcode 9.4. Si prega di notare però che si parla specificamente di framework, quindi di bundle Darwin con estensione .framework e archivi di oggetti collegati staticamente all’interno. Carthage attualmente non supporta schemi di librerie statiche, né ci sono piani per introdurre il loro supporto in futuro.

Il flusso di lavoro differisce appena:

• Hai ancora bisogno di spuntare gli schemi del tuo progetto conforme a Carthage come condivisi in Product > Scheme > Manage Schemes…, proprio come con i binari dinamici
• Hai ancora bisogno di linkare contro i .nelle fasi di compilazione del tuo progetto proprio come con i binari dinamici

Tuttavia:

• Nelle impostazioni di compilazione, sezione Linking, del tuo progetto Cocoa Framework target conforme a Carthage, imposta Mach-O Type su Static Library
• I tuoi framework collegati staticamente saranno compilati in ./Carthage/Build/$(PLATFORM_NAME)/Static
• Non dovresti aggiungere alcun framework statico come file di input/output in carthage copy-frameworks Build Phase

Carthage 0.29.0 o inferiore

Vedi il documento StaticFrameworks per dettagli.

Si prega di notare che alcuni avvertimenti si applicano a questo approccio:

• I framework statici Swift non sono ufficialmente supportati da Apple
• Questo è un flusso di lavoro avanzato che non è integrato in Carthage, YMMV

Dichiara la tua compatibilità

Vuoi pubblicizzare che il tuo progetto può essere usato con Carthage? Puoi aggiungere un badge di compatibilità:

… al tuo README, inserendo semplicemente il seguente Markdown:

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

Problemi noti

Problema dei simboli DWARFs

Il framework precostruito non può essere sottoposto a debug utilizzando l’esecuzione di passi su una macchina diversa da quella su cui il framework è stato costruito. Semplicemente carthage bootstrap/build/update --no-use-binaries dovrebbe risolvere questo problema, ma per un workaround più automatizzato, vedere #924. Duplica rdar://23551273 se vuoi che Apple risolva la causa principale di questo problema.

CarthageKit

La maggior parte delle funzionalità dello strumento a riga di comando carthage è effettivamente incapsulato in un framework chiamato CarthageKit.

Se sei interessato ad usare Carthage come parte di un altro strumento, o forse ad estendere le funzionalità di Carthage, dai un’occhiata al codice sorgente di CarthageKit per vedere se l’API si adatta alle tue esigenze.

Differenze tra Carthage e CocoaPods

CocoaPods è un gestore di dipendenze di vecchia data per Cocoa. Allora perché è stato creato Carthage?

In primo luogo, CocoaPods (per default) crea e aggiorna automaticamente uno spazio di lavoro Xcode per la tua applicazione e tutte le dipendenze. Carthage costruisce i binari del framework usando xcodebuild, ma lascia la responsabilità di integrarli all’utente. L’approccio di CocoaPods è più facile da usare, mentre quello di Carthage è flessibile e non intrusivo.

L’obiettivo di CocoaPods è elencato nel suo README come segue:

… per migliorare la scopribilità e l’impegno nelle librerie open-source di terze parti, creando un ecosistema più centralizzato.

Al contrario, Carthage è stato creato come un gestore di dipendenze decentralizzato. Non c’è una lista centrale di progetti, il che riduce il lavoro di manutenzione ed evita qualsiasi punto centrale di fallimento. Tuttavia, la scoperta dei progetti è più difficile – gli utenti devono ricorrere alle pagine Trending di GitHub o simili.

I progetti CocoaPods devono anche avere quello che è conosciuto come un file podspec, che include metadati sul progetto e specifica come dovrebbe essere costruito. Carthage usa xcodebuild per costruire le dipendenze, invece di integrarle in un unico spazio di lavoro, non ha un file di specifica simile ma le vostre dipendenze devono includere il proprio progetto Xcode che descrive come costruire i loro prodotti.

In definitiva, abbiamo creato Carthage perché volevamo lo strumento più semplice possibile – un gestore di dipendenze che facesse il lavoro senza assumersi la responsabilità di Xcode, e senza creare lavoro extra per gli autori di framework. CocoaPods offre molte caratteristiche sorprendenti che Carthage non avrà mai, a spese di una maggiore complessità.

Licenza

Carthage è rilasciato sotto la MIT License.

La foto dello sfondo è rilasciata sotto licenza CC BY-NC-SA 2.0. Foto originale di Richard Mortel.