Private Composer Packages with Gemfury

Key Points

• Gemfury is a platform-as-a-service (PaaS) solution for hosting private Composer packages, providing an alternative to self-hosting options such as Toran Proxy or Satis. It supports multiple languages ​​including the PHP Composer package, Ruby Gems, Node.js npm, Python PyPi, APT, Yum, and Nu-Get.
• To use Gemfury, you need to create an account, create a package, and upload it to the platform. This can be done by using Git and having Gemfury handle the rest, or by manually zipping the package's source code and uploading it on the Gemfury dashboard.
• You can add your private repository to the composer.json file of your project. This allows you to use any private Composer packages you create with Gemfury without adding a separate repository every time you want to use the package.
• Gemfury also provides a command line tool to manage your packages. This tool allows you to list your packages, view versions of specific packages, and more. You can install it using the command sudo gem install gemfury.

Suppose you are familiar with Composer, this is the latest and probably the best PHP package manager. If not, check out Alexander’s introduction and I’m sure you’ll be immediately attracted to it. You need to have its working knowledge to make the most of this article.

Composer works efficiently and seamlessly with Packagist, a comprehensive public package repository.

However, sooner or later, you will encounter a package you wrote yourself, which for some reason cannot be open source and shared for free via Packagist.

There are several options for hosting these private packages. You can configure the composer.json file of the project by adding the package's repository separately. Alternatively, Satis allows you to generate your own static repository. Alternatively, Toran Proxy allows you to create a self-hosted private version of Packagist that, once set up, is easier to manage than specifying a repository in your composer.json.

Gemfury is a PaaS alternative. Apart from the peace of mind (although it needs to be paid) that hosted solutions are a huge advantage that it supports not only the PHP Composer package, but also Ruby Gems, Node.js npm, Python PyPi, APT, Yum, and Nu-Get. This is very useful if you have multiple languages.

Let's dive into how to use it.

Set up your account

First of all, you need an account. There is a 14-day trial period, with a free account limited to one collaborator and a hosting package, and a range of other plans starting at $9 per month.

You can register using your email address or Github account. Go to the website to register.

Create your first package

To demonstrate how to use Gemfury for a private Composer package, let's create a package step by step which we will submit to the service for use in other projects later.

The easiest way to create a new package is to use the following command:

composer init

It asks you a series of questions; Here is an example record of this process:

<code>...  (此处省略与原文相同的composer init交互过程) ...</code>

As you can see, we are creating a simple package with only one dependency Faker .

Next, let's add a line to the newly created composer.json and tell it where to find the source code of the package.

"autoload": {        
    "psr-0": {
        "Acme\": "src/"
    }
},

Now let's create the package itself. We will create a class with only one purpose; generate discount coupon codes for e-commerce platforms using complex, top-secret proprietary algorithms.

In your working directory, create the src and src/Acme directories, and then create the following file named Coupon.php:

<?php namespace Acme;

use Faker\Factory;

class Coupon {

    public static function generate($percent) 
    {
        $faker = Factory::create();

        return sprintf('%s-%s-%d',
            strtoupper(date('M')),
            strtoupper($faker->word()),
            intval($percent));
    }

}

Run now composer install to load our only dependencies and configure the autoloader.

This is the package we built. Now upload it to Gemfury.

To continue, you need your API key. If you go to your dashboard, you will find it under Settings.

The easiest way to build and upload a package is to simply use Git and let Gemfury handle the rest.

First create a .gitignore file with the following content:

<code>vendor/
composer.lock</code>

Initialize the repository now:

git init

Add file:

git add src
git add composer.json

Now we will add a Git remote repository. You can find the relevant URL by selecting Getting Started in the Gemfury dashboard and then selecting the PHP Composer tab. It will look like this:

<code>https://your-username@git.fury.io/your-username/<package-name>.git</code>

Be sure to replace your-username with your Gemfury username (if you register with Github, it will be the same as your Github username) and add it as a remote repository:

git remote add fury https://your-username@git.fury.io/your-username/coupon.git

At this point, you have two choices. The first is to use explicit version control, where you specify the version in the composer.json file, as shown below:

{
    "name": "your-username/coupon",
    "description": "Generates a coupon code",
        "version": "1.0.0",
    ...

It is important that you use semantic versioning. Otherwise, your package may not be built correctly; this can also lead to some weirdly worded error messages.

Or, you can use the Git tag. For example, create a new version with a tag, as shown below:

git tag -a 1.0.0 -m "Version 1.0.0"

No matter which method you take, the next step is to submit:

git commit -a -m "Initial commit"

Finally, run the following command:

git push fury master --tags

This pushes your code to Gemfury, which will then automatically build it into a package.

Now if you go to your dashboard, you should see that your new repository is listed. Next, let's see how you use it in your project.

Using private package

If you go back to the dashboard and select "Repos" on the left, you will find your private repository URL. This should be kept private, so please keep it safe. It will look like this:

<code>https://php.fury.io/SECRET-CODE/your-username/</code>

It is SECRET-CODE that makes it unpredictable and therefore is actually private.

Add it now to your project's composer.json:

composer init

You just need to add this one repository to use any private Composer packages you created with Gemfury. There is no need to add a separate repository every time you want to use the package.

Now you can need your private package just like you do on Packagist. Here is a complete example of a project composer.json:

<code>...  (此处省略与原文相同的composer init交互过程) ...</code>

Other methods

Personally, I believe that using Git and tags is the easiest and most effective way to manage packages.

Or, if you prefer, you can build it yourself by zipping the source code of the package and uploading it on the Gemfury dashboard.

Command line tool

Gemfury also provides a command line tool. To install it:

"autoload": {        
    "psr-0": {
        "Acme\": "src/"
    }
},

To list your package, you can use the following command:

<?php namespace Acme;

use Faker\Factory;

class Coupon {

    public static function generate($percent) 
    {
        $faker = Factory::create();

        return sprintf('%s-%s-%d',
            strtoupper(date('M')),
            strtoupper($faker->word()),
            intval($percent));
    }

}

To view the version of a specific package:

<code>vendor/
composer.lock</code>

For more information about CLI, please visit the relevant sections of the documentation.

Summary

In this article, I introduce Gemfury, one of the many options for managing private repositories. As a PaaS solution, it does not require the extra burden of self-hosting options like Toran and is easier to use than Satis. It also has the huge advantage of supporting packages in a variety of languages, from PHP Composer packages to Ruby Gems and Node.js npm. Of course, as a PaaS solution, it does have to pay for it – but why not try it with a free trial or a free single package plan to see if it’s right for you?

(The original FAQs part is omitted here because this part is a frequently asked question, and it has a high repetition of the main content of the article, and its value is not high after pseudo-originality.)

The above is the detailed content of Private Composer Packages with Gemfury. For more information, please follow other related articles on the PHP Chinese website!