Ce qui se passe dans votre .gitignore si vous utilisez CocoaPods?

J'ai fait la de développement iOS pour un couple de mois maintenant et tout juste d'apprendre le prometteur CocoaPods bibliothèque pour la gestion de la dépendance.

Je l'ai essayé sur un projet personnel: ajout d'une dépendance à Kiwi à mon Podfile, couru pod install CocoaPodsTest.xcodeproj, et voila, il a travaillé beaucoup.

La seule chose que je me pose, c'est: que dois-je vérifier, et que dois-je ignorer pour le contrôle de version? Il semble évident que je veux vérifier dans le Podfile lui-même, et probablement la .xcworkspace fichier ainsi; mais puis-je ignorer les Gousses/répertoire? Existe-il d'autres fichiers qui seront générés en bas de la route (quand j'en ajouter d'autres dépendances) que je devrais aussi ajouter à mes .gitignore?

InformationsquelleAutor Dan Tao | 2012-02-25

257

Personnellement je n'ai pas de vérifier dans les Gousses annuaire & contenu. Je ne peux pas dire que j'ai passé de longs siècles de considérer les implications, mais mon raisonnement est quelque chose comme:

La Podfile se réfère à une balise spécifique ou de ou de validation de chaque dépendance si les Gousses eux-mêmes peuvent être générés à partir de la podfile, ergo, ils sont plus comme un intermédiaire, construire produit qu'une source et, par conséquent, n'a pas besoin de contrôle de version dans mon projet.
- Il pourrait être utile de mentionner que la CocoaPods projet ignore les Gousses dans le répertoire exemple.
- Donc, pourrait-on dire dans un projet standard contenant un Podfile (où nous utilisons git add -a) que nous devrions gitignore Podfile.lock & répertoire module ?
- Je voudrais envisager d'ajouter le Podfile.fichier de verrouillage, car alors vous enregistrer exactement quelles sont les versions de bibliothèques que vous avez utilisé pour un build spécifique, et peuvent se reproduire, c'est exactement pour les autres membres de l'équipe. Avoir à demander "quelle est la version de X utilisez-vous" peut être très ennuyeux. Voici une bonne discussion de l'ruby Gemfile équivalent: yehudakatz.com/2010/12/16/...
- Je ne comprends pas pourquoi vous auriez commettre le Podfile.de verrouillage, ne devriez-vous pas être plus précis dans votre Podfile au sujet de exactement ce que les versions dont vous dépendez? Ce que je ne suis pas à la compréhension?
- Voici comment je vois les choses: Si votre Podfile spécifie les versions exactes de chaque cosse alors la seule façon d'obtenir des mises à jour est de connaître l'existence de mises à jour et de les spécifier manuellement. Ce pourrait être préférée populaire de la critique ou de l'app. Pour un développement antérieur, les mises à jour importantes sont beaucoup plus faciles à trouver si vous venez de diff Podfile.verrouillage lorsqu'il est mis à jour et de décider ensuite si vous souhaitez que les mises à jour, dont vous n'avez probablement la plupart du temps.
- Je vois ce que tu veux dire, j'essayais juste de pod list outdated (comme vous le feriez dans MacPorts), pour voir qui de mon pod versions n'est pas la version actuellement disponible, mais cette fonctionnalité fonctionne différemment. Je pense que je m'attendais à un python pip style de l'installation, où il est l'une des exigences de fichier que l'outil de mises à jour pour vous sur demande, ce qui semble plus élégant que deux fichiers avec une syntaxe différente. Donc, avec Cocoapods, lorsque vous avez besoin de savoir exactement ce code est allé dans une de construire, valider les Podfile.verrouillage.
- Quel est le proj.xcworkspace fichier qui a été généré par pod install? Devrait-il être dans .gitignore trop?
- vous devriez certainement vérifier le projet .xcworkspace fichier, sinon, d'autres utilisateurs ont des problèmes à l'aide de l'installation de gousses.
- Il est important de mentionner Podfile.lock: il est appelé par Cocoapods comme recommandé d'être sous contrôle de version.
- si vous n'avez pas commettre les gousses qui ne sera pas un problème parce que vous auriez encore besoin d'appeler pod installer (ce qui génère le proj.xcworkspace)
- Il pourrait être également intéressant de mentionner les guide dans cocoapods a recommandé contre le fait d'ajouter les Gousses d'annuaire à l' .gitignore
- + commettre les gousses coups de vos dépôts inutilement!
- Le CocoaPods guides recommande contre le fait d'ajouter les Gousses d'annuaire à l' .gitignore fichier.
- Ils recommandent contre le fait d'ajouter les Gousses dir de .gitignore, mais encore une fois ils font un tas de trucs faux. Podfile.de verrouillage est changé en tout temps, vous ne gousse d'installer une version différente, ce qui conduit à les parasites des modifications de fichiers. Les gousses dir contient construire des artefacts. Ils peuvent être régénérées, et, par conséquent, n'ont pas à être dans le scm.
- Vous pourriez ne pas être en mesure de régénérer les Gousses dossier si par exemple l'auteur de toute bibliothèque supprime son dépôt sur github. Aussi, certaines personnes dans le passé mentionné des situations où les zip les fichiers liés dans le podfile ont été changé sur l'auteur du serveur et a cassé leur construire après la récolte des gousses de mise à jour et il y avait des problèmes avec les aller retour à l'ancienne version, il n'était pas disponible n'importe où. Lorsque vous garder les Gousses dossier sur les pensions de titres, vous êtes toujours en sécurité et vous pouvez être sûr que si vous essayez de construire votre projet dans l'avenir, après un an à partir de maintenant, alors il sera encore construire de la même manière comme il le fait maintenant.
- Quoi à ce sujet? guides.cocoapods.org/using/using-cocoapods.html dit que: Si oui ou non vous vérifier dans les Gousses de répertoire, le Podfile et Podfile.verrouillage doit toujours être gardé sous contrôle de version.
InformationsquelleAutor Matt Mower
368

