Carthage / Carthage

Carthage pretende ser a maneira mais simples de adicionar frameworks à sua aplicação Cocoa.

Carthage constrói suas dependências e fornece a você frameworks binários, mas você mantém controle total sobre a estrutura e configuração do seu projeto. Carthage não modifica automaticamente seus arquivos de projeto ou suas configurações de construção.

• Inicio rápido
• Instalando Carthage
• Adicionando frameworks a um aplicativo
  • Começando
    • Construindo plataforma-XCFrameworks independente
      • Migrating a project from framework bundles to XCFrameworks
    • Construir framework bundles específicos da plataforma
      • Se estiver a construir para macOS
      • Se estiver a construir para iOS, tvOS, ou watchOS
    • Para todas as plataformas
    • (Opcionalmente) Adicionar fase de construção para avisar sobre dependências ultrapassadas
    • Compatibilidade de download do framework binário do Swift
  • Executar um projecto que usa Cartago
  • Adicionar estruturas a testes unitários ou uma estrutura
  • Actualizar estruturas
    • Experimental Resolver
  • Nested dependências
  • Utilizar submódulos para dependências
  • Redificar dependências automaticamente
  • Caching builds
  • Bash/Zsh/Fish completion
• Apoio Cartago para o seu framework
  • Partilhe os seus esquemas de código X
  • Resolver falhas de construção

  >

  • Lançamentos estáveis da Tag
  • Arquivar frameworks pré-construídas em um arquivo zip
    >
    • Utilizar travis-ci para carregar os seus frameworks pré-construídos marcados
  • Build static frameworks para acelerar os tempos de lançamento do seu aplicativo
  • Declarar a sua compatibilidade
• Problemas conhecidos
  • Problemas com símbolos DWARFs
• CarthageKit
• Diferenças entre Carthage e CocoaPods
• Licença

Início Rápido

1. >

   Apanhar Cartago executando brew install carthage ou escolher outro método de instalação

2. Criar um arquivo de Cartas no mesmo diretório onde o seu .xcodeproj ou .xcworkspace é

3. Listar as dependências desejadas no arquivo de Cartas, por exemplo:

   github "Alamofire/Alamofire" ~> 4.7.2

4. Executar carthage update --use-xcframeworks

5. A Cartfile.resolved ficheiro e um directório Carthage aparecerá no mesmo directório onde o seu .xcodeproj ou .xcworkspace é

6. Arraste os pacotes construídos .xcframework de Carthage/Build para a secção “Frameworks and Libraries” do projecto Xcode da sua aplicação.

7. Se estiver usando Carthage para uma aplicação, selecione “Embed & Sign”, caso contrário “Do Not Embed”.

Para um guia de profundidade, leia a partir de Adding frameworks to an application

Installing Carthage

Existem múltiplas opções para instalar Carthage:

• Installer: Baixe e execute o arquivo Carthage.pkg para o último lançamento, depois siga as instruções na tela. Se você estiver instalando o pkg via CLI, você pode precisar executar sudo chown -R $(whoami) /usr/local primeiro.

• Homebrew: Você pode usar Homebrew e instalar a ferramenta carthage em seu sistema simplesmente executando brew update e brew install carthage. (nota: se você instalou anteriormente a versão binária de Carthage, você deve apagar /Library/Frameworks/CarthageKit.framework).

• MacPorts: Você pode usar o MacPorts e instalar a ferramenta carthage no seu sistema simplesmente executando sudo port selfupdate e sudo port install carthage. (nota: se você instalou anteriormente a versão binária de Carthage, você deve excluir /Library/Frameworks/CarthageKit.framework).

• Do código fonte: Se você gostaria de executar a última versão de desenvolvimento (que pode ser altamente instável ou incompatível), simplesmente clone o ramo master do repositório, então execute make install. Requer Xcode 10.0 (Swift 4.2).

Adicionando frameworks a uma aplicação

Após você ter Carthage instalado, você pode começar a adicionar frameworks ao seu projeto. Note que Carthage suporta somente frameworks dinâmicos, que só estão disponíveis no iOS 8 ou posterior (ou qualquer versão do OS X).

>

Começando

Construir frameworks XCFrameworks independentes de plataforma (Xcode 12 e superior)

