Carthage / Carthage

Carthage soll der einfachste Weg sein, Frameworks zu Ihrer Cocoa-Anwendung hinzuzufügen.

Carthage baut Ihre Abhängigkeiten und stellt Ihnen binäre Frameworks zur Verfügung, aber Sie behalten die volle Kontrolle über Ihre Projektstruktur und -einrichtung. Carthage ändert nicht automatisch Ihre Projektdateien oder Ihre Build-Einstellungen.

• Schnellstart
• Installation von Carthage
• Hinzufügen von Frameworks zu einer Anwendung
  • Erste Schritte
    • Erstellen plattform-unabhängiger XCFrameworks
      • Migrieren eines Projekts von Framework-Bundles zu XCFrameworks
    • Erstellen plattformspezifischer Framework-Bundles
      • Wenn Sie für macOS bauen
      • Wenn Sie für iOS, tvOS, oder watchOS
    • Für alle Plattformen
    • (Optional) Build-Phase hinzufügen, um vor veralteten Abhängigkeiten zu warnen
    • Kompatibilität des Downloads von binären Frameworks
  • Ausführen eines Projekts, das Carthage verwendet
  • Hinzufügen von Frameworks zu Unit-Tests oder einem Framework
  • Upgrading von Frameworks
    • Experimental Resolver
  • Verschachtelte Abhängigkeiten
  • Verwendung von Submodulen für Abhängigkeiten
  • Automatischer Neuaufbau von Abhängigkeiten
  • Caching von Builds
  • Bash/Zsh/Fish-Vervollständigung
• Unterstützung von Carthage für Ihr Framework
  • Teilen Sie Ihre Xcode-Schemata
  • Beheben Sie Build-Fehler
  • Taggen Sie stabile Releases
  • Archivieren Sie vorgefertigte Frameworks in einer Zip-Datei
    • Verwenden Sie travis-ci, um Ihre getaggten vorgefertigten Frameworks hochzuladen
  • Statische Frameworks bauen, um die Startzeiten Ihrer App zu beschleunigen
  • Kompatibilität erklären
• Bekannte Probleme
  • DWARFs Symbolproblem
• CarthageKit
• Unterschiede zwischen Carthage und CocoaPods
• Lizenz

Schnellstart

1. Erstelle Carthage durch Ausführen von brew install carthage oder wähle eine andere Installationsmethode

2. Erstelle ein Cartfile im selben Verzeichnis, in dem sich dein .xcodeproj oder .xcworkspace befindet

3. Liste die gewünschten Abhängigkeiten im Cartfile auf, zum Beispiel:

   github "Alamofire/Alamofire" ~> 4.7.2

4. Starten Sie carthage update --use-xcframeworks

5. Eine Cartfile.resolvedDatei und ein CarthageVerzeichnis erscheinen im selben Verzeichnis, in dem sich Ihre .xcodeproj oder .xcworkspace befindet

6. Ziehen Sie die erstellten .xcframeworkBundles aus Carthage/Build in den Abschnitt „Frameworks und Bibliotheken“ des Xcode-Projekts Ihrer Anwendung.

7. Wenn Sie Carthage für eine Anwendung verwenden, wählen Sie „Embed & Sign“, andernfalls „Do Not Embed“.

Für eine ausführliche Anleitung lesen Sie weiter unter Hinzufügen von Frameworks zu einer Anwendung

Installieren von Carthage

Es gibt mehrere Optionen für die Installation von Carthage:

• Installer: Laden Sie die Carthage.pkg-Datei für die neueste Version herunter, führen Sie sie aus und folgen Sie den Anweisungen auf dem Bildschirm. Wenn Sie das pkg über CLI installieren, müssen Sie möglicherweise zuerst sudo chown -R $(whoami) /usr/local ausführen.

• Homebrew: Sie können Homebrew verwenden und das Tool carthage auf Ihrem System installieren, indem Sie einfach brew update und brew install carthage ausführen. (Hinweis: Wenn Sie zuvor die binäre Version von Carthage installiert haben, sollten Sie /Library/Frameworks/CarthageKit.framework löschen).