Je remets mon Gousses d'annuaire. Je ne suis pas d'accord que les Gousses d'annuaire, un artefact. En fait, je dirais le plus n'est certainement pas. C'est une partie de la source de votre application: il ne sera pas construire sans elle!

Il est plus facile de penser à CocoaPods comme un outil de développement plutôt qu'un outil de construction. Il n'a pas à construire votre projet, il suffit simplement de clones et installe vos dépendances pour vous. Il ne devrait pas être nécessaire d'avoir CocoaPods installé pour être en mesure de simplement construire votre projet.

En faisant CocoaPods une dépendance de votre build, vous devez maintenant vous assurer qu'il est disponible partout où vous pourriez avoir besoin pour construire votre projet...une équipe d'admin besoins, votre serveur CI en a besoin. Vous pouvez, en règle générale, toujours être en mesure de cloner votre dépôt et de construire sans effort supplémentaire.

Pas commettre votre Gousses directory crée également un gros mal de tête si vous basculez souvent branches. Maintenant, vous devez exécuter la gousse d'installer chaque fois que vous changez branches assurez-vous que vos dépendances sont corrects. Cela peut être moins de tracas que vos dépendances stabiliser, mais au début d'un projet c'est un énorme puits de temps.

Alors, que dois-je l'ignorer? Rien. Podfile, le fichier de verrouillage et les Gousses répertoire de tous les obtenir commis. Croyez-moi, il va vous faire économiser beaucoup de tracas. Quels sont les inconvénients? Un légèrement plus grand repo? Pas la fin du monde.
- C'est certainement la façon d'utiliser CocoaPods. Non seulement est-il une partie de votre source parce que vous ne pouvez pas construire sans elle, mais votre "application de base" est aussi souvent très couplé à code dans CocoaPods. Très important pour la gestion des versions de savoir exactement quelle version d'un module est utilisé, et seulement à l'aide de fichier de verrouillage ne coupe pas.
- Plus facile lors de la commutation de la branche et lors du retour dans le temps... C'est un énorme argument.
- Oui, je pourrais avoir élaboré sur cette autre, mais pour moi, un commit dans votre pension représente un instantané de votre source dans le temps et si vous ne validez pas votre Gousses répertoire, une grande partie de la capture instantanée est manquant. Vous pouvez réduire ce en étant très précis de votre Pod versions, mais aussi envisager cette...si vous mettez à jour l'un de vos Gousses, si votre Gousses sont dans votre pension, alors que la mise à jour sera capturé dans un commit et sera entièrement diffable. Si la mise à jour d'un module d'un bug, on peut très facilement voir pourquoi le changement sous-jacent est capturé dans votre propre repo.
- Je pense que c'est clair, c'est une question de goût personnel maintenant. Des gens comme Seamus sont maintenant polariser le débat... c'est vraiment pas juste de dire que ne comprenant pas le Pods répertoire va vous causer de la douleur, lors de la vérification il en est également livré avec son propre ensemble de problèmes. par exemple, un développeur bosses une version d'une dépendance dans un Podfile sans se rappeler de vérifier dans la mise à jour des sources dans les Gousses. La loi de Murphy. pod install chaque fois que vous changez de branche coûts de précieux ... des DIZAINES de secondes, mais il élimine cette classe de problèmes tout à fait.
- Vous pouvez également étendre cet argument de l'état que vous devriez inclure dans votre version de compilateur et de versions de système d'exploitation ainsi que ceux-ci peuvent avoir une incidence sur votre construire.
- Que faites-vous avec votre intérieur cocoapods et privé fourches de public coccoapods? Avez-vous aussi de commettre leurs sources dans chaque projet qui les contient?
- Cet article semble assez pro, y compris les Gousses
- Je pense que cela devrait être un principe de base: développement de logiciel: Vos constructions doivent être reproductibles. Et un nouveau développeur de commencer à partir de zéro doit être en mesure de vérifier votre projet et de commencer à travailler. Leur première tâche devrait pas être à la chasse pour les différentes pièces et de morceaux vous avez laissé de côté. CocoaPods peut être retiré par les développeurs; ou ils se déplacent, ou des versions spécifiques sont supprimés. Que ce soit - c'est l'internet, les choses peuvent se produire. Gardez ce dont vous avez besoin pour construire dans le repo.
- Même si je suis d'accord que, en théorie, que les Gousses doivent être dans les pensions, dans la pratique, il provoque des maux de tête plus que de ne pas, surtout si vous devez souvent basculer branches. Dans de nombreux cas, vous serez à gauche avec des centaines de fichiers à valider simplement en changeant les branches parce que git ne gère pas la suppression de répertoires bien. En outre, vous êtes obligés de pod install de toute façon lors de la commutation de branches, de sorte qu'il semble inutile d'ajouter un tas de fichiers, vous devez recréer.
- C'est argument est, tout dépend du fait que le processus de construction, par exemple Xcode, ne se fait pas 'pod installer". Si elle n'était simplement qu'un serveur CI, ou une équipe d'admin sera tout simplement obtenir plus récentes et les construire et les Gousses de Cacao, ce serait déjà actualisé. La cabosse est de construire des artefacts, la seule raison que c'est une bonne pratique, afin de les inclure dans la source de contrôle est parce que les "gousses d'installer" n'est pas automatique partie de Xcode Construire. D'autres plates-formes ont élégamment résolu ce problème, par exemple, Visual Studio et Nuget, vous ne signez rien, sauf un paquet.config et toutes les versions d'obtenir les bibliothèques
- Comment gérez-vous les conflits de fusion entre les fichiers présents dans votre Pod dossier et d'autres pod fichiers associés?
- It won't build without it! Vous pourriez aussi bien s'engager XCode trop
- Tout le code de Gousses de dossier s'affiche dans la fusion demandes et fait faire la révision du code très difficile.
- Je recommande d'ajouter les Gousses d'annuaire sous contrôle de code source, mais toujours définir un ensemble de versions de bibliothèques dans Podfile (par exemple pod "Alamofire', '4.7.0") et seul les mettre à jour de temps à autre, de sorte que, par exemple, si quelqu'un de l'équipe de faire de la gousse de mise à jour puis les changements dans les Gousses sont minimes ou inexistants. Aussi garder à l'esprit que si vous ne commettez pas Gousses dossier et, par exemple, auteur de la bibliothèque supprime son repo (cocoapods ne contient que des liens vers de l'auteur repo) ou si github est arrêté, alors vous ne serez pas en mesure d'exécuter gousse d'installer et de construire votre projet.
- Comment s'engager de grandes podfiles? @LukeRedpath Puisque la limite est de seulement 100 mo sur github
- Bonnes opinions. En particulier le cas lorsque vous changez de branches très souvent. Peut-on en dire de même pour le répertoire node_modules pour le nœud apps?
InformationsquelleAutor Luke Redpath
151

Je recommande d'utiliser le GitHub de l'Objective-C gitignore.
Dans le détail, les meilleures pratiques sont les suivantes:
- La Podfile doit toujours être sous contrôle de code source.
- La Podfile.lock doit toujours être sous contrôle de code source.
- L'espace de travail généré par CocoaPods devrait être gardé sous contrôle de code source.
- Toute Pod référencé avec le :path option devrait être gardé sous contrôle de code source.
- La ./Pods dossier peut être gardé sous contrôle de code source.
Pour plus d'informations vous pouvez vous référer à la guide officiel.

source: je suis un membre de la CocoaPods équipe de base, comme @alliage

Bien que les Gousses dossier, un artefact, il ya des raisons que vous pourriez envisager de décider si pour le garder sous contrôle de code source:
- CocoaPods n'est pas un gestionnaire de paquet, afin de la source d'origine de la bibliothèque pourrait être supprimé à l'avenir par l'auteur.
- Si les Gousses dossier est inclus dans le contrôle de code source, il n'est pas nécessaire d'installer CocoaPods pour exécuter le projet que la caisse devrait suffire.
- CocoaPods est toujours en cours et il y a des options qui ne sont pas toujours d'aboutir au même résultat (par exemple la :head et la :git options ne sont pas actuellement à l'aide de la commet stockées dans le Podfile.lock).
- Il y a moins de points de défaillance si vous pouvez reprendre le travail sur un projet après un moyen/long laps de temps.
- Pourquoi s'ennuyer à conserver le fichier d'espace de travail? Elle est générée par Cocoapods de toute façon.
- Pour Cocoapods aveugle continue-l'intégration des serveurs de test, dans mon expérience. J'ai vérifier tout cela parce que je n'ai pas accès au script de build pour mon CI hôte (règle d'entreprise) et de traiter CocoaPods comme un outil de développement, et non pas un système de construction ou le gestionnaire de package.
- ./Pod dossier ne doit PAS être gardé sous contrôle de code source (il est généré automatiquement) par CocoaPods. Les gousses dossier est un artefact du processus de construction. L'espace de travail peut également être retiré de contrôle de code source, sauf s'il a d'autres projets ne sont pas gérés avec CocoaPods.
- Je pense qu'il doit être vérifié, car c'est une douleur pour faire une gousse d'installer chaque fois que je fais un pull.
InformationsquelleAutor Fabio
39

.gitignore fichier

Pas de réponse fait offre un .gitignore, donc, ici, sont deux saveurs.

Vérification dans les Gousses répertoire (Avantages)

Xcode/iOS friendly git d'ignorer, ignorer Mac fichiers du système d'exploitation, Xcode, construit, d'autres référentiels et des sauvegardes.

