O que vai para o seu .gitignore se você estiver usando o CocoaPods?

https://stackoverflow.com/questions/9446644

12-11-2019
|

Pergunta

Eu tenho feito o desenvolvimento do iOS para um par de meses e só soube da promissor CocoaPods biblioteca para gerenciamento de dependência.

Eu tentei sair em um projeto pessoal:adicionado uma dependência para Kiwi a minha Podfile, correu pod install CocoaPodsTest.xcodeproj, e voila, ele trabalhou muito.

A única coisa que eu fico pensando é:o que deveria fazer o check in, e o que me ignorar para o controle de versão?Parece óbvio que eu quero, verifique a Podfile a si mesmo, e, provavelmente, o .xcworkspace arquivo;mas posso ignorar as Vagens/ directory?Existem outros arquivos que serão gerados na estrada (quando eu adicionar outras dependências) que eu deveria também adicionar aos meus .gitignore?

Solução

Pessoalmente, eu não, verifique a Vagem de diretório e conteúdo.Eu não posso dizer que eu gasto muito tempo a analisar as implicações, mas o meu raciocínio é algo como:

O Podfile refere-se a uma marca específica ou ou confirmação de cada dependência, de modo que as Vagens se pode ser gerado a partir de podfile, ergo eles são mais como um intermediário construir o produto de uma fonte e, daqui, não precisa de controle de versão no meu projeto.

Outras dicas

Eu entrego minha Vagens de diretório.Eu não concordo que as Vagens de diretório é uma compilação artefacto.Na verdade, eu diria que é mais, definitivamente, não é.É parte de seu aplicativo de origem:ele não vai construir sem ele!

É mais fácil pensar em CocoaPods como uma ferramenta de desenvolvimento, ao invés de incluir uma ferramenta de compilação.Ele não construir o seu projeto, ele simplesmente clones e instala as dependências para você.Não deve ser necessário ter CocoaPods instalado para ser capaz de simplesmente construir o seu projeto.

Fazendo CocoaPods uma dependência de compilação, agora, você precisa se certificar de que é disponível em todos os lugares, talvez você precise criar seu projeto...uma equipe de administração precisa, em sua CI servidor precisa.Você deve, como regra, ser sempre capaz de clonar o repositório de código-fonte e criar sem qualquer esforço adicional.

Não se comprometendo sua Vagens directory também cria uma enorme dor de cabeça se você frequentemente mudar ramos.Agora você precisa para executar pod instalar toda vez que você mudar ramos para certificar-se de suas dependências estão corretas.Isso pode ser menos incômodo como suas dependências estabilizar, mas no início de um projeto, este é um enorme desperdício de tempo.

Então, o que eu ignoro?Nada.Podfile, o bloqueio de arquivo e as Vagens de diretório de todos se comprometeram.Confie em mim, ele irá poupar-lhe um monte de problemas.Quais são os contras?Um pouco maior repo?Não é o fim do mundo.

Eu recomendo usar o O GitHub do objective-C gitignore.Em detalhe, as melhores práticas são:

O Podfile deve sempre estar sob controle de origem.
O Podfile.lock deve sempre estar sob controle de origem.
O espaço de trabalho gerados por CocoaPods deve ser mantidos sob controle de origem.
Qualquer Pod referenciado com o :path opção deve ser mantidos sob controle de origem.
O ./Pods pasta pode ser mantidos sob controle de origem.

Para mais informações você pode consultar o guia oficial.

fonte:Eu sou um membro do CocoaPods equipe principal, como o @liga

Embora as Vagens pasta é construir um artefato há razões que você pode considerar ao decidir o tempo para mantê-lo sob controle de origem:

CocoaPods não é um gerenciador de pacotes para a fonte original da biblioteca pode ser removido em futuras pelo autor.
Se as Vagens pasta está incluído no controle de origem, não é necessário instalar o CocoaPods para executar o projeto, como o checkout seria suficiente.
CocoaPods é ainda um trabalho em andamento e há opções que nem sempre levam ao mesmo resultado (por exemplo, o :head e o :git opções actualmente não estão a utilizar a compromete-se armazenados no Podfile.lock).
Há menos pontos de falha, se você pode continuar a trabalhar em um projeto depois de médio/longo período de tempo.