• MacPorts: Sie können MacPorts verwenden und das Tool carthage auf Ihrem System installieren, indem Sie einfach sudo port selfupdate und sudo port install carthage ausführen. (Hinweis: Wenn Sie zuvor die Binärversion von Carthage installiert haben, sollten Sie /Library/Frameworks/CarthageKit.framework löschen).

• Aus dem Quellcode: Wenn Sie die neueste Entwicklungsversion verwenden möchten (die sehr instabil oder inkompatibel sein kann), klonen Sie einfach den master-Zweig des Repositorys und führen Sie dann make install aus. Erfordert Xcode 10.0 (Swift 4.2).

Hinzufügen von Frameworks zu einer Anwendung

Sobald Sie Carthage installiert haben, können Sie beginnen, Frameworks zu Ihrem Projekt hinzuzufügen. Beachten Sie, dass Carthage nur dynamische Frameworks unterstützt, die nur unter iOS 8 oder höher (oder einer beliebigen Version von OS X) verfügbar sind.

Erste Schritte

Erstellen von plattformunabhängigen XCFrameworks (Xcode 12 und höher)

1. Erstellen Sie ein Cartfile, das die Frameworks auflistet, die Sie in Ihrem Projekt verwenden möchten.
2. Starten Sie carthage update --use-xcframeworks. Dadurch werden Abhängigkeiten in einen Carthage/Checkouts-Ordner geholt und jedes einzelne Framework gebaut oder ein vorkompiliertes XCFramework heruntergeladen.
3. Ziehen Sie auf der Registerkarte „Allgemeine Einstellungen“ Ihrer Anwendungsziele im Abschnitt „Frameworks, Bibliotheken und eingebettete Inhalte“ jedes XCFramework, das Sie verwenden möchten, per Drag & Drop aus dem Carthage/Build-Ordner auf die Festplatte.

Migrieren eines Projekts von Framework-Bundles zu XCFrameworks

Wir empfehlen die Verwendung von XCFrameworks ab Version 0.37.0 (Januar 2021) und setzen XCFrameworks voraus, wenn Sie auf einem Apple Silicon Mac bauen. Der Wechsel von diskreten Framework-Bundles zu XCFrameworks erfordert ein paar Änderungen an Ihrem Projekt:

Migrationsschritte

1. Löschen Sie Ihren Carthage/Build-Ordner, um alle vorhandenen Framework-Bundles zu entfernen.
2. Erstellen Sie neue XCFrameworks, indem Sie carthage build --use-xcframeworks ausführen. Alle anderen Argumente, mit denen Sie bauen, können wie üblich angegeben werden.
3. Entfernen Sie Verweise auf die alten Frameworks in jedem Ihrer Ziele:
   • Löschen Sie Verweise auf Carthage-Frameworks aus dem Abschnitt „Frameworks, Bibliotheken und eingebettete Inhalte“ des Ziels und/oder der Bauphase „Link Binary with Libraries“.
   • Löschen Sie Verweise auf Carthage-Frameworks aus allen Bauphasen „Copy Files“.
   • Löschen Sie die Bauphase „carthage copy-frameworks“ des Ziels, falls vorhanden.
4. Fügen Sie Verweise auf XCFrameworks in jedem Ihrer Ziele hinzu:
   • Für ein Anwendungsziel: Ziehen Sie auf der Registerkarte „Allgemeine Einstellungen“ im Abschnitt „Frameworks, Bibliotheken und eingebettete Inhalte“ jedes von Ihnen verwendete XCFramework aus dem Ordner „Carthage/Build“ auf die Festplatte.
   • Für ein Framework-Ziel: Ziehen Sie auf der Registerkarte „Erstellungsphasen“ in einer Phase „Binär mit Bibliotheken verknüpfen“ jedes verwendete XCFramework aus dem Ordner „Carthage/Build“ auf die Festplatte und legen Sie es ab.

Erstellen plattformspezifischer Framework-Bundles (Standard für Xcode 11 und darunter)

Xcode 12+ Inkompatibilität: Multi-Architektur-Plattformen werden beim Erstellen von Framework-Bundles in Xcode 12 und höher nicht unterstützt. Bevorzugen Sie die Erstellung mit XCFrameworks. Wenn Sie diskrete Framework-Bundles erstellen müssen, verwenden Sie als Umgehung die xcconfig-Datei.

Wenn Sie für macOS bauen

macOS-spezifische Anweisungen

1. Erstellen Sie eine Cart-Datei, die die Frameworks auflistet, die Sie in Ihrem Projekt verwenden möchten.
2. Starten Sie carthage update --platform macOS. Dadurch werden Abhängigkeiten in einen Carthage/Checkouts-Ordner geholt und jedes einzelne Framework gebaut oder ein vorkompiliertes Framework heruntergeladen.
3. Ziehen Sie auf der Registerkarte „Allgemeine Einstellungen“ Ihrer Anwendungsziele im Abschnitt „Eingebettete Binärdateien“ jedes Framework, das Sie verwenden möchten, per Drag & Drop aus dem Carthage/Build-Ordner auf die Festplatte.

Zusätzlich müssen Sie Debugsymbole für das Debugging und die Absturzmeldung unter OS X kopieren.

1. Klicken Sie auf der Registerkarte „Build Phases“ Ihres Anwendungsziels auf das +-Symbol und wählen Sie „New Copy Files Phase“ aus.
2. Klicken Sie auf das Dropdown-Menü „Destination“ und wählen Sie „Products Directory“ aus.
3. Ziehen Sie für jedes von Ihnen verwendete Framework die entsprechende dSYM-Datei und legen Sie sie ab.

Wenn Sie für iOS, tvOS oder watchOS bauen

Plattformspezifische Anweisungen

1. Erstellen Sie eine Cartfile, die die Frameworks auflistet, die Sie in Ihrem Projekt verwenden möchten.

2. Starten Sie carthage update. Dadurch werden die Abhängigkeiten in einen Cartage/Checkouts-Ordner geholt und dann jedes einzelne Framework erstellt oder ein vorkompiliertes Framework heruntergeladen.

3. Öffnen Sie die Registerkarte „Allgemeine Einstellungen“ Ihrer Anwendungsziele. Bei Xcode 11.0 und höher ziehen Sie im Abschnitt „Frameworks, Bibliotheken und eingebettete Inhalte“ jedes Framework, das Sie verwenden möchten, per Drag-and-Drop aus dem Ordner „Carthage/Build“ auf die Festplatte. Wählen Sie dann im Abschnitt „Einbetten“ für jedes hinzugefügte Element die Option „Nicht einbetten“ aus dem Pulldown-Menü. Bei Xcode 10.x und niedrigeren Versionen ziehen Sie im Abschnitt „Verknüpfte Frameworks und Bibliotheken“ jedes Framework, das Sie verwenden möchten, aus dem Ordner „Carthage/Build“ auf die Festplatte.

4. Klicken Sie auf der Registerkarte „Build-Phasen“ Ihrer Anwendungsziele auf das Symbol „+“ und wählen Sie „Neue Skriptausführungsphase“. Erstellen Sie ein Run Script, in dem Sie Ihre Shell angeben (z. B. /bin/sh), und fügen Sie den folgenden Inhalt in den Skriptbereich unterhalb der Shell ein:

   /usr/local/bin/carthage copy-frameworks

5. Erstellen Sie eine Datei mit dem Namen input.xcfilelist und eine Datei mit dem Namen output.xcfilelist

6. Fügen Sie die Pfade zu den Frameworks, die Sie verwenden möchten, zu Ihrer input.xcfilelist hinzu. Beispiel:

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

7. Fügen Sie die Pfade zu den kopierten Frameworks in die Datei output.xcfilelist ein. Beispiel:

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

   Wenn neben den Eingabedateien auch Ausgabedateien angegeben sind, muss Xcode das Skript nur ausführen, wenn sich die Eingabedateien geändert haben oder die Ausgabedateien fehlen. Das bedeutet, dass Dirty Builds schneller sind, wenn Sie Frameworks nicht mit Carthage neu erstellt haben.

8. Hinzufügen von input.xcfilelist zum Abschnitt „Input File Lists“ der Carthage-Run-Skript-Phase

9. Hinzufügen von output.xcfilelist zum Abschnitt „Output File Lists“ der Carthage-Run-Skript-Phase

Dieses Skript umgeht einen App Store-Übermittlungsfehler, der durch universelle Binärdateien ausgelöst wird, und stellt sicher, dass notwendige Bitcode-bezogene Dateien und dSYMs beim Archivieren kopiert werden.