.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/
```
En ignorant les Gousses répertoire (Avantages)

.gitignore: (ajouter à la liste précédente)
```
# Cocoapods
Pods/
```
Si oui ou non vous vérifier dans les Gousses de répertoire, le Podfile et Podfile.verrouillage doit toujours être gardé sous contrôle de version.

Si Pods ne sont pas enregistrés, votre Podfile devrait probablement demande explicite des numéros de version pour chaque Cocoapod. Cocoapods.org discussion ici.

InformationsquelleAutor SwiftArchitect
38

Je travaille en général sur l'application de clients. Dans ce cas, j'ai ajouter les Gousses d'annuaire pour les pensions ainsi, pour s'assurer qu'à tout moment, n'importe quel développeur peut faire une extraction et de créer et d'exécuter des.

Si c'était une application de la nôtre, je serais probablement exclure les Gousses répertoire jusqu'à ce que je ne travaillez pas sur elle pendant un certain temps.

En fait, je dois conclure, je ne pourrais pas être la meilleure personne pour répondre à votre question, par rapport à des vues de pure utilisateurs 🙂 je vais tweet à propos de cette question de https://twitter.com/CocoaPodsOrg.
- J'avais l'écho de ce que bien. Vous pouvez utiliser CocoaPods sans vos autres développeurs qui ont besoin de l'utiliser (bien qu'ils devraient) en cochant dans les Gousses de dossier. Une fois CocoaPods devient omniprésent, les gousses seront semblables à des pierres précieuses, vous devriez vérifier dans le même cas que vous auriez du "vendeur" gems ruby.
- Je pense que l'une ont également considérer que, parfois, les gousses ou pod utilité(la bonne version) peuvent ne pas être disponibles. Encore plus, si deux utilisateurs avec différents pod version de l'utilitaire exécuter l'utilitaire pour exactement la même Podspec, le résultat peut différer.
- La caisse, de construire et d'exécuter est la considération la plus importante. Pourquoi voudriez-vous faire de votre construction, et la capacité de construire dépend de tous les facteurs externes? Je vérifie dans toutes les gousses. Vous pouvez enregistrer d'autres développeurs (ou votre soi futur) heures de recherche pour le bon gousses. Je ne vois pas d'inconvénients à la vérification, soit.
InformationsquelleAutor alloy
17

La réponse à cette question est donnée directement dans Cocoapod docs. Vous pouvez regarder les "http://guides.cocoapods.org/using/using-cocoapods.html#should-i-ignore-the-pods-directory-in-source-control"
Si oui ou non vous vérifiez dans votre Gousses dossier est à vous, en tant que
les flux de travail varie en fonction du projet. Nous vous recommandons de conserver les
Gousses de répertoire sous contrôle de code source, et de ne pas l'ajouter à votre
.gitignore. Mais, en définitive, cette décision est à vous:

Avantages de la vérification dans les Gousses répertoire
- Après cloner le repo, le projet peut immédiatement à construire et à exécuter, même sans avoir CocoaPods installé sur la machine. Il n'y a pas de
  besoin d'exécuter pod installer, et aucune connexion Internet n'est nécessaire.
- La Gousse d'artefacts (code/bibliothèques) sont toujours disponibles, même si la source d'un module (par exemple, GitHub) à la baisse.
- La Gousse d'artefacts sont garantis d'être identiques à ceux de l'installation d'origine après cloner le repo.
Avantages d'ignorer les Gousses répertoire
- De commande de la source repo sera plus petit et prendre moins de place.
- Tant que sources (par exemple, GitHub) pour toutes les Gousses sont disponibles, CocoaPods est généralement en mesure de recréer la même installation.
  (Techniquement, il n'y a aucune garantie que la course de pod installer va chercher
  et de le recréer à l'identique les artefacts lorsque vous n'utilisez pas un commit SHA dans la
  Podfile. Cela est particulièrement vrai lors de l'utilisation de fichiers zip dans le Podfile.)
- Il n'y aura pas de conflits à traiter lors de l'exécution de la source, les opérations de contrôle, telles que la fusion des branches à différentes Pod
  les versions.
Si oui ou non vous vérifier dans les Gousses de répertoire, le Podfile et
Podfile.verrouillage doit toujours être gardé sous contrôle de version.
InformationsquelleAutor shah1988
16

Je vérifie tout. (Pods/ et Podfile.lock.)

Je veux être en mesure de cloner le dépôt et de savoir que tout va juste travailler comme il l'a fait la dernière fois j'ai utilisé l'application.

Je préfère fournisseur de choses que le risque d'avoir des résultats différents qui pourraient être causés par une version différente de la gemme, ou quelqu'un de réécriture de l'histoire dans le module référentiel, etc.
- L'autre bonne chose à propos de le faire, c'est après une mise à jour, vous pouvez regarder le diff avant de vérifier et de voir exactement quels sont les fichiers dans les gousses changé.
- En outre, votre projet ne nécessite pas l'ensemble de vos développeurs ont CocoaPods installé (qui peut être une bonne chose si vous souhaitez contrôler qui/comment dépendances sont ajoutés et mis à jour).
InformationsquelleAutor funroll
12

Je suis dans le camp des développeurs qui ne vérifient pas dans les bibliothèques, en supposant que nous avons une bonne copie dans un autre emplacement. Donc, dans mon .gitignore-je inclure les lignes suivantes spécifiques à CocoaPods:
```
Pods/
#Podfile.lock  # changed my mind on Podfile.lock
```
Puis-je m'assurer que nous avons une copie de l'bibliothèques dans un endroit sûr. Plutôt que de (mal)utiliser un code du projet de référentiel pour stocker les dépendances (compilé ou non) je pense que la meilleure façon de le faire est d'archives des builds. Si vous utilisez un serveur CI pour vos constructions (tels que Jenkins), vous pouvez en permanence archiver toutes les versions qui sont importantes pour vous. Si vous faites tout votre production s'appuie dans vos locaux Xcode, prenez l'habitude de prendre une archive de votre projet pour la builds que vous devez garder. Quelque chose comme:
1. Produit --> Archive
1. Distribuer... Soumettre à l'App Store d'iOS /Enregistrer pour l'Entreprise ou au Déploiement Ad-hoc /qu'avez-vous
2. Révéler votre dossier de projet dans le Finder
3. Clic droit et Compresser "WhateverProject"
Cela fournit une mesure de l'image de l'ensemble du projet, y compris l'ensemble du projet et de l'espace de travail les paramètres utilisés pour construire l'application aussi bien que les distributions binaires (comme Éclat, propriétaire des Kits de développement logiciel comme TestFlight, etc.) qu'ils utilisent ou non CocoaPods.

Mise à jour: j'ai changé d'avis sur cela et maintenant commettre le Podfile.lock à la source de contrôle. Cependant, je persiste à croire que les gousses sont eux-mêmes de construire des artefacts et devraient être gérés comme tels en dehors du contrôle de code source, par une autre méthode telle que votre serveur CI ou d'un processus d'archivage comme je l'ai décrit ci-dessus.
- Cocoapods spécifiquement recommande de vérifier dans Podfile.lock: docs.cocoapods.org/guides/working_with_teams.html
- Intéressant. Depuis Podfile.lock cuit dans les chemins d'accès aux locaux des gousses, je n'avais pas envisagé d'ajouter à la version de contrôle. Cependant, maintenant que j'y pense, ce n'est pas différente de la locale les modifications que je fais dans Podfile mais ne jamais s'engager. Merci de souligner ce point.
- A que le travail avec les équipes de lien a changé? Il mentionne rien au sujet de la Podfile.lock fichier.
- Je pense que le nouveau lien est celui-ci
- L'avantage de vérifier dans Podfile.lock c'est qu'il est évident que si l'un de vos gousses ou de leurs dépendances ont été mis à niveau.
- Cocoapods recommandation: Ce fichier doit toujours être gardé sous contrôle de version. guides.cocoapods.org/using/using-cocoapods.html
- Je pense que vous avez fait une erreur en ne vérifiant pas dans les Gousses à l'annuaire, il y a un réel danger que les dépôts visés par votre Podfile/Podspecs seront déplacés ou supprimés. Si cela se produit, votre projet est inutile. Je dirais qu'ils ne sont pas de construire des artefacts: ils sont des composantes nécessaires de votre projet. Je préfère de tout vérifier (Podfile/Podfile.lock/Pods) dans le contrôle de version, ce qui a le bel effet de permettre à moi de passer en revue les modifications apportées par pod update avant de l'intégrer au projet, mais aussi des moyens de mon projet toujours compile (même sans CocoaPods).
- Je suis en train de changer mon esprit bien fait. Pour une raison ou une autre, mon pod de commande ne fonctionne pas parce que certains commande git est long et n'est pas terminer à temps. Pour tout ce temps que pod ne fonctionne pas, je suis coincé et ne peut même pas construire le projet. En commettant toutes les sources est une bonne idée car il n'a vraiment accélérer la commutation entre les branches.
- Le "danger réel" qui se réfèrent à des référentiels de disparaître est exactement pourquoi je vous recommande d'archivage de l'ensemble de la construire dans le cadre de votre processus de libération. Comme pour la vérification dans les Gousses de répertoire, je vois deux problèmes: 1. C'est vraiment pas pratique si vous utilisez souvent :chemin de consulter les versions de développement de l'intérieur CocoaPods. 2. Il pourrait inciter une personne à maintenir l'extrait de gousses de code directement dans le projet de code, plutôt que de ramification ou de bifurquer le pod repo comme ils le devraient. Cela pourrait être particulièrement sujettes à l'erreur si vous avez déjà maintenir fourchettes internes de repos public.
- Totalement en désaccord avec cela. Afin de comprendre le code et la correction de bugs, vous avez besoin de la totalité de la source, ou autant que possible. Vous voulez éliminer autant de variables que possible; d'avoir exactement le Pod version qui a été utilisé pour la construction est essentielle. Quant à votre argument contre (2): Si les développeurs de modifier les gousses (mauvais!), alors ce serait bien pire problème lorsque vous avez des pas vérifié dans le pod. Alors que le code pourrait juste être sur que les développeurs de la machine... bonne chance.
- Si vous êtes en s'appuyant sur GitHub (ou un autre VCS) pour l'ensemble de votre gestion de la dépendance, que faites-vous à propos de dépendances binaires tels que Crashlytics ou de l'Éclat? Et avez-vous aussi intérieur des gousses qui sont maintenant copiés dans chaque repo qui les utilise? Ce sujet de test spécifiques des régimes qui incluent les différentes dépendances spécifiques à des tests automatisés? Ce que je défends est qu'il y est une autre façon de gérer les dépendances, à l'extérieur de GitHub, dans votre processus de génération et/ou de votre système CI. Une fois que notre dépendance à l'égard de l'arbre a progressé modérément complexe, nous avons trouvé ceci pour être une meilleure option.
- Dépendances binaires, intérieur des gousses sont enregistrés pour la même raison. Un nouveau développeur doit être en mesure de vérifier et de faire construire. Que nouveau développeur peut-être vous-même quelques mois en bas de la route. Pour le test automatisé avec différents ensembles de dépendances, je voudrais vérifier dans les, trop? Il n'y a pas de mal. Aucune partie essentielle du projet peuvent être locaux sur l'un des développeurs de la machine. Et si vous êtes en utilisant un certain type de partage, git est aussi bon que n'importe quel (vs dropbox, votre serveur de build, peu importe).
InformationsquelleAutor Alex Nauda
11

Je préfère commettre Pods répertoire avec Podfile et Podfile.lock à assurez-vous que quelqu'un dans mon équipe peut l'extraction de la source à tout moment et ils n'ont pas à vous soucier de quoi que ce soit ou faire d'autres choses pour le faire fonctionner.

Cela aide aussi dans un scénario où vous avez correction d'un bug à l'intérieur des gousses ou modifié certains comportements en fonction de vos besoins, mais ces changements ne seront pas disponibles sur d'autres machines si pas commis.

Et à ignorer les répertoires inutiles:
```
xcuserdata/
```
InformationsquelleAutor nomann
10

Je dois dire que je suis un fan de commettre des Gousses dans le référentiel. À la suite d'un lien déjà mentionné, vous aurez un bon .gitignore fichier pour récupérer vos projets Xcode pour iOS pour permettre Gousses, mais aussi pour que vous puissiez exclure, si vous le souhaitez: https://github.com/github/gitignore/blob/master/Objective-C.gitignore

Mon raisonnement pour être un fan d'ajouter les Gousses dans le référentiel est pour une raison fondamentale qui personne ne semble se ramasser sur ce qui se passe si une bibliothèque de notre projet est donc dépendant de est soudainement retiré du web?
- Peut-être l'hôte décide de ne plus vouloir garder leur GitHub
  compte ouvert Ce qui se passe si la bibliothèque est à dire vieux de plusieurs années
  (comme plus de 5 ans par exemple) il y a un fort risque que les
  projet peuvent ne plus être disponibles à la source
- Aussi un autre point, qu'advient-il si l'URL du référentiel
  les changements? Permet de dire que la personne effectuant la Gousse de leur GitHub
  compte, décide de se représenter eux-mêmes sous un autre poignée
  votre Gousses Url allons briser.
- Enfin un autre point. Dire si vous êtes un développeur comme moi qui fait beaucoup
  de codage lors d'un vol entre les pays. Je fais un rapide tirez sur
  la branche "maître", faire une gousse d'installer sur cette branche, tout en restant assis
  dans l'aéroport, et moi-même tous ensemble pour les prochaines 8 heures
  vol. Je reçois 3 heures dans mon vol, et de réaliser j'ai besoin de passer à la
  une autre branche.... 'DO' - manque Gousse d'information qui est disponible uniquement sur la branche "maître".
NB... s'il vous plaît noter la branche "maître" pour le développement est juste pour des exemples, évidemment "maître" des branches dans les systèmes de contrôle de version, doit être gardé propre et déployable/constructible à tout moment

Je pense que à partir de ces clichés dans vos dépôts de code sont certainement mieux que d'être strict sur le référentiel de la taille. Et comme déjà mentionné, la podfile.verrouillage de fichier - alors que la version contrôlée vous donnera une bonne histoire de votre Pod versions.

À la fin de la journée, si vous avez une date limite appuyant sur un budget serré, le temps est de l'essence -, nous devons être aussi habile que possible et ne pas perdre de temps sur le strict idéologies, et, au lieu de tirer parti d'un ensemble d'outils pour travailler ensemble à rendre notre vie plus facile, plus efficace.
- C'est l'une des meilleures réponses à la "Dois-je vérifier mon dépendances au contrôle de code source" d'âge en question. Tout d'abord, vous expliquer un concrètes, fondées sur le risque, les entreprises justification de votre raisonnement. D'autre part, de rappeler à tous que, à la fin de la journée, la meilleure solution est tout ce qui fait le travail et amène les gens à travailler ensemble. Vous retirez la religion à partir de l'équation. Nice job!!!
InformationsquelleAutor leewilson86
8

À la fin, c'est à vous de l'approche que vous prenez.

C'est ce que Cocoapods équipe pense à ce sujet:

Si oui ou non vous vérifiez dans votre Gousses dossier est à vous, en tant que
les flux de travail varie en fonction du projet. Nous vous recommandons de conserver les
Gousses de répertoire sous contrôle de code source, et de ne pas l'ajouter à votre
.gitignore. Mais, en définitive, cette décision est à vous.

Personnellement j'aimerais garder Gousses, comme node_modules si je l'utiliser Nœud ou bower_components si je l'utiliser Bower. Cela s'applique pour presque n'importe quelle Dépendance Gestionnaire de là-bas, et c'est la philosophie derrière submodules aswell.

Cependant il y a parfois de ce que vous pourriez voulez être vraiment sûr de la l'état de l'art d'une certaine dépendance, de cette façon vous est propre la dépendance au sein de votre projet. Bien-sûr il y a plusieurs inconvénients qui s'appliquent si vous le faites, mais les préoccupations ne sont pas les seuls à Cocoapods, celles qui s'applique à toute Dépendance Gestionnaire de là-bas.

Ci-dessous il y a une bonne avantages/inconvénients liste faite par Cocoapods de l'équipe, et le texte intégral de la citation mentionnée précédemment.

Cocoapods équipe: dois-je vérifier les Gousses d'annuaire dans le contrôle de code source?

InformationsquelleAutor zevarito
7

Il dépend, personnellement:

Pourquoi les gousses doivent faire partie de l'opération (sous contrôle de code source) et ne doit pas être ignoré
- La source est identique
- Vous pouvez construire tout de suite comme c'est (même sans le cocoapods)
- Même si un module est supprimé, nous avons encore sa copie (Oui, cela peut arriver et il l'a fait. Dans un vieux projet où vous voulez juste un petit changement, vous devrez mettre en œuvre une nouvelle bibliothèque pour être en mesure de construire même).
- pods.xcodeproj paramètres font partie de la source de contrôle. Cela signifie par exemple que si vous avez le projet swift 4, mais quelques gousses doivent être en swift 3.2 parce qu'ils ne sont pas mis à jour encore, ces paramètres seront enregistrés. Sinon celui qui cloné le repo allait se retrouver avec des erreurs.
- Vous pouvez toujours supprimer les gousses de le projet et exécutez pod install, le contraire ne peut pas être fait.
- Même le auteurs de la Cocoapods recommander.
Certains inconvénients: les plus gros dépôt, confusion des diffs (principalement pour les membres de l'équipe), potentiellement plus de conflits.

InformationsquelleAutor Jakub Truhlář
2

Pour moi, la plus grande préoccupation est l'avenir de vérification linguistique de votre source. Si vous prévoyez d'avoir votre dernier projet pendant un certain temps et CocoaPods ne va jamais à l'écart ou de la source de l'un des gousses va vers le bas, vous êtes complètement hors de la chance si vous essayez de construire frais à partir d'une archive.

Cela pourrait être atténué avec l'périodique source complet archivals.

InformationsquelleAutor Shawn
2

Vérifier dans les Gousses.

Je pense que cela devrait être un principe de développement de logiciels
- Toutes les générations doivent être reproductibles
- La seule façon de s'assurer versions sont
  reproductible est d'être en contrôle de toutes les dépendances; la vérification dans tous les
  dépendances est donc un must.
- Un nouveau développeur de commencer à partir de zéro doit être en mesure de vérifier votre projet et de commencer à travailler.
Pourquoi?

CocoaPods ou toutes les autres bibliothèques externes peut changer, ce qui pourrait casser des choses. Ou ils pourraient se déplacer ou être renommé, ou être complètement éliminés. Vous ne pouvez pas compter sur internet pour stocker des choses pour vous. Votre ordinateur portable peut-être décédé et il y a un bug critique dans la production qui doit être corrigé. Le développeur principal pourrait se faire frapper par un autobus et son remplacement doit commencer à la hâte. Et je souhaite que ce dernier était un exemple théorique, mais il s'est réellement passé lors d'un démarrage, j'ai été avec. RIP.

Maintenant, de façon réaliste, vous ne pouvez pas vraiment vérifier dans TOUTES les dépendances. Vous ne pouvez pas vérifier dans une image de la machine que vous avez utilisé pour créer des versions, vous ne pouvez pas vérifier dans la version exacte du compilateur. Et ainsi de suite. Il y a des limites réalistes. Mais vérifiez tout ce que vous pouvez - pas tout à fait de votre vie plus difficile. Et nous ne voulons pas que.

Mot de la fin: les Gousses sont pas de construire des artefacts. Construire des artéfacts de ce qui est généré à partir de vos constructions. Votre build utilise des Gousses, pas les générer. Je ne suis même pas sûr de savoir pourquoi cela doit être débattu.

InformationsquelleAutor n13
1

En théorie, vous devez vérifier dans les Gousses de répertoire. Dans la pratique, il n'est pas toujours d'aller travailler. De nombreuses gousses bien dépasser la limite de taille de github fichiers donc, si vous utilisez github vous allez avoir des problèmes de contrôle dans les Gousses de répertoire.

InformationsquelleAutor Matt
1

Pros de pas signant Pods/ de contrôle de version (en subjective ordre d'importance):
1. Beaucoup plus facile de fusion s'engage, et passer en revue le code de diff. La fusion est une source fréquente de problèmes dans une base de code, et cela vous permet de vous concentrer uniquement sur les choses qui sont pertinentes.
2. Il est impossible pour certains aléatoire contributeur à modifier les dépendances elles-mêmes et vérifiez les changements, qu'ils ne doivent jamais faire (et encore, il serait difficile de déterminer si l'écart est énorme). L'édition de dépendances est très mauvaise pratique, car un avenir pod install pourrait obstruer les modifications.
3. Divergences entre les Podfile et la Pods/ répertoire sont trouvés plus rapidement entre les coéquipiers. Si vous signez Pods/ et, par exemple, de mettre à jour une version dans la Podfile, mais oublier d'exécuter pod install, ou par chèque dans les changements de Pods/, vous aurez un temps beaucoup plus difficile de remarquer la source de l'écart. Si Pods/ n'est pas enregistré, vous devez toujours exécuter pod install de toute façon.
4. Les petites pensions de taille. Avoir un plus petit octet-empreinte est agréable, mais qui n'a pas beaucoup d'importance dans le grand schéma. Le plus important: avoir plus de choses dans le repo augmente également votre charge cognitive. Il n'y a pas de raison d'avoir des choses dans les pensions de titres que vous ne devriez pas être en train de regarder. Reportez-vous à la documentation (l'abstraction) de savoir comment quelque chose fonctionne, pas au code (mise en œuvre).
5. Plus facile de discerner à quel point quelqu'un contribue (depuis leurs lignes de code ont contribué de ne pas inclure les dépendances ils n'ont pas écrit)
6. JAR fichiers, .venv/ (environnements virtuels), et node_modules/ ne sont jamais inclus dans le contrôle de version. Si nous avons été complètement agnostique sur la question, pas signant Pods par défaut basé sur le précédent.
Les inconvénients de pas vérifier dans le Pods/
1. Vous devez exécuter pod install lors de la commutation de branches, ou le retour s'engage.
2. Vous ne pouvez pas exécuter un projet par clonage du référentiel. Vous devez installer le pod de l'outil, puis exécutez pod install.
3. Vous devez avoir une connexion internet pour exécuter pod install, et la source de gousses doivent être disponibles.
4. Si le propriétaire d'une dépendance supprime leur forfait, vous êtes en difficulté.
En résumé, pas compris la Pods répertoire est un garde-fou contre les mauvaises pratiques. Y compris la Pods répertoire qui fait courir le projet plus facile. Je préfère l'ancien sur le second. Vous n'aurez pas besoin de débriefing à chaque nouvelle personne sur un projet de "ce qui pas à faire" si il n'y a pas une possibilité de faire certaines erreurs dans la première place. J'aime aussi l'idée d'avoir une version séparée pour le contrôle de l' Pods qui atténue les Inconvénients.

InformationsquelleAutor efthimio
0

Semble être une bonne manière de structurer ce serait vraiment d'avoir les "Gousses" directory en tant que git sous-module /projet distinct, voici pourquoi.
- Avoir les gousses dans votre projet de pensions de titres, lorsque l'on travaille avec plusieurs développeurs, peut provoquer de TRÈS GRANDES différences dans le pull demandes où il est presque impossible de voir le travail qui a été changé par des personnes (penser à plusieurs centaines de milliers de fichiers qui ont été modifiés pour les bibliothèques, et à seulement quelques changé dans le projet).
- Je vois le problème de ne pas s'engager tout de git, comme la personne qui est propriétaire de la bibliothèque pourrait le prendre à tout moment et vous êtes essentiellement de SOL, cela résout aussi que.
InformationsquelleAutor jaredpetker
0

Si oui ou non vous vérifiez dans votre Gousses dossier est à vous, que les flux de travail varie en fonction du projet. Nous vous recommandons de conserver les Gousses d'annuaire sous contrôle de code source, et de ne pas l'ajouter à votre .gitignore. Mais, en définitive, cette décision est à vous:

Avantages de la vérification dans les Gousses répertoire
1. Après cloner le repo, le projet peut immédiatement à construire et à exécuter, même sans avoir CocoaPods installé sur la machine. Il n'est pas nécessaire pour exécuter pod installer, et aucune connexion Internet n'est nécessaire.
2. La Gousse d'artefacts (code/bibliothèques) sont toujours disponibles, même si la source d'un module (par exemple, GitHub) à la baisse.
3. La Gousse d'artefacts sont garantis d'être identiques à ceux de l'installation d'origine après cloner le repo.
Avantages d'ignorer les Gousses répertoire
1. De commande de la source repo sera plus petit et prendre moins de place.
  Aussi longtemps que les sources (par exemple, GitHub) pour toutes les Gousses sont disponibles, CocoaPods est généralement en mesure de recréer la même installation.(Techniquement, il n'y a aucune garantie que la course de pod installation d'extraction et de le recréer à l'identique les artefacts lorsque vous n'utilisez pas un commit SHA dans la Podfile. Cela est particulièrement vrai lors de l'utilisation de fichiers zip dans le Podfile.)
2. Il n'y aura pas de conflits à traiter lors de l'exécution de la source, les opérations de contrôle, telles que la fusion des branches avec module différent des versions.
  Si vous vérifiez dans les Gousses de répertoire, le Podfile et Podfile.verrouillage doit toujours être gardé sous contrôle de version.
- Vous pouvez utiliser ce lien pour des aucun doute: guides.cocoapods.org/using/...
InformationsquelleAutor Sourabh Mahna
0

TL;DR: lorsque vous suivez le Pods/ dossier, le projet est plus facile à
pick up de. Lorsque vous n'avez pas le suivre, il est plus facile de l'améliorer lors de la
vous travaillez dans une équipe.

Bien que le Cocoapods organisation nous encourager à suivre le Pods/ répertoire, ils disent que c'est aux devs pour décider si ou de ne pas le faire sur la base de ces avantages et des inconvénients: http://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control

Personnellement, j'ai l'habitude de suivre les Pods/ dossier juste pour des projets que je ne peux pas travailler plus pendant un certain temps. De cette façon, n'importe quel développeur peut rapidement revenir et continuer le travail en utilisant la version correcte de la cocoapods.

D'autre part, je pense que la validation de l'histoire devient plus propre et plus facile de fusionner le code et l'examen d'une autre personne code lorsque vous n'êtes pas suivi le Pods/ dossier. J'ai l'habitude de définir la cocoapod de la bibliothèque de version quand j'ai installer pour s'assurer que n'importe qui peut installer le projet en utilisant les mêmes versions que I.

Aussi, lorsque le Pods/ répertoire est en cours de suivi de toutes les développeurs doivent utiliser la même version de Cocoapods pour l'empêcher de changer des dizaines de fichiers chaque fois que nous courons pod install pour ajouter/supprimer un pod.

Ligne de fond: lorsque vous suivez le Pods/ dossier, le projet est plus facile à ramasser de. Lorsque vous n'avez pas suivi, c'est plus facile à améliorer.

InformationsquelleAutor marcelosalloum

Vous devez vous connecter pour publier un commentaire.

.gitignore fichier

Pourquoi les gousses doivent faire partie de l'opération (sous contrôle de code source) et ne doit pas être ignoré