Comment développer et inclure un Compositeur paquet?

Je suis à la recherche pour développer un logiciel en PHP, mais je ne veux pas immédiatement disponible sur GitHub ou quelque part. Il est assez facile de comprendre un Packagist fichier dans mon composer.json, mais comment puis-je ajouter un paquet dans mon composer.json? Aussi, dois-je être la construction du paquet dans /vendor/foo/bar (par rapport à la racine composer.json), ou dois-je le mettre ailleurs?

Modifier: je suppose que ma question est à propos de la façon dont tout le monde écrit leurs forfaits. Est-ce que chaque nouveau paquet ajouté à Packagist, et puis quand vous voulez tester vos modifications, vous vous engagez à GitHub (ou autre ville), puis tirez-le que retour vers le bas par le Compositeur? Cela semble très inefficace.

InformationsquelleAutor greggilbert | 2013-01-12

composer-php php

26

Que cette question a de nombreux composants différents/normes à être expliqué, je vais essayer d'expliquer autant que possible ici, et vous pouvez me PM ou simplement Google pour des questions plus spécifiques comme elles arrivent.

Pour répondre à votre première question, "Comment puis-je ajouter un paquet dans mon composer.json?":

Si par "ajouter un forfait local" vous voulez dire de chargement automatique de votre classe/paquet, vous pouvez le faire soit en utilisant le PSR-4 ou PSR-0 ou Classmap options de compositeur.

Lire plus
Vous pouvez Google si vous avez besoin de plus d'infos sur le PSR-0, PSR-4 et Classmap.

Exemple
```
"autoload": {
   "psr-4": { "Core\\": "src/Core" }  ## "standard": { "namespace" : "path/to/dir"}
}
```
Ou (modifier)

Si vous voulez ajouter un paquet:
1. Créer un composer.json pour le forfait local, comme:
```
{
   "name": "localPackage/core",
   "version": "dev-master"
}
```
  Vous pouvez également définir d'autres caractéristiques et/ou les dépendances nécessaires.
2. Zip le paquet, avec le composer.json fichier à la racine de fichier dans le archive.zip, et le placer à l'endroit désiré.
3. Dans l'autre projet/dossier où vous souhaitez inclure le forfait local, ajouter le forfait local nom pour le paramètre requis, comme
```
"localPackage/core": "dev-master"
```
  Ajoutez la ligne suivante sous la repositories paramètre:
```
"repositories" : [
    {
        "type": "artifact",
        "url": "path/to/localPackage.zip"
    }
]
```
Maintenant, si vous avez le forfait local git, alors il n'y aurait pas besoin d'archiver l'ensemble (essentiellement omettez l'étape 2) et vous avez juste besoin de remplacer l'URL dans l'exemple ci-dessus à la path/to/localPackage/.git.

(Fin de l'edit)

Maintenant pour répondre à la grande question: "Comment puis-je développer et inclure un Compositeur paquet?":
1. Décider de la structure de répertoire. Souvent, il est comme suit:
```
/PackageRoot
    /src/PackageCore
    composer.json   ## this is your library’s composer.json
    LICENSE
```
  et de configurer votre composer.json.
  
  Un exemple de l'un de mes composer.json les fichiers peuvent être trouvés à http://pastebin.com/tyHT01Xg.
2. De le télécharger à l' Github et la version. Utilisation Sémantique gestion des versions (assurez-vous d'exclure/ignorer la vendor répertoire lors de téléchargement sur Github).
3. Inscrire le package avec Packagist (une fois connecté).
  
  Si vous avez coché votre s'engager en tant qu' v1.0.0 (ou similaire), cela apparaîtra dans votre Packagist tableau de bord pour ce paquet.
Maintenant, si tout est fait correctement, vous devriez être en mesure d'utiliser votre bibliothèque comme une dépendance à d'autres projets en l'ajoutant à la composer.json de ce projet.
- Mais comment développer un compositeur paquet sans de la nécessité de le publier? La raison en est que je ne veux pas publier mon colis, parce que c'est fondamentalement pas encore fini, mais je veux encore à définir mon compositeur.fichier json et ses dépendances sans le besoin de valider et/ou publier c'est déjà quelque part. Je veux être en mesure de bricoler avec mon code jusqu'à ce que c'est d'accord et quand c'est prêt, je veux le publier. Exemple: j'ai un projet Un et pour ce projet, je définir une require dépendance sur mon nouveau forfait B, qui n'existe que sur ma machine. Comment puis-je test B à l'intérieur d'Un sans le publier?
- Comme je l'ai dit compositeur travaille de de Packagist et Git. Son okie si votre colis n'est pas prêt. juste le tag ' alpha/beta sur git.
- Fondamentalement, vous ne pouvez pas besoin d'un package qui n'est pas sur Packagist ou sur github. Même ma demande n'est pas prêt, mais est sur github/packagist et étiquetés comme v1.x.x-alpha, check it out si vous le souhaitez - github.com/shalomsam/Core
- vous pouvez très bien avoir besoin des paquets qui ne sont pas sur Packagist, ni github - voir la Coutume des Référentiels de Lien avec l'autre ont posté des réponses
- oui je suis corrigé. Mais je suppose que vous ne pouvez pas l'utiliser pour charger des packages locaux, ou pouvez-vous?
- désolé pour le retard de mise à jour. Mais espérons que cette aide
InformationsquelleAutor ShalomSam
20

Au lieu de créer un nouvel espace de stockage, vous pouvez dire compositeur à utiliser tout chemin d'accès local:

https://getcomposer.org/doc/05-repositories.md#path

Par exemple, disons que vous avez vos projets PHP sous ~/devel/projects

Vous pouvez avoir votre principal projet dans ~/devel/projects/main_project, et votre "forfait local" dans ~/devel/projects/local_package

Définir votre compositeur de configuration pour le forfait local. Dans ~/devel/projects/local_package/composer.json.
```
{
    "name": "your_vendor_id/your_local_package",
    ...
}
```
Ensuite, vous pouvez modifier ~/devel/projects/main_project/composer.json et un lien vers votre forfait local via chemin de repo:
```
"repositories": [
    {
        "type": "path",
        "url": "../local_package",
        "options": {
            "symlink": true
        }
    }
],
"require": {
    "your_vendor_id/your_local_package": "dev-master",
    ...
}
```
Plus d'infos sur ce lien (pas écrit par moi, mais a une bonne explication à ce sujet):

https://carlosbuenosvinos.com/working-at-the-same-time-in-a-project-and-its-dependencies-composer-and-path-type-repository/

InformationsquelleAutor Federico J. Álvarez Valero
9

Il semble que la plupart des réponses sur ce fil ne sont pas "dans le savoir". Je suis nouveau à Composer moi-même, mais ces réponses sont trompeuses. La question pourrait tout simplement être énoncé comme: "Comment puis-je développer un compositeur package".

Oui, vous pouvez utiliser un référentiel ou de les télécharger à reconstituer le paquet et le mettre à jour après chaque modification. Qu'elle n'est pas la bonne solution ou la réponse à la question.

Cela n'aide pas que Compositeur de la documentation officielle ne fait pas état de cette avance, mais vous pouvez voir la rubrique sur la Documentation des bibliothèques de la page:

Chaque projet est un package

C'est très important de comprendre

compositeur.json:

Mentionnées précédemment, la page d'état:
Afin de faire de ce paquet installable vous avez besoin de lui donner un nom. Vous faites cela en ajoutant le nom de la propriété dans composer.json
```
{
    "name": "acme/hello-world",
    "require": {
        "monolog/monolog": "1.0.*"
    }
}
```
Dans cet exemple, jusqu'à présent, nous avons un package requis, et maintenant un nom. Remarque le vendor/name format.

Donc maintenant à l'auto-chargement de nos propres fichiers, ce qui est documenté sur le Utilisation de base page.
```
{
    "autoload": {
        "psr-4": {"Acme\\": "src/"}
    }
}
```
Cela va de chargement automatique de l'espace de noms de fichiers de classe en vertu de la src/Acme répertoire.

Sur le plaisir.

Installer/Mettre À Jour

Installer ou mettre à jour le paquet avec la commande:
```
composer update
```
ou
```
php composer.phar update
```
Cela permettra de télécharger les paquets nécessaires et de créer la autoload.php fichier

Notre structure de projet devrait ressembler similaires aux suivantes:
```
src
    Acme
        Foo.php
vendor
    monolog
        ...
composer.json
```
Y compris

Maintenant pour tester.

Inclure autoload.php

require_once 'path/to/project/vendor/autoload.php';

En supposant Foo.php se présente comme suit:
```
<?php

namespace Acme;

class Foo {
    public static function bar(){
        return 'baz';
    }
}

?>
```
on peut alors appeler cela de notre script:
```
echo Acme\Foo::bar(); //baz
```
Veuillez corriger toute information trompeuse j'ai peut-être dit. C'est ce que semble l'être la solution à une question populaire.
- Que les modifier à la question d'origine mentionne, c'est vraiment inefficace avoir à commettre, pousser, puis exécutez la mise à jour sur le projet parent à chaque fois que vous faites un peu de changement à votre sous-package. Je ne suis pas sûr que cette réponse s'occupe de cette question.
InformationsquelleAutor iautomation
7

Voici un récapitulatif des solutions en plus de ma propre
1. publier sur packagist
Puisque vous ne voulez pas publier encore, vous êtes en développement, c'est une mauvaise option.
1. télécharger github
Vous ne pouvez pas publier votre bibliothèque de source sur github, pas envie de payer pour un repo, ou être en mesure d'utiliser un cloud service externe (pour des raisons politiques ou des stratégies de réseau).
1. zip de votre bibliothèque
Vous pouvez utiliser le compositeur le chemin du référentiel dans votre exemple de mise en œuvre à point à un fichier zip comme une libération. Vous devrez re-zip à chaque fois que vous apportez une modification à la lib, même avec un fichier de commandes pour le faire, c'est dégueulasse.
1. télécharger local git/svn repo sur votre machine
C'est de se rapprocher, mais vous aurez besoin de faire un compositeur de mise à jour chaque fois que vous changez votre bibliothèque et que vous voulez tester votre exemple de mise en œuvre. Cette imite productions, mais c'est encombrant. Personnellement je recommande cette solution, même si elle n'est pas sans cervelle.
1. De chargement automatique de la bibliothèque directement (sortof fait ce que vous voulez)
C'est un hack, mais vous pouvez simplement ajouter:
```
{    
  "require": {
  },
  "autoload": {
    "psr-4": { 
      "yourlibnamespace": "D:\\Code\\yourlib\\src\\" 
    }
  }
```
}

Veuillez noter que vous devrez copier+coller l'exigent " la section de votre lib de votre exemple de mise en œuvre. Le changement "yourlibnamespace" à votre bibliothèque de noms et de "D:\Code\yourlib\src\" à votre chemin d'accès à votre bibliothèque de source.

De cette façon, tous les changements sont immédiatement répercutées. Toutefois, vous ne pouvez pas utiliser ou tester votre bibliothèque compositeur.fichier json à tous. Si vous modifiez une exigence dans votre bibliothèque .json il ne s'écoule pas à travers à tous. Donc, il a quelques gros inconvénients, mais ne faites ce que vous voulez, ce qui est de tester votre bibliothèque de la mise en œuvre immédiatement avec le moins de commandes possibles.
1. ajouter votre exemple de mise en œuvre directement dans votre bibliothèque arbre (recommandé)
Habituellement, vous n'avez src\ et tests\, mais beaucoup ont des exemples\ où vous pouvez trouver un exemple de mise en œuvre. Comme vous le développement de votre application, vous pouvez contribuer à ces exemple implémentations. Vous pouvez le faire dans un local git/svn repo, et vous avez l'avantage de l'obtention de la lib de 'besoin', en plus de l'espace de noms automatiquement. C'est le meilleur de tous les mondes. Je recommande cette méthode.
- Très trompeur. La question est sur le développement avant de le télécharger. #5 est la bonne réponse, et n'est pas un hack.
- Vous êtes dans l'erreur. La question est "comment puis-je développer un nouveau compositeur paquet localement avant de les publier sur packagist" n'est pas "Comment dois-je utiliser compositeur paquets dans mon projet". La réponse que vous avez posté après downvoting moi (et je ne peux donc pas commenter votre réponse à tort réponses à la 2ème question, pas le sujet de cette question. Tous les 6 approches dans ma réponse sont correctes (3-6 répondre à l'op directement), qu'ils ont tous des inconvénients. Je suggère #6.
InformationsquelleAutor Finlay Beaton
5

Peut-être l'ajout d'un dépôt personnalisée vous aidera?

https://github.com/composer/composer/blob/master/doc/05-repositories.md

Vous pouvez mettre en place un dépôt git local avec votre bibliothèque très facilement.

Bien sûr, si vous utiliser composer pour gérer les dépendances vous devez construire votre bibliothèque à un autre endroit, et de le télécharger à vendor/via composer coz c'est l'ensemble de point, je suppose.
- Alors que vous développez, vous avez à faire un composer update chaque fois que vous faites un petit changement à votre package pour le dev du projet à tirer dans la dernière version? Est-il un moyen plus rapide?
- Je suis dans la même situation. Je ne comprends pas comment développer un compositeur paquet localement sans avoir besoin de le télécharger quelque part ou de l'exécution d'un compositeur de commande à chaque fois qu'une modification est apportée.
- Ce conseil était juste pour l'élaboration d'un compositeur hors de votre bibliothèque. Pourquoi voulez-vous utiliser compositeur de développer la bibliothèque elle-même? Je pense que vous pouvez poser une autre question coz je ne suis pas à l'aide de compositeur plus et c'est près de 2 ans. cheers
- parce que votre Compositeur package est un Compositeur plugin, par exemple.
InformationsquelleAutor fsw
5

C'est mon flux de création et de développement d'un nouveau Compositeur paquet localement:
1. Créer un nouveau référentiel pour le package sur GitHub (juste un exemple)
2. L'ajouter à du Compositeur de la base de données (packagist.org)
3. L'ajouter à votre projet principal via composer besoin. C'est là que vous commencez à vous demandez-vous comment pouvez-vous appliquer les correctifs rapidement
4. Le Clone en local sur votre machine, c'est là que vous le développer
5. Maintenant pour tester votre version locale, ajouter un php require() déclaration de l'endroit où vous chargez les fichiers de classe en question. L'autochargeur de ne pas charger l'un téléchargés via le compositeur, mais votre local.
6. Lorsque vous avez terminé hotfixing, de supprimer, de commenter le besoin énoncé de revenir en arrière à l'aide du compositeur version du package.
7. Valider toutes les modifications, le tag de la validation et de la pousser à GitHub; crochet feux de mise à jour de Compositeur. Exécuter compositeur de mise à jour sur votre projet principal, le paquet est mis à jour pour votre version locale.
Ce n'est pas encore idéal, mais il obtient le travail fait pour les petites et moyennes paquets.

InformationsquelleAutor George Kagan
5

Pour rendre le développement plus efficace, j'ai simplement symlink le référentiel de développement dans un répertoire qui a déjà installé.

Par exemple, si /Code/project-1 exige un paquet qui est dans /Code/package-1, j':
1. Commettre package-1 à GitHub (peut-être même privé).
2. Je puis dire project-1 installer à l'aide d'un référentiel personnalisé (voir les autres réponses pour le lien vers le référentiel de configuration).
3. Une fois qu'il est installé, je symlink /Code/project-1/vendor/developer/package-1 à /Code/package-1.
De cette façon, quand je fais des changements dans /Code/package-1, il est immédiatement pris en compte dans /Code/project-1.

InformationsquelleAutor Adam Engebretson
0

Mon flux de travail ne permet pas de répondre complètement à l'OP de la question, mais peut être utile pour les autres.
1. J'aime à développer une réutilisables package /lib dans un monde réel projet et je ne veux pas passer par git /compositeur localement.
2. Je n'aime pas non plus à charger le package différemment localement par rapport à la production (par exemple, par le biais d'un local exiger la déclaration ou local compositeur réglage).
Donc ce que je fais est simple: j'ai ajouter le package directement sous le répertoire des vendeurs, que ce soit directement ou à l'aide d'un lien symbolique.

inconvénients
1. Lors de l'utilisation de compositeur de mise à jour /installer, votre colis peut être remplacé. (j'ai donc tendance à mettre à jour ou ajouter des dépendances, un par un, pendant ce temps).
2. Lorsqu'il n'est pas prudent, compositeur installer sur l'environnement de production peut installer une version différente. Afin de continuer à pousser votre colis et les balises de version!!
3. Changer les dépendances du paquet et de le charger dans le projet parent creux compositeur de mise à jour, remplace le package du dossier
InformationsquelleAutor roelleor

Vous devez vous connecter pour publier un commentaire.

Lire plus

Exemple

Ou (modifier)

compositeur.json:

Installer/Mettre À Jour

Y compris

inconvénients