Mit den Debug-Informationen, die in das Verzeichnis „built products“ kopiert werden, kann Xcode den Stack-Trace symbolisieren, wenn Sie an einem Haltepunkt anhalten. So können Sie auch den Code von Drittanbietern im Debugger durchgehen.

Wenn Sie Ihre Anwendung für die Einreichung im App Store oder bei TestFlight archivieren, kopiert Xcode diese Dateien auch in das Unterverzeichnis dSYMs des .xcarchiveBundles Ihrer Anwendung.

Für alle Plattformen

Auf dem Weg hat Carthage einige Build-Artefakte erstellt. Das wichtigste davon ist die Datei Cartfile.resolved, in der die Versionen aufgelistet sind, die für jedes Framework tatsächlich gebaut wurden. Stellen Sie sicher, dass Sie Ihre Cartfile.resolved Datei übergeben, da jeder, der das Projekt verwendet, diese Datei benötigt, um die gleichen Framework-Versionen zu bauen.

(Optional) Build-Phase hinzufügen, um vor veralteten Abhängigkeiten zu warnen

Sie können eine Run Script Phase hinzufügen, um automatisch gewarnt zu werden, wenn eine Ihrer Abhängigkeiten veraltet ist.

1. Klicken Sie auf der Build PhasesEinstellungsregisterkarte Ihrer Anwendungsziele auf das +Symbol und wählen Sie New Run Script Phase. Erstellen Sie ein Ausführungsskript, in dem Sie Ihre Shell angeben (z. B. /bin/sh), und fügen Sie den folgenden Inhalt in den Skriptbereich unter der Shell ein:

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

Kompatibilität der heruntergeladenen Swift-Binärframeworks

Carthage prüft, ob die heruntergeladenen Swift-Frameworks (und gemischte Objective-C/Swift-Frameworks) mit der gleichen Version von Swift erstellt wurden, die lokal verwendet wird. Wenn es eine Versionsabweichung gibt, wird Carthage fortfahren, das Framework aus dem Quellcode zu erstellen. Wenn das Framework nicht aus dem Quellcode erstellt werden kann, schlägt Carthage fehl.

Da Carthage die Ausgabe von xcrun swift --version verwendet, um die lokale Swift-Version zu bestimmen, stellen Sie sicher, dass Sie die Carthage-Befehle mit der Swift-Toolchain ausführen, die Sie verwenden möchten. Für viele Anwendungsfälle ist nichts Zusätzliches erforderlich. Wenn Sie jedoch zum Beispiel ein Swift 2.3-Projekt mit Xcode 8.x erstellen, ist eine Möglichkeit, Ihre Voreinstellung swift für carthage bootstrap festzulegen, die Verwendung des folgenden Befehls:

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

Ausführen eines Projekts, das Carthage verwendet

Nachdem Sie die oben genannten Schritte durchgeführt und Ihre Änderungen veröffentlicht haben, müssen andere Benutzer des Projekts nur noch das Repository abrufen und carthage bootstrap ausführen, um mit den von Ihnen hinzugefügten Frameworks zu arbeiten.

Hinzufügen von Frameworks zu Unit Tests oder einem Framework

Die Verwendung von Carthage für die Abhängigkeiten eines beliebigen Ziels ist der Verwendung von Carthage für eine Anwendung ziemlich ähnlich. Der Hauptunterschied liegt in der Art und Weise, wie die Frameworks in Xcode tatsächlich eingerichtet und verknüpft werden.

Da den Unit-Test-Zielen der Abschnitt „Verknüpfte Frameworks und Bibliotheken“ in der Registerkarte „Allgemeine Einstellungen“ fehlt, müssen Sie die erstellten Frameworks stattdessen in die Erstellungsphase „Binärdateien mit Bibliotheken verknüpfen“ ziehen.

Fügen Sie im Testziel auf der Registerkarte „Build Settings“ @loader_path/Frameworks zu den Runpath Search Paths hinzu, wenn es nicht bereits vorhanden ist.

In seltenen Fällen möchten Sie vielleicht auch jede Abhängigkeit in das Build-Produkt kopieren (z. B., um Abhängigkeiten in das äußere Framework einzubetten, oder um sicherzustellen, dass Abhängigkeiten in einem Test-Bundle vorhanden sind). Erstellen Sie dazu eine neue Build-Phase Copy Files mit dem Ziel Frameworks und fügen Sie die Framework-Referenz auch dort ein. Sie sollten den Befehl carthage copy-frameworks nicht verwenden, da Test-Bundles keine gestrippten Frameworks benötigen und das gleichzeitige Ausführen von copy-frameworks (mit eingeschalteten parallelen Builds) nicht unterstützt wird.

Upgraden von Frameworks

Wenn Sie Ihr Cartfile geändert haben oder auf die neuesten Versionen der einzelnen Frameworks aktualisieren möchten (vorbehaltlich der von Ihnen angegebenen Anforderungen), führen Sie einfach den Befehl carthage update erneut aus.

Wenn Sie nur eine oder bestimmte Abhängigkeiten aktualisieren möchten, übergeben Sie diese als durch Leerzeichen getrennte Liste an den update-Befehl. z.B.

carthage update Box

oder

carthage update Box Result

Experimenteller Resolver

Die Logik für die Aktualisierung von Frameworks wurde neu geschrieben, um die Geschwindigkeit zu erhöhen und den Speicherverbrauch zu reduzieren. Es handelt sich derzeit um eine Opt-in-Funktion. Sie kann durch die Übergabe von --new-resolver an den Update-Befehl verwendet werden, z.B.

carthage update --new-resolver Box

Wenn Sie Leistungsprobleme bei Updates haben, probieren Sie bitte den neuen Resolver aus

Verschachtelte Abhängigkeiten

Wenn das Framework, das Sie zu Ihrem Projekt hinzufügen möchten, Abhängigkeiten hat, die explizit in einem Cartfile aufgelistet sind, wird Carthage diese automatisch für Sie abrufen. Sie müssen sie dann selbst aus dem Carthage/Build-Ordner in Ihr Projekt ziehen.

Wenn das eingebettete Framework in Ihrem Projekt Abhängigkeiten zu anderen Frameworks hat, müssen Sie diese mit dem Anwendungsziel verknüpfen (auch wenn das Anwendungsziel keine Abhängigkeit zu diesen Frameworks hat und sie nie verwendet).

Verwendung von Submodulen für Abhängigkeiten

Standardmäßig checkt Carthage die Quelldateien der Abhängigkeiten direkt in den Projektordner aus und überlässt es Ihnen, sie nach Belieben zu committen oder zu ignorieren. Wenn Sie die Abhängigkeiten stattdessen als Git-Submodule zur Verfügung haben möchten (z.B. um Änderungen darin zu übertragen und zu pushen), können Sie carthage update oder carthage checkout mit dem --use-submodules-Flag ausführen.

Auf diese Weise schreibt Carthage in die .gitmodules– und .git/config-Dateien Ihres Repositorys und aktualisiert die Submodule automatisch, wenn sich die Versionen der Abhängigkeiten ändern.

Abhängigkeiten automatisch neu aufbauen

Wenn Sie während der Entwicklung an Ihren Abhängigkeiten arbeiten wollen und möchten, dass diese automatisch neu aufgebaut werden, wenn Sie Ihr übergeordnetes Projekt bauen, können Sie eine Run-Script-Build-Phase hinzufügen, die Carthage wie folgt aufruft:

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

Beachten Sie, dass Sie Submodule verwenden sollten, bevor Sie dies tun, denn einfache Checkouts sollten nicht direkt geändert werden.

Zwischenspeichern von Builds

Standardmäßig baut Carthage eine Abhängigkeit neu auf, unabhängig davon, ob es sich um die gleiche aufgelöste Version wie zuvor handelt. Die Übergabe von --cache-builds veranlasst Carthage, den Neuaufbau einer Abhängigkeit zu vermeiden, wenn es möglich ist. Siehe Informationen über Versionsdateien für Details darüber, wie Carthage diese Zwischenspeicherung durchführt.

Hinweis: Zur Zeit ist --cache-builds nicht kompatibel mit --use-submodules. Die Verwendung beider führt dazu, dass die Arbeitskopie und die übertragenen Änderungen an der Submodulabhängigkeit nicht korrekt wiederhergestellt werden. Siehe #1785 für Details.

Bash/Zsh/Fish Vervollständigung

Automatische Vervollständigung von Carthage Befehlen und Optionen sind verfügbar wie in Bash/Zsh/Fish Vervollständigung dokumentiert.

Unterstützung von Carthage für Ihr Framework

Carthage unterstützt offiziell nur dynamische Frameworks. Dynamische Frameworks können auf jeder Version von OS X verwendet werden, aber nur auf iOS 8 oder höher. Zusätzlich unterstützt Carthage seit Version 0.30.0 statische Frameworks.

Da Carthage keine zentralisierte Paketliste und kein Projektspezifikationsformat hat, sollten die meisten Frameworks automatisch gebaut werden.

Die spezifischen Anforderungen eines Framework-Projekts sind unten aufgeführt.

Geben Sie Ihre Xcode-Schemata frei

Carthage wird nur Xcode-Schemata bauen, die von Ihrem .xcodeproj freigegeben sind. Sie können sehen, ob alle Ihre beabsichtigten Schemata erfolgreich gebaut werden, indem Sie carthage build --no-skip-current ausführen und dann den Ordner Carthage/Build überprüfen.

Wenn ein wichtiges Schema nicht gebaut wird, wenn Sie diesen Befehl ausführen, öffnen Sie Xcode und stellen Sie sicher, dass das Schema als freigegeben markiert ist, damit Carthage es erkennen kann.

Beheben Sie Build-Fehler

Wenn Sie Build-Fehler in carthage build --no-skip-current feststellen, versuchen Sie, xcodebuild -scheme SCHEME -workspace WORKSPACE build oder xcodebuild -scheme SCHEME -project PROJECT build (mit den aktuellen Werten) auszuführen und sehen Sie, ob dort der gleiche Fehler auftritt. Dies sollte hoffentlich genügend Informationen liefern, um das Problem zu beheben.

Wenn Sie mehrere Versionen der Apple-Entwicklerwerkzeuge installiert haben (zum Beispiel eine Xcode-Beta), verwenden Sie xcode-select, um zu ändern, welche Version Carthage verwendet.

Wenn Sie immer noch nicht in der Lage sind, Ihr Framework mit Carthage zu bauen, öffnen Sie bitte ein Problem und wir helfen Ihnen gerne!

Tag stable releases

Carthage bestimmt, welche Versionen Ihres Frameworks verfügbar sind, indem es die im Repository veröffentlichten Tags durchsucht und versucht, jeden Tag-Namen als semantische Version zu interpretieren. Zum Beispiel ist im Tag v1.2 die semantische Version 1.2.0.

Tags ohne Versionsnummer oder mit beliebigen Zeichen nach der Versionsnummer (z.B., 1.2-alpha-1) werden derzeit nicht unterstützt und werden ignoriert.

Archivieren Sie vorgefertigte Frameworks in einer Zip-Datei

Carthage kann automatisch vorgefertigte Frameworks verwenden, anstatt sie von Grund auf neu zu erstellen, wenn sie an eine GitHub-Veröffentlichung im Repository Ihres Projekts oder über eine binäre Projektdefinitionsdatei angehängt sind.

Um vorgefertigte Frameworks für ein bestimmtes Tag anzubieten, sollten die Binärdateien für alle unterstützten Plattformen zusammen in ein Archiv gezippt werden, und dieses Archiv sollte an ein veröffentlichtes Release für dieses Tag angehängt werden. Der Anhang sollte .framework in seinem Namen enthalten (z.B. ReactiveCocoa.framework.zip), um Carthage anzuzeigen, dass es Binärdateien enthält. Die Verzeichnisstruktur des Archivs ist frei wählbar, Frameworks sollten jedoch nur einmal im Archiv vorkommen, da sie anhand ihres Namens (z. B. ReactiveCocoa.framework) nach Carthage/Build/<platform> kopiert werden.

Sie können die Archivierung mit Carthage selbst durchführen, indem Sie Folgendes verwenden:

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

oder alternativ

carthage build --archive

Entwürfe von Releases werden automatisch ignoriert, selbst wenn sie dem gewünschten Tag entsprechen.

Verwenden Sie travis-ci, um Ihre getaggten vorgefertigten Frameworks hochzuladen

Es ist möglich, travis-ci zu verwenden, um Ihre getaggten Releases zu erstellen und hochzuladen.

1. Installieren Sie travis CLI mit gem install travis

2. Richten Sie travis-ci für Ihr Repository ein (Schritte 1 und 2)

3. Erstellen Sie .travis.ymleine Datei im Stammverzeichnis Ihres Repositorys, die auf dieser Vorlage basiert. Setzen Sie FRAMEWORK_NAME auf den richtigen Wert.

   Ersetzen Sie PROJECT_PLACEHOLDER und SCHEME_PLACEHOLDER

   Wenn Sie einen Workspace anstelle eines Projekts verwenden, entfernen Sie die Zeile xcode_project und heben Sie die Kommentierung der Zeile xcode_workspace auf.

   Das Projekt sollte das Format haben: MeinProjekt.xcodeproj

   Der Arbeitsbereich sollte im Format: MyWorkspace.xcworkspace

   Fühlen Sie sich frei, den xcode_sdk Wert auf ein anderes SDK zu aktualisieren, beachten Sie, dass das Testen auf iphoneos SDK das Hochladen einer Code Signing Identity erfordern würde

   Für weitere Informationen können Sie die Travis Docs für Objective-C-Projekte besuchen

   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, folgen Sie der Dokumentation hier

   Dieser Befehl kodiert Ihre GitHub-Anmeldeinformationen in die .travis.yml-Datei, damit travis die Veröffentlichung auf GitHub hochladen kann.comWenn Sie nach der hochzuladenden Datei gefragt werden, geben Sie $FRAMEWORK_NAME.framework.zip

5. Aktualisieren Sie den Bereitstellungsabschnitt, damit er auf Tags ausgeführt wird:

   In .travis.yml suchen Sie:

   on: repo: repo/repo

   Und fügen Sie tags: true und skip_cleanup: true hinzu:

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

   Damit weiß Travis, dass ein Deployment erstellt werden muss, wenn ein neuer Tag gepusht wird, und verhindert, dass Travis die generierte Zip-Datei bereinigt

Bauen Sie statische Frameworks ein, um die Startzeiten Ihrer App zu beschleunigen

Wenn Sie viele dynamische Frameworks in Ihre App einbetten, können die Startzeiten vor dem Hauptstart recht langsam sein. Carthage kann dies abmildern, indem es Ihre dynamischen Frameworks stattdessen als statische Frameworks erstellt. Statische Frameworks können direkt in Ihre Anwendung eingebunden oder mit ein paar einfachen Änderungen an Ihrem Arbeitsablauf zu einem größeren dynamischen Framework zusammengeführt werden, was zu einer drastischen Verringerung der Pre-Main-Startzeiten führen kann.

Carthage 0.30.0 oder höher

Seit Version 0.30.0 bietet das Carthage-Projekt Unterstützung für statisch eingebundene Frameworks, die in Swift oder Objective-C geschrieben sind, wofür die Unterstützung in Xcode 9.4 eingeführt wurde. Bitte beachten Sie jedoch, dass hier ausdrücklich von Frameworks die Rede ist, also von Darwin-Bundles mit der Erweiterung .framework und statisch gelinkten Objektarchiven darin. Carthage unterstützt derzeit keine statischen Bibliotheksschemata und es gibt auch keine Pläne, diese in Zukunft einzuführen.

Der Arbeitsablauf unterscheidet sich kaum:

• Sie müssen die Schemata Ihres Carthage-kompatiblen Projekts immer noch als gemeinsam genutzt in Product > Scheme > Manage Schemes… markieren, genau wie bei dynamischen Binärdateien
• Sie müssen immer noch gegen statische .Frameworks in den Build-Phasen Ihres Projekts verlinken, genau wie bei dynamischen Binärdateien

Allerdings:

• In den Build-Einstellungen des Cocoa-Framework-Ziels Ihres Carthage-kompatiblen Projekts, Abschnitt Linking, setzen Sie Mach-O Type auf Static Library
• Ihre statisch verlinkten Frameworks werden unter ./Carthage/Build/$(PLATFORM_NAME)/Static
• Sie sollten keine statischen Frameworks als Input/Output Dateien in der carthage copy-frameworks Build Phase hinzufügen

Carthage 0.29.0 oder niedriger

Siehe die StaticFrameworks Doku für Details.

Bitte beachten Sie, dass für diesen Ansatz einige Vorbehalte gelten:

• Swift StaticFrameworks werden von Apple nicht offiziell unterstützt
• Dies ist ein fortgeschrittener Arbeitsablauf, der nicht in Carthage integriert ist, YMMV

Deklarieren Sie Ihre Kompatibilität

Sollen Sie darauf hinweisen, dass Ihr Projekt mit Carthage verwendet werden kann? Sie können eine Kompatibilitätsplakette:

… zu Ihrem README hinzufügen, indem Sie einfach den folgenden Markdown einfügen:

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

Bekannte Probleme

DWARFs Symbolproblem

Vorgefertigte Frameworks können nicht mit Hilfe von Step Execution auf einem anderen Rechner als dem, auf dem das Framework erstellt wurde, debugged werden. Einfach carthage bootstrap/build/update --no-use-binaries sollte dieses Problem beheben, aber für einen automatisierten Workaround, siehe #924. Duplizieren Sie rdar://23551273, wenn Sie möchten, dass Apple die Ursache dieses Problems behebt.

CarthageKit

Der größte Teil der Funktionalität des carthage Kommandozeilenwerkzeugs ist in einem Framework namens CarthageKit gekapselt.

Wenn Sie daran interessiert sind, Carthage als Teil eines anderen Tools zu verwenden oder vielleicht die Funktionalität von Carthage zu erweitern, werfen Sie einen Blick auf den Quellcode von CarthageKit, um zu sehen, ob die API Ihren Bedürfnissen entspricht.

Unterschiede zwischen Carthage und CocoaPods

CocoaPods ist ein langjähriger Abhängigkeitsmanager für Cocoa. Warum also wurde Carthage entwickelt?

Zunächst einmal erstellt und aktualisiert CocoaPods (standardmäßig) automatisch einen Xcode-Arbeitsbereich für Ihre Anwendung und alle Abhängigkeiten. Carthage erstellt Framework-Binärdateien mit xcodebuild, überlässt aber die Verantwortung für deren Integration dem Benutzer. Der Ansatz von CocoaPods ist einfacher zu verwenden, während der von Carthage flexibel und unaufdringlich ist.

Das Ziel von CocoaPods ist in der README wie folgt aufgeführt:

… die Auffindbarkeit von und das Engagement für Open-Source-Bibliotheken von Drittanbietern zu verbessern, indem ein zentralisiertes Ökosystem geschaffen wird.

Im Gegensatz dazu wurde Carthage als dezentraler Abhängigkeitsmanager entwickelt. Es gibt keine zentrale Liste von Projekten, was den Wartungsaufwand reduziert und einen zentralen Fehlerpunkt vermeidet. Allerdings ist das Auffinden von Projekten schwieriger – die Nutzer müssen auf die Trending-Seiten von GitHub oder ähnliche Seiten zurückgreifen.

CocoaPods-Projekte müssen außerdem eine so genannte Podspec-Datei haben, die Metadaten über das Projekt enthält und angibt, wie es gebaut werden soll. Carthage verwendet xcodebuild, um Abhängigkeiten zu bauen, anstatt sie in einen einzigen Arbeitsbereich zu integrieren, es hat keine ähnliche Spezifikationsdatei, aber Ihre Abhängigkeiten müssen ihr eigenes Xcode-Projekt enthalten, das beschreibt, wie ihre Produkte zu bauen sind.

Letztendlich haben wir Carthage entwickelt, weil wir ein möglichst einfaches Werkzeug wollten – einen Abhängigkeitsmanager, der die Arbeit erledigt, ohne die Verantwortung von Xcode zu übernehmen und ohne zusätzliche Arbeit für Framework-Autoren zu schaffen. CocoaPods bietet viele erstaunliche Funktionen, die Carthage nie haben wird, auf Kosten zusätzlicher Komplexität.

Lizenz

Carthage wird unter der MIT-Lizenz veröffentlicht.

Hintergrundfoto wird unter der CC BY-NC-SA 2.0 Lizenz veröffentlicht. Originalfoto von Richard Mortel.