1. Criar um Cartfile que lista os frameworks que você gostaria de usar no seu projeto.
2. Executar carthage update --use-xcframeworks. Isto irá buscar dependências em uma pasta Carthage/Checkouts e construir cada uma ou baixar um XCFramework pré-compilado.
3. Na guia Configurações Gerais da sua aplicação, na seção Frameworks, Bibliotecas e Conteúdo Embutido, arraste e solte cada XCFramework que você deseja utilizar da pasta Carthage/Build no disco.

Migrando um projeto de pacotes de framework para XCFrameworks

Abriamos o uso do XCFrameworks a partir da versão 0.37.0 (janeiro de 2021), e exigimos o XCFrameworks ao construir em um Apple Silicon Mac. Mudar de pacotes de framework discretos para XCFrameworks requer algumas alterações no seu projeto:

Passos de migração

1. Eliminar sua pasta Carthage/Build para remover qualquer pacote de framework existente.
2. Build novo XCFrameworks executando carthage build --use-xcframeworks. Qualquer outro argumento que você construir com pode ser fornecido como normal.
3. Remover referências aos frameworks antigos em cada um dos seus targets:
   • Eliminar referências aos frameworks de Carthage da seção Frameworks, Libraries, e Embedded Content do target e/ou sua seção Link Binary with Libraries build phase.
   • Eliminar referências aos frameworks de Carthage de qualquer fase de construção de Copy Files.
   • Eliminar as fases de construção dos targets carthage copy-frameworks build phase, se presentes.
4. Adicionar referências ao XCFrameworks em cada um dos seus alvos:
   • Para um alvo da aplicação: Na aba General settings, na seção Frameworks, Libraries, and Embedded Content, arraste e solte cada XCFramework que você usa da pasta Carthage/Build no disco.
   • Para um alvo de framework: Na guia Fases de construção, em uma fase Link Binário com bibliotecas, arraste e solte cada XCFramework que você utiliza da pasta Carthage/Build no disco.

Construindo pacotes de framework específicos da plataforma (padrão para Xcode 11 e abaixo)

Incompatibilidade do Xcode 12+: As plataformas multi-arquitetura não são suportadas na construção de pacotes de estruturas no Xcode 12 e superiores. Prefira construir com o XCFrameworks. Se você precisa construir pacotes de frameworks discretos, use um arquivo xcconfig em volta.

Se você está construindo para macOS

instruções específicas para macOS

1. Crie um arquivo Cartfile que lista os frameworks que você gostaria de usar no seu projeto.
2. Executar carthage update --platform macOS. Isto irá buscar dependências em uma pasta Carthage/Checkouts e construir cada uma ou baixar um framework pré-compilado.
3. Na aba General settings do seu aplicativo, na seção Embedded Binaries, arraste e solte cada framework que você deseja usar da pasta Carthage/Build no disco.

Adicionalmente, você precisará copiar símbolos de debug para depuração e relatórios de crash no OS X.

1. Na guia Configurações das Fases de Construção do seu aplicativo, clique no ícone + e escolha New Copy Files Phase.
2. Clique no menu suspenso Destino e selecione Products Directory.
3. Para cada framework que você estiver usando, arraste e solte seu arquivo dSYM correspondente.

Se você está construindo para iOS, tvOS, ou watchOS

Instruções específicas da plataforma

1. Criar um arquivo Cart que lista os frameworks que você gostaria de usar em seu projeto.

2. Executar carthage update. Isto irá buscar dependências em uma pasta Carthage/Checkouts, então construa cada uma ou baixe um framework pré-compilado.

3. Abra a aba General settings da sua aplicação targets. Para Xcode 11.0 e superior, na seção “Frameworks, Bibliotecas e Conteúdo Embutido”, arraste e solte cada framework que você deseja usar da pasta Carthage/Build no disco. Depois, na seção “Embed”, selecione “Não Embedar” no menu suspenso para cada item adicionado. Para Xcode 10.x e inferior, na seção “Linked Frameworks and Libraries”, arraste e solte cada framework que você deseja usar da pasta Carthage/Build no disco.

4. Na aba Build Phases settings da sua aplicação, clique no ícone + e escolha New Run Script Phase. Crie um Run Script no qual você especifica a sua shell (ex: /bin/sh), adicione o seguinte conteúdo à área de script abaixo da shell:

   /usr/local/bin/carthage copy-frameworks

5. Crie um arquivo chamado input.xcfilelist e um arquivo chamado output.xcfilelist

6. Adicione os caminhos para os frameworks que você deseja usar ao seu input.xcfilelist. Por exemplo:

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

7. Adicionar os caminhos para os frameworks copiados para o arquivo output.xcfilelist. Por exemplo:

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

   Com ficheiros de saída especificados ao lado dos ficheiros de entrada, o Xcode só precisa de correr o script quando os ficheiros de entrada tiverem mudado ou quando faltarem os ficheiros de saída. Isto significa que compilações sujas serão mais rápidas quando você não tiver reconstruído frameworks com Carthage.

8. Adicionar o input.xcfilelist à seção “Listas de Arquivos de Entrada” da fase de Carthage run script

9. Adicionar o output.xcfilelist à seção “Listas de Arquivos de Saída” da fase de Carthage run script

Este script funciona em torno de um bug de submissão da App Store acionado por binários universais e garante que os arquivos e dSYMs relacionados com bitcode necessários sejam copiados ao arquivar.

Com a informação de depuração copiada para o diretório de produtos construídos, o Xcode será capaz de simbolizar o stack trace sempre que você parar em um ponto de parada. Isto também permitirá que você passe pelo código de terceiros no debugger.

Ao arquivar sua aplicação para submissão à App Store ou TestFlight, o Xcode também copiará esses arquivos para o subdiretório dSYMs da sua aplicação .xcarchive bundle.

Para todas as plataformas

Durante o caminho, Carthage terá criado alguns artefatos de compilação. O mais importante deles é o arquivo Cartfile.resolved, que lista as versões que foram realmente construídas para cada framework. Certifique-se de submeter o seu Cartfile.resolved, porque qualquer pessoa usando o projeto vai precisar desse arquivo para construir as mesmas versões do framework.

(Opcionalmente) Adicionar fase de construção para avisar sobre dependências desatualizadas

Você pode adicionar uma fase Run Script para avisá-lo automaticamente quando uma de suas dependências estiver desatualizada.

1. Na aba ‘targets’ de sua aplicação’ Build Phases, clique no ícone + e escolha New Run Script Phase. Crie um Run Script no qual você especifica sua shell (ex: /bin/sh), adicione o seguinte conteúdo à área de script abaixo da shell:

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

Compatibilidade de download de frameworks binários Swift

Carthage irá verificar se os frameworks Swift baixados (e os frameworks mistos Objective-C/Swift) foram construídos com a mesma versão do Swift que está em uso localmente. Se houver um descasamento de versão, Carthage irá proceder para construir o framework a partir do código-fonte. Se o framework não puder ser construído a partir do código fonte, Carthage irá falhar.

Porque Carthage usa a saída de xcrun swift --version para determinar a versão Swift local, certifique-se de executar os comandos Carthage com a cadeia de ferramentas Swift que você pretende usar. Para muitos casos de uso, nada adicional é necessário. Entretanto, por exemplo, se você está construindo um projeto Swift 2.3 usando o Xcode 8.x, uma abordagem para especificar seu padrão swift para carthage bootstrap é usar o seguinte comando:

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

Executando um projeto que usa Carthage

Após você ter terminado os passos acima e empurrado suas alterações, outros usuários do projeto só precisam buscar o repositório e executar carthage bootstrap para começar com os frameworks que você adicionou.

Adicionando frameworks a testes unitários ou um framework

Usar Carthage para as dependências de qualquer alvo arbitrário é bastante similar a usar Carthage para uma aplicação. A principal diferença está em como os frameworks são realmente configurados e ligados no Xcode.

Porque os alvos dos testes unitários estão faltando na seção Linked Frameworks and Libraries em sua guia General settings, você deve, em vez disso, arrastar os frameworks construídos para a fase de construção Link Binaries With Libraries.

No alvo Teste na guia Configurações de compilação, adicione @loader_path/Frameworks aos Caminhos de pesquisa do caminho de execução se ele ainda não estiver presente.

Em casos raros, você também pode querer copiar cada dependência para o produto de compilação (por exemplo para incorporar as dependências dentro da estrutura externa, ou certificar-se de que as dependências estão presentes em um pacote de teste). Para fazer isso, crie uma nova fase de construção de arquivos de cópia com o destino do Frameworks, e então adicione a referência do framework também. Você não deve usar o comando carthage copy-frameworks uma vez que os pacotes de teste não precisam de frameworks removidos, e rodar instâncias simultâneas de copy-frameworks (com builds paralelos ativados) não é suportado.

Atualizando frameworks

Se você modificou seu Cartfile, ou deseja atualizar para as versões mais recentes de cada framework (sujeito aos requisitos especificados), simplesmente execute o comando carthage update novamente.

Se você quiser atualizar apenas uma, ou dependências específicas, passe-as como uma lista separada por espaço para o comando update. ex.

carthage update Box

ou

carthage update Box Result

Resolver Experimental

Uma reescrita da lógica de atualização de frameworks foi feita com o objetivo de aumentar a velocidade e reduzir o uso de memória. Atualmente é uma funcionalidade opt-in. Ele pode ser usado passando --new-resolver para o comando update, por exemplo,

carthage update --new-resolver Box

Se você estiver enfrentando problemas de desempenho durante as atualizações, por favor, dê ao novo resolvedor uma tentativa

Dependências aninhadas

Se o framework que você deseja adicionar ao seu projeto tiver dependências explicitamente listadas em um Cartfile, Carthage irá recuperá-las automaticamente para você. Você terá então que arrastá-las você mesmo para seu projeto a partir da pasta Carthage/Build.

Se o framework incorporado em seu projeto tiver dependências para outros frameworks, você deve vinculá-las ao alvo do aplicativo (mesmo que o alvo do aplicativo não tenha dependência daquele framework e nunca o utilize).

Usando submódulos para dependências

Por padrão, Carthage irá verificar diretamente os arquivos fonte das dependências em sua pasta do projeto, deixando você para submetê-los ou ignorá-los como você escolher. Se você gostaria de ter dependências disponíveis como submódulos Git (talvez assim você possa submeter e empurrar as mudanças dentro deles), você pode executar carthage update ou carthage checkout com a bandeira --use-submodules.

Quando executado desta forma, Carthage irá escrever nos arquivos .gitmodules e .git/config do seu repositório, e automaticamente atualizar os submódulos quando as versões das dependências mudarem.

Reconstruir dependências automaticamente

Se você quiser trabalhar em suas dependências durante o desenvolvimento, e quiser que elas sejam reconstruídas automaticamente quando você construir seu projeto pai, você pode adicionar uma fase de construção de Run Script que invoque Carthage assim:

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

Note que você deve estar usando submódulos antes de fazer isso, porque os checkouts simples não devem ser modificados diretamente.

Caching builds

Por padrão Carthage irá reconstruir uma dependência, independentemente de ser a mesma versão resolvida como antes. Passar o --cache-builds fará com que Cartago evite reconstruir uma dependência se ela puder. Veja as informações nos arquivos de versão para detalhes sobre como Carthage executa este cache.

Nota: Neste momento --cache-builds é incompatível com --use-submodules. O uso de ambos resultará na cópia de trabalho e alterações comprometidas na sua dependência do submódulo não sendo corretamente reconstruída. Veja #1785 para detalhes.

Bash/Zsh/Fish completion

Auto conclusão dos comandos e opções de Carthage estão disponíveis como documentado em Bash/Zsh/Fish Completion.

Suportando Carthage para sua estrutura

Carthage suporta oficialmente apenas estruturas dinâmicas. Os frameworks dinâmicos podem ser usados em qualquer versão do OS X, mas apenas no iOS 8 ou posterior. Adicionalmente, desde a versão 0.30.0 Carthage suporta frameworks estáticos.

Porque Carthage não tem uma lista de pacotes centralizada, e nenhum formato de especificação de projeto, a maioria dos frameworks deve construir automaticamente.

Os requisitos específicos de qualquer projeto de framework estão listados abaixo.

Compartilhe seus esquemas Xcode

Carthage irá construir somente esquemas Xcode que são compartilhados a partir do seu .xcodeproj. Você pode ver se todos os esquemas que você pretende construir com sucesso executando carthage build --no-skip-current, então verifique a pasta Carthage/Build.

Se um esquema importante não for construído quando você executar esse comando, abra o Xcode e certifique-se de que o esquema está marcado como Shared, para que Carthage possa descobri-lo.

Resolver falhas de compilação

Se você encontrar falhas de compilação em carthage build --no-skip-current, tente executar xcodebuild -scheme SCHEME -workspace WORKSPACE build ou xcodebuild -scheme SCHEME -project PROJECT build (com os valores reais) e veja se a mesma falha ocorre lá. Isso deve render informações suficientes para resolver o problema.

Se você tiver várias versões das ferramentas de desenvolvimento Apple instaladas (um Xcode beta, por exemplo), use xcode-select para alterar qual versão Carthage usa.

Se você ainda não for capaz de construir seu framework com Carthage, por favor abra um problema e ficaremos felizes em ajudar!

Tag stable releases

Carthage determina quais versões do seu framework estão disponíveis, pesquisando através das tags publicadas no repositório, e tentando interpretar cada nome de tag como uma versão semântica. Por exemplo, na tag v1.2, a versão semântica é 1.2.0.

Tags sem qualquer número de versão, ou com quaisquer caracteres seguindo o número da versão (por exemplo, 1.2-alpha-1) não são atualmente suportados, e serão ignorados.

Arquive frameworks pré-construídos em um arquivo zip

Carthage pode automaticamente usar frameworks pré-construídos, ao invés de construir do zero, se eles estiverem anexados a uma versão GitHub no repositório do seu projeto ou através de um arquivo de definição binário do projeto.

Para oferecer frameworks pré-construídos para uma tag específica, os binários para todas as plataformas suportadas devem ser zipados juntos em um arquivo, e esse arquivo deve ser anexado a uma release publicada correspondente a essa tag. O anexo deve incluir .framework em seu nome (por exemplo, ReactiveCocoa.framework.zip), para indicar a Carthage que ele contém binários. A estrutura do diretório do arquivo é de forma livre mas, frameworks devem aparecer apenas uma vez no arquivo, pois eles serão copiados para Carthage/Build/<platform> baseado em seu nome (por exemplo, ReactiveCocoa.framework).

Você pode realizar a operação de arquivamento com a própria carthage usando:

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

ou alternativamente

carthage build --archive

Draft Releases serão automaticamente ignorados, mesmo que eles correspondam à tag desejada.

Use travis-ci para carregar seus frameworks pré-construídos com tags

É possível usar travis-ci para construir e carregar seus releases com tags.

1. Instale travis CLI com gem install travis

2. Configure travis-ci para o seu repositório (Passos 1 e 2)

3. Criar .travis.yml arquivo na raiz do seu repositório baseado nesse template. Defina FRAMEWORK_NAME para o valor correto.

   Substitua PROJECT_PLACEHOLDER e SCHEME_PLACEHOLDER

   Se você estiver usando um espaço de trabalho ao invés de um projeto remova a linha xcode_project e descomente a linha xcode_workspace.

   O projeto deve estar no formato: MyProject.xcodeproj

   O espaço de trabalho deve estar no formato: MyProject.xcodeproj

   O espaço de trabalho deve estar no formato MyWorkspace.xcworkspace

   Feel free para atualizar o valor xcode_sdk para outro SDK, note que testes no SDK iphoneos exigiriam que você fizesse o upload de uma identidade de assinatura de código

   Para mais informações você pode visitar travis docs para projetos objective-c

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

4. Run travis setup releases, siga a documentação aqui

   Este comando codificará suas credenciais do GitHub no arquivo .travis.yml a fim de deixar o travis fazer o upload do release para o GitHub.com Quando solicitado para o arquivo carregar, digite $FRAMEWORK_NAME.framework.zip

5. Atualize a seção deploy para rodar em tags:

   In .travis.yml locate:

   on: repo: repo/repo

   E adicione tags: true e skip_cleanup: true:

   >

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

   Isso permitirá ao travis saber como criar uma implantação quando uma nova tag é empurrada e evitará que o travis limpe o arquivo zip gerado

   Construa frameworks estáticos para acelerar o tempo de lançamento da sua aplicação

   Se você incorporar muitos frameworks dinâmicos na sua aplicação, o tempo de lançamento antes da primeira inicialização pode ser bastante lento. Carthage é capaz de ajudar a mitigar isso, construindo seus frameworks dinâmicos como frameworks estáticos. Os frameworks estáticos podem ser ligados diretamente em sua aplicação ou fundidos em um framework dinâmico maior com algumas modificações simples no seu fluxo de trabalho, o que pode resultar em reduções dramáticas nos tempos de lançamento pré-manutenção.

   Carthage 0.30.0 ou superior

   Desde a versão 0.30.0, o projeto Carthage implementa suporte para frameworks estaticamente ligados escritos em Swift ou Objective-C, suporte para o qual foi introduzido no Xcode 9.4. Por favor, note que ele diz especificamente frameworks, daí que Darwin empacota com extensão .framework e arquivos de objetos ligados estaticamente dentro. Carthage não suporta atualmente esquemas de bibliotecas estáticas, nem há planos para introduzir seu suporte no futuro.

   O fluxo de trabalho difere apenas:

   • Você ainda precisa marcar os esquemas do seu projeto compatível com Carthage como compartilhado no Produto > Esquema > Gerenciar Esquemas…, assim como com binários dinâmicos
   • Você ainda precisa fazer um link contra esquemas estáticos .nas Fases de Construção do seu projeto, assim como com binários dinâmicos

   No entanto:

   • Na seção de Configurações de Construção do seu projeto em conformidade com Carthage-Coa Framework, Linkking, defina o tipo de Mach-O para Static Library
   • Os seus frameworks estaticamente ligados serão construídos em ./Carthage/Build/$(PLATFORM_NAME)/Static
   • Você não deve adicionar nenhum dos frameworks estáticos como arquivos de entrada/saída na fase de construção de frameworks estáticos em carthage

   Carthage 0.29.0 ou inferior

   Veja o documento StaticFrameworks para detalhes.

   Por favor note que algumas advertências se aplicam a esta abordagem:

   • As frameworks estáticas não são oficialmente suportadas pela Apple
   • Este é um fluxo de trabalho avançado que não está integrado em Carthage, YMMV

   Declare sua compatibilidade

   Deseja anunciar que seu projeto pode ser usado com Carthage? Você pode adicionar um crachá de compatibilidade:

   

   … ao seu README, simplesmente inserindo o seguinte Markdown:

   >

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

   Problemas conhecidos

   Problema do símbolo DWARFs

   Framework pré-construído não pode ser depurado usando a execução de passos em outra máquina que não aquela em que o framework foi construído. Simplesmente carthage bootstrap/build/update --no-use-binaries deve corrigir isso, mas para uma solução mais automatizada, veja #924. Dupe rdar://23551273 se você quiser que a Apple corrija a causa raiz deste problema.

   CarthageKit

   A maior parte da funcionalidade da ferramenta de linha de comando carthage está na verdade encapsulada em um framework chamado CarthageKit.

   Se você estiver interessado em usar Carthage como parte de outra ferramenta, ou talvez ampliar a funcionalidade de Carthage, dê uma olhada no código fonte do CarthageKit para ver se a API atende às suas necessidades.

   Diferenças entre Carthage e CocoaPods

   CocoaPods é um gerenciador de dependência de longa data para Cocoa. Então porque foi criado Carthage?

   Primeiro, CocoaPods (por padrão) cria e atualiza automaticamente um espaço de trabalho Xcode para a sua aplicação e todas as dependências. Carthage constrói binários de framework usando xcodebuild, mas deixa a responsabilidade de integrá-los para o usuário. A abordagem de CocoaPods é mais fácil de usar, enquanto a de Carthage é flexível e pouco intrusiva.

   O objetivo de CocoaPods é listado no seu README como segue:

   … para melhorar a capacidade de descoberta e engajamento em bibliotecas de código aberto de terceiros, criando um ecossistema mais centralizado.

   Por outro lado, Carthage foi criado como um gerenciador de dependências descentralizado. Não há uma lista central de projetos, o que reduz o trabalho de manutenção e evita qualquer ponto central de falha. Entretanto, a descoberta do projeto é mais difícil – os usuários devem recorrer às páginas de tendências do GitHub ou similares.

   CocoaPods projetos também devem ter o que é conhecido como um arquivo podspec, que inclui metadados sobre o projeto e especifica como ele deve ser construído. Carthage usa xcodebuild para construir dependências, em vez de integrá-las em um único espaço de trabalho, ele não tem um arquivo de especificação similar, mas suas dependências devem incluir seu próprio projeto Xcode que descreve como construir seus produtos.

   Ultimamente, criamos Carthage porque queríamos a ferramenta mais simples possível – um gerenciador de dependências que conseguisse fazer o trabalho sem assumir a responsabilidade do Xcode, e sem criar trabalho extra para os autores do framework. CocoaPods oferece muitos recursos incríveis que Carthage nunca terá, às custas de complexidade adicional.

   Licença

   Carthage é lançado sob a licença MIT.

   Foto de fundo de cabeçalho é lançado sob a licença CC BY-NC-SA 2.0. Foto original de Richard Mortel.