.gitignore arquivo

Sem resposta na verdade, dispõe de uma .gitignore, então , aqui estão dois sabores.

A verificação em Vagens de diretório (Benefícios)

Xcode/iOS amigável git ignorar, ignorar o Mac OS arquivos de sistema, Xcode, constrói, outros repositórios e backups.

.gitignore:

# Mac OS X Finder
.DS_Store

# Private Keys
*.pem

# Xcode legacy
*.mode1
*.mode1v3
*.mode2v3
*.perspective
*.perspectivev3
*.pbxuser

# Xcode
xcuserdata/
project.xcworkspace/
DerivedData/

# build products
build/
*.[oa]

# repositories
.hg
.svn
CVS

# automatic backup files
*~.nib
*.swp
*~
*(Autosaved).rtfd/
Backup[ ]of[ ]*.pages/
Backup[ ]of[ ]*.key/
Backup[ ]of[ ]*.numbers/

Ignorando as Vagens de diretório (Benefícios)

.gitignore: (anexar a lista anterior)

# Cocoapods
Pods/

Se ou não você verificar os Núcleos de diretório, o Podfile e Podfile.o bloqueio deve ser mantido sempre sob controle de versão.

Se Pods não são o check-in, a sua Podfile provavelmente deve pedido explícito números de versão para cada Cocoapod.Cocoapods.org discussão aqui.

Eu, geralmente, o trabalho no aplicativo de clientes.No caso eu adicione as Vagens para o diretório de recompra, bem como, para garantir que, em qualquer momento, qualquer desenvolvedor poderia fazer um check-out e criar e executar.

Se fosse um aplicativo nossa, eu provavelmente iria excluir as Vagens diretório até que eu não estar trabalhando nele por um tempo.

Na verdade, devo concluir, posso não ser a melhor pessoa para responder a sua pergunta, versus vistas de pura blog :) eu vou tweet sobre esta questão a partir de https://twitter.com/CocoaPodsOrg.

A resposta a isto é dado diretamente na Cocoapod docs.Você pode olhar "http://guides.cocoapods.org/using/using-cocoapods.html#should-i-ignore-the-pods-directory-in-source-control"

Se ou não você verifique no seu Vagens pasta é para você, como fluxos de trabalho variam de projeto para projeto.Recomendamos que você mantenha o Vagens de diretório sob controle de origem, e não adicioná-lo ao seu .gitignore.Mas, em última instância, essa decisão é sua:

Benefícios de verificar no diretório de Vagens

Depois de clonar o repositório, o projeto pode, de imediato, criar e executar, mesmo sem ter CocoaPods instalado na máquina.Não há precisa executar pod instalar, e sem conexão com a Internet é necessária.

O Pod de artefatos (código/bibliotecas) estão sempre disponíveis, mesmo se a origem de um Pod (e.g.O GitHub) ir para baixo.

O Pod artefatos são garantidos para ser idênticos aos originais de instalação depois de clonar o repositório.

Benefícios de ignorar as Vagens de diretório

O controlo de origem de recompra serão menores e ocupam menos espaço.

Enquanto as fontes (e.g.O GitHub) para todos os Pods estão disponíveis, CocoaPods é, geralmente, capaz de recriar a mesma instalação.(Tecnicamente não há nenhuma garantia de que a execução pod instalar vai buscar e recriar idênticos artefatos quando não estiver usando um commit SHA na Podfile.Isto é especialmente verdadeiro quando a utilização de arquivos zip no Podfile.)

Não haverá qualquer tipo de conflitos para lidar com quando efectuar operações de controlo de origem, como a fusão de ramos com diferentes Pod versões.

Se ou não você verificar os Núcleos de diretório, o Podfile e Podfile.o bloqueio deve ser mantido sempre sob controle de versão.

Eu seleção em tudo.(Pods/ e Podfile.lock.)

Eu quero ser capaz de clonar o repositório e saber que tudo estará simplesmente a funcionar como fez da última vez que eu usei o app.

Eu prefiro fornecedor de coisas em que o risco de ter diferentes resultados que podem ser causados por uma versão diferente da gema, ou alguém reescrever a história da Carcaça do repositório, etc.

Eu estou no campo de desenvolvedores que não se verifique em bibliotecas, supondo que temos uma boa cópia disponíveis em outro local.Então, na minha .gitignore eu inclua as seguintes linhas específicas para CocoaPods:

Pods/
#Podfile.lock  # changed my mind on Podfile.lock

Em seguida, certifique-se que temos uma cópia das bibliotecas em um local seguro.Em vez de (mal)uso de um projecto repositório de código para armazenar dependências (compilado ou não) eu acho que a melhor maneira para fazer isso é para configurações do arquivo.Se você usar um CI de servidor para a sua cria (como Jenkins) você pode permanentemente qualquer arquivo compilações que são importantes para você.Se você fizer toda a sua produção se baseia em seu local Xcode, criar o hábito de tomar um arquivo do seu projeto para qualquer compilações você precisa para manter.Algo como:1.Produto --> Arquivo

Distribuir...Enviar à App Store do iOS / Salvar para a Empresa ou Ad-hoc de Implantação / o que você tem
Revelar sua pasta de projeto no Finder
Clique com botão direito e Comprimir "WhateverProject"

Isso fornece uma imagem interna de todo o projeto, incluindo o projeto completo e configurações do espaço de trabalho usado para criar o aplicativo, bem como as distribuições binárias (tais como Brilho, de propriedade SDKs como TestFlight, etc.) se podem ou não usar CocoaPods.

Atualização: Eu mudei minha mente sobre isso e agora comete o Podfile.lock para controlo de origem.No entanto, eu ainda acredito que as vagens são, em si construir artefatos e devem ser gerenciados como tal fora do controlo de origem, através de outro método, como o CI server ou um processo de arquivamento, como eu descrevo acima.

Eu prefiro cometer Pods diretório junto com Podfile e Podfile.lock para certificar-se de que alguém da minha equipe pode fazer o checkout de origem a qualquer momento e eles não têm que se preocupar com nada ou fazer coisas adicionais para fazê-lo funcionar.

Isso também ajuda em um cenário onde você tem corrigido um bug dentro de uma das cabines ou modificados alguns comportamentos como por suas necessidades, mas essas alterações não estarão disponíveis em outros computadores, se não cometeu.

E para ignorar diretórios desnecessários:

xcuserdata/

Eu devo dizer que eu sou um fã de cometer Vagens para o repositório.Seguir um link em um já mencionado irá dar-lhe uma boa .gitignore arquivo para chegar até o seu Xcode projetos para iOS para permitir Vagens, mas também para que você possa excluí-los se assim o desejar: https://github.com/github/gitignore/blob/master/Objective-C.gitignore

Meu raciocínio para ser um fã de adição de Vagens para o repositório é para uma razão fundamental que ninguém parece estar pegando, o que acontece se uma biblioteca que nosso projeto é tão dependente de repente é removido da web?

Talvez o anfitrião decide que não quer mais manter o seu GitHub conta o Que acontece se a biblioteca é dizer de vários anos de idade (como idade superior a 5 anos por exemplo), há um alto risco a o projeto podem já não estar disponíveis na fonte
Também outro ponto, o que acontece se o URL para o repositório mudanças?Vamos dizer que a pessoa que o Pod do seu GitHub conta, decide representar-se sob um identificador diferente - suas Vagens são os URLs vai quebrar.
Finalmente, outro ponto.Dizem que se você for um desenvolvedor, como eu, que faz um monte de codificação, quando em um voo entre países.Eu faço um rápido puxão no o 'mestre' de ramo, de fazer um pod instalar no ramo, ao sentar-se no aeroporto e tenho tudo definido para as próximas 8 horas voo.Eu fico 3 horas para o meu vôo, e perceber que eu preciso mudar para outro ramo....'DÓ' - falta Pod informações que só está disponível no 'master' ramo.

NB...por favor, note que o 'mestre' ramo de desenvolvimento é apenas para exemplos, obviamente, 'mestre' ramos em sistemas de controle de versão, deve ser mantido limpo e destacáveis/edificável a qualquer momento

Eu acho que a partir destes, os instantâneos em seus repositórios de código são, certamente, melhor do que ser rigoroso no repositório de tamanho.E, como já mencionado, o podfile.arquivo de lock - enquanto a versão controlado vai lhe dar uma boa história de seu Pod versões.

No final do dia, se você tiver uma pressionar prazo, um orçamento apertado, o tempo é da essência - nós precisamos ser tão engenhoso quanto possível e não perca tempo em estrita ideologias, e, em vez disso, o chicote de um conjunto de ferramentas para trabalhar juntos para tornar a nossa vida mais fácil, mais eficiente.

No final é até você o que você fizer.

Isso é o que Cocoapods equipe pensa sobre isso:

Se ou não você verifique no seu Vagens pasta é para você, como fluxos de trabalho variam de projeto para projeto.Recomendamos que você mantenha o Vagens de diretório sob controle de origem, e não adicioná-lo ao seu .gitignore.Mas, em última instância, essa decisão é sua.

Pessoalmente, eu gostaria de manter Vagens fora, como node_modules se eu estivesse usando Nó ou bower_components se eu estivesse usando Bower.Isso se aplica para quase qualquer Dependência do Gestor lá fora, e é a filosofia por trás git submódulos também.

No entanto, há, por vezes, que você pode querer ter a certeza sobre o estado-da-arte de uma certa dependência, de que maneira você é levar a própria dependência dentro do seu projeto.De-é claro que existem várias desvantagens que se aplicam, se você faz isso, mas as preocupações não se aplicam apenas à Cocoapods, aqueles que se aplica a qualquer Dependência do Gestor de lá fora.

Abaixo há uma boa prós/contras lista feita pelo Cocoapods equipe, e o texto completo da citação mencionada anteriormente.

Cocoapods equipe:Devo verificar as Vagens de diretório no controle de origem?

Depende, pessoalmente:

Por vagens devem ser parte do acordo de recompra (sob controle de origem) e não deve ser ignorado

A fonte é idêntica
Você pode construí-lo imediatamente, como é (mesmo sem o cocoapods)
Mesmo se um pod é excluído, ainda temos a sua cópia (Sim, isso pode acontecer e ele fez.Em um projeto antigo, onde você quiser apenas uma pequena alteração seria necessário para implementar uma nova biblioteca para ser capaz de até mesmo criar).
pods.xcodeproj as configurações são parte do controle de origem do bem.Isto significa, por exemplo,se você tiver o projeto em swift 4, mas , algumas vagens devem ser em swift 3.2 porque eles não são atualizados ainda, essas configurações serão salvas.Caso contrário, o que clonado o repo iria acabar com os erros.
Você pode sempre excluir casca de projecto e de execução pod install, o oposto não pode ser feito.
Até mesmo a autores do Cocoapods recomendo.

Alguns contras:maior repositório, confuso difs (principalmente para os membros da equipe), potencialmente mais conflitos.

Para mim, a maior preocupação é com o futuro de verificação de sua origem.Se você pretende ter o seu projecto durar por um tempo e CocoaPods nunca vai embora ou a origem de uma das vagens vai para baixo, você está completamente fora da sorte se tentando construir fresco a partir de um arquivo.

Isso poderia ser atenuado com total periódica de origem archivals.

Verifique em Vagens.

Eu acho que isso deveria ser um princípio de desenvolvimento de software

Todas as versões devem ser reprodutíveis
A única maneira de garantir compilações são reproduzível é para estar no controle de todas as dependências;verificar em todos os dependências, portanto, é uma obrigação.
Um novo desenvolvedor começando do zero deve ser capaz de verificar o seu projeto e começar a trabalhar.

Por quê?

CocoaPods ou quaisquer outras bibliotecas externas podem alterar o que pode quebrar as coisas.Ou eles podem se mover ou mudar o nome, ou ser completamente removidos.Você não pode confiar na internet para armazenar as coisas para você.O seu computador portátil pode ter morrido e não é um bug crítico na produção que precisa ser corrigido.O principal desenvolvedor pode ser atropelado por um ônibus e sua substituição tem de iniciar em uma pressa.E desejo que a última foi um exemplo, mas realmente aconteceu em uma partida eu estava com.RIP.

Agora, de forma realista, você não pode realmente verificar em TODAS as dependências.Você não pode verificar na imagem de máquina que você usou para criar construções;você não pode verificar o número exato da versão do compilador.E assim por diante.Há realista limites.Mas verifique tudo o que você pode - e não fazer isso só torna a sua vida mais difícil.E nós não queremos isso.

Palavra Final:Vagens não são construir artefatos.Construir artefatos são o que é gerada a partir de suas construções.Sua construção utiliza Vagens, não gerá-los.Eu não sei mesmo por que isso tem que ser debatido.

Em teoria, você deve verificar no Vagens de diretório.Na prática, nem sempre vai funcionar.Muitas vagens bem exceder o limite de tamanho do sistema de arquivos, então se você estiver usando o github, você vai ter problemas de verificar em Vagens de diretório.

Prós não verificação de Pods/ para controle de versão (no subjetiva ordem de importância):

Muito mais fácil para mesclar compromete-se, e a revisão do código de diffs.A fusão é uma fonte comum de problemas em uma base de código, e isto permite-lhe concentrar-se apenas nas coisas que são pertinentes.
É impossível para qualquer contribuinte para editar as dependências próprias e verificar as alterações, que eles nunca devem fazer (e, novamente, seria difícil identificar se a comparação é enorme).Edição de dependências é muito má prática porque um futuro pod install pode ocluir a alterações.
As discrepâncias entre os Podfile e o Pods/ diretório de são encontrados mais rápido entre os membros da equipe.Se você verificar em Pods/ e, por exemplo, a atualização de uma versão no Podfile, mas se esqueça de executar o pod install ou check-in de alterações para Pods/, você vai ter um tempo muito mais difícil de perceber a origem da discrepância.Se Pods/ não é verificado, você sempre precisará executar pod install de qualquer maneira.
Menores de recompra de tamanho.Ter um menor de bytes pegada é bom, mas isso não importa muito no grande esquema.Mais importante ainda:ter mais coisas no repo também aumenta a carga cognitiva.Não há nenhuma razão para ter as coisas no repo que você não deveria estar olhando.Consulte a documentação do (a abstração) para saber como algo funciona, não em código (implementação).
Mais fácil de discernir quanto alguém contribui (desde suas linhas de código contribuiu não incluir dependências eles não escrever)
JAR arquivos, .venv/ (ambientes virtuais), e node_modules/ nunca estão incluídas no controle de versão.Se estivéssemos completamente agnóstico sobre a questão, não verificação de Pods seria o padrão com base no precedente.

Contras não a verificação em Pods/

Você deve executar pod install quando mudar de ramos, ou reverter compromete-se.
Você não pode executar um projeto só por clonar o repositório.Você deve instalar o pod ferramenta, em seguida, executar pod install.
Você deve ter uma conexão com a internet para executar pod install, e a origem das vagens deve estar disponível.
Se o proprietário de uma dependência remove um pacote, você está em apuros.

Em resumo, não incluindo o Pods diretório é um guardrail contra as más práticas. Incluindo o Pods diretório faz com que a execução do projeto mais fácil.Eu prefiro o antigo sobre o segundo.Você não precisa perguntar a cada nova pessoa em um projeto sobre "o que não para o fazer" se não houver a possibilidade de fazer certos erros em primeiro lugar.Eu também gosto da idéia de ter uma versão separada de controle para o Pods o que minimiza as Desvantagens.

Parece ser uma boa maneira de estruturar esse realmente seria ter os "Pods" diretório do git submodule / projeto separado, aqui está o porquê.

Tendo vagens em seu projeto de recompra, quando se trabalha com vários desenvolvedores, pode causar MUITO GRANDES diferenciais pull requests onde é quase impossível ver o trabalho real que foi alterado por pessoas (acho que várias centenas de milhares de arquivos alterados para as bibliotecas, e apenas alguns alterado no projeto real).
Eu vejo o problema de não cometer nada para o git, como a pessoa que possuir a biblioteca poderia derrubá-lo a qualquer momento, e você está, essencialmente, SOL, isso também resolve isso.

Se ou não você verifique no seu Vagens pasta é para você, como fluxos de trabalho variam de projeto para projeto.Recomendamos que você mantenha as Vagens diretório sob controle de origem, e não adicioná-lo ao seu .gitignore.Mas, em última instância, essa decisão é sua:

Benefícios de verificar no diretório de Vagens

Depois de clonar o repositório, o projeto pode, de imediato, criar e executar, mesmo sem ter CocoaPods instalado na máquina.Não há necessidade de executar pod instalar, e sem conexão com a Internet é necessária.
O Pod de artefatos (código/bibliotecas) estão sempre disponíveis, mesmo se a origem de um Pod (e.g.O GitHub) ir para baixo.
O Pod artefatos são garantidos para ser idênticos aos originais de instalação depois de clonar o repositório.

Benefícios de ignorar as Vagens de diretório

O controlo de origem de recompra serão menores e ocupam menos espaço.Enquanto as fontes (e.g.O GitHub) para todos os Pods estão disponíveis, CocoaPods é, geralmente, capaz de recriar a mesma instalação.(Tecnicamente não há nenhuma garantia de que a execução pod instalar o vai buscar e recriar idênticos artefatos quando não estiver usando um commit SHA na Podfile.Isto é especialmente verdadeiro quando a utilização de arquivos zip no Podfile.)
Não haverá qualquer tipo de conflitos para lidar com quando efectuar operações de controlo de origem, como a fusão de ramos com diferentes Pod versões.Se ou não você verificar os Núcleos de diretório, o Podfile e Podfile.o bloqueio deve ser mantido sempre sob controle de versão.

TL;DR:quando você controlar o Pods/ pasta, o projeto é mais fácil pick up a partir de.Quando você não controlar, é mais fácil melhorar quando você trabalha em equipe.

Embora o Cocoapods organização a incentivar-nos para controlar o Pods/ diretório, eles dizem que até os devs para decidir se quer ou não fazê-lo com base nestes prós e contras:http://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control

Pessoalmente, eu costumo acompanhar o Pods/ pasta apenas para projetos que eu não vou trabalhar mais um pouco.Dessa forma, qualquer desenvolvedor pode pegar rapidamente a partir dele e continuar o trabalho usando a versão correta do cocoapods.

Por outro lado, eu acho que a consolidar a história fica mais limpo e mais fácil de mesclar o código e revisão de outra pessoa de código quando você não está acompanhando a Pods/ a pasta.Eu costumo definir o cocoapod de versão da biblioteca de quando eu instalá-lo para se certificar de que qualquer pessoa pode instalar o projeto usando as mesmas versões I.

Além disso, quando o Pods/ diretório está sendo acompanhada de todos os devs tem que usar a mesma versão do Cocoapods para impedi-lo de alterar dezenas de arquivos a cada vez que executar pod install para adicionar/remover uma vagem.

Linha de fundo:quando você controlar o Pods/ pasta, o projeto é mais fácil de pegar.Quando você não controlar, é mais fácil para melhorar.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow