English | العربية | বাংলা | Bosanski | Deutsch | Español | Français | हिन्दी | Italiano | 日本語 | 한국어 | मराठी | Português | Русский | Kiswahili | தமிழ் | తెలుగు | Türkçe | اردو | Tiếng Việt | 中文

• Introduction
  • Caractéristiques Principales
  • Exemple
• Installation
  • Exigences
  • Dépendances Optionnelles
• Utilisation
  • Flux de Travail Basique
  • Configuration de Stockage
  • Configuration de Concurrence
  • Nom de Fichier
  • Semence pour la Reproductibilité
• Générateurs
  • Générateurs d'Images
  • Générateur de Texte
  • Générateur CSV
  • Générateur Binaire
  • Générateur d'E-mails
• Utilisation Avancée
  • Générateurs Personnalisés
  • Classes de Configuration
  • Conseils de Performance
• Configuration
  • Méthodes de Configuration Globales
• Directives de Support
  • Support Axé sur la Communauté
  • Bugs et Priorisation des Fonctionnalités
• Licence - Licence MIT

🔗Introduction

Faker Storage est un package PHP performant conçu pour générer et stocker de grands volumes de fichiers de données fictives de manière efficace. Construit avec la concurrence à l'esprit, il utilise Swoole ou PCNTL pour générer des milliers de fichiers en parallèle, ce qui le rend idéal pour les tests de charge, les environnements de développement et l'évaluation des systèmes de stockage.

Le package fournit une API fluide pour générer divers types de fichiers, y compris des images (PNG, JPG, GIF, BMP, WEBP, AVIF), des fichiers texte, des fichiers CSV, des données binaires et des e-mails conformes à RFC822. Chaque générateur produit une sortie déterministe lorsqu'il est initialisé, garantissant des données de test reproductibles à travers les environnements.

🔗Caractéristiques Principales

• Concurrence Haute Performance : Sélection automatique entre Swoole (coroutines) et PCNTL (forking de processus) pour la génération de fichiers parallèle.
• Multiple Générateurs de Fichiers : Support intégré pour les images, le texte, les fichiers CSV, binaires et les e-mails.
• Sortie Déterministe : La génération basée sur la graine assure des résultats reproductibles.
• Stockage Flexible : Fonctionne avec tout adaptateur League Flysystem (local, S3, etc.).
• Nom de Fichiers Personnalisable : Génération de noms basée sur des closures avec un contrôle total.
• Support d'Image : Multiples formats avec dimensions et compression configurables.
• Génération d'E-mails : E-mails conformes à RFC822 avec pièces jointes et support MIME.

🔗Exemple

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Png;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Générer 1000 images PNG avec 10 travailleurs concurrents
Faker::make(Png::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->basePath('images')
    ->count(1000)
    ->concurrency(10)
    ->seed(42)
    ->generate();
 
// Générer des fichiers CSV
use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)
    ->rows(100, 500)
    ->delimiter(',')
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(50)
    ->generate();
 
// Générer des e-mails avec pièces jointes
use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)
    ->sentences(2, 4)
    ->withAttachment(Png::class, 1, 3)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(100)
    ->generate();

🔗Installation

Installez le package via Composer :

composer require defectivecode/faker-storage

🔗Exigences

• PHP >= 8.4
• ext-gd (pour la génération d'images)
• ext-swoole (optionnel, pour de meilleures performances)
• ext-pcntl (repli pour la concurrence)

🔗Dépendances Optionnelles

Pour des performances optimales, installez l'extension Swoole :

pecl install swoole

Le package utilisera automatiquement Swoole si disponible, sinon il revertira à PCNTL.

🔗Utilisation

🔗Flux de Travail Basique

Tous les générateurs suivent le même modèle :

1. Créez une instance de Faker avec un générateur.
2. Configurez le générateur (optionnel).
3. Définissez la destination de stockage.
4. Configurez la concurrence et le nombre.
5. Générez les fichiers.

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Text;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)          // Configuration spécifique au générateur.
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // Les fichiers seront dans /storage/documents/
    ->count(100)                 // Générer 100 fichiers.
    ->concurrency(4)             // Utiliser 4 travailleurs.
    ->seed(123)                  // Pour une sortie déterministe.
    ->generate();

🔗Configuration de Stockage

Utilisation de Flysystem

Faker Storage utilise League Flysystem pour l'abstraction du stockage :

use League\Flysystem\Filesystem;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Stockage local
$filesystem = new Filesystem(new LocalFilesystemAdapter('/path/to/storage'));
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->generate();

Stockage AWS S3

use Aws\S3\S3Client;
use League\Flysystem\Filesystem;
use League\Flysystem\AwsS3V3\AwsS3V3Adapter;
 
$client = new S3Client([
    'credentials' => [
        'key'    => 'your-key',
        'secret' => 'your-secret',
    ],
    'region' => 'us-east-1',
    'version' => 'latest',
]);
 
$adapter = new AwsS3V3Adapter($client, 'your-bucket-name');
$filesystem = new Filesystem($adapter);
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->basePath('uploads/images')
    ->generate();

Options de Disque

Passez des options supplémentaires à l'adaptateur de système de fichiers :

Faker::make(Png::class)
    ->toDisk($filesystem)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
        'CacheControl' => 'max-age=31536000',
    ])
    ->generate();

🔗Configuration de Concurrence

Contrôlez l'exécution parallèle avec la méthode concurrency() :

// Utiliser 10 threads/processus de travail
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Spécifique à Swoole : Définir à la fois les threads et les coroutines par thread
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 travailleurs, 8 coroutines chacun.
    ->generate();

🔗Nom de Fichier

Nommage par Défaut

Par défaut, les fichiers sont nommés avec UUID v4 :

// Génère : e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
Faker::make(Png::class)->generate();

Générateurs de Noms Intégrés

use DefectiveCode\Faker\NameGenerator;
 
// Basé sur UUID (défaut)
NameGenerator::setDefault('uuid'); // Génère : e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
 
// Numérotation séquentielle
NameGenerator::setDefault('sequence'); // Génère : 1.png, 2.png, 3.png, ...

Nommage Personnalisé

Fournissez une closure pour personnaliser les noms de fichiers :

use DefectiveCode\Faker\NameGenerator;
 
// Closure personnalisée
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "custom-{$completedFiles}-{$seed}.png";
    })
    ->generate();
 
// Nommage basé sur la date
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return date('Y/m/d') . "/image-{$completedFiles}.png";
    })
    ->generate();

🔗Semence pour la Reproductibilité

Définissez une graine pour générer les mêmes fichiers à chaque exécution :

Faker::make(Png::class)
    ->seed(42)
    ->count(10)
    ->generate();

Chaque fichier obtient une graine déterministe unique dérivée de la graine de base et de l'index du fichier.

🔗Générateurs

🔗Générateurs d'Images

Tous les générateurs d'images prennent en charge la configuration des dimensions et de la qualité.

PNG

use DefectiveCode\Faker\Generators\Png;
 
Faker::make(Png::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px.
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px.
    ->withAlpha(true)           // Activer le canal alpha/transparence.
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5.
    ->toDisk($filesystem)
    ->generate();

JPG

use DefectiveCode\Faker\Generators\Jpg;
 
Faker::make(Jpg::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px.
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px.
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5.
    ->toDisk($filesystem)
    ->generate();

GIF

use DefectiveCode\Faker\Generators\Gif;
 
Faker::make(Gif::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px.
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px.
    ->withAlpha(true)           // Activer le canal alpha/transparence.
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5.
    ->toDisk($filesystem)
    ->generate();

BMP

use DefectiveCode\Faker\Generators\Bmp;
 
Faker::make(Bmp::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px.
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px.
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5.
    ->toDisk($filesystem)
    ->generate();

WEBP

use DefectiveCode\Faker\Generators\Webp;
 
Faker::make(Webp::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px.
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px.
    ->withAlpha(true)           // Activer le canal alpha/transparence.
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5.
    ->toDisk($filesystem)
    ->generate();

AVIF

use DefectiveCode\Faker\Generators\Avif;
 
Faker::make(Avif::class)
    ->width(800, 1920)          // Largeur aléatoire entre 800-1920px.
    ->height(600, 1080)         // Hauteur aléatoire entre 600-1080px.
    ->withAlpha(true)           // Activer le canal alpha/transparence.
    ->grid(5)                   // Optionnel : Générer un motif symétrique 5x5.
    ->toDisk($filesystem)
    ->generate();

Image Aléatoire

Génère un format d'image aléatoire :

use DefectiveCode\Faker\Generators\RandomImage;
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(false)          // Aléatoire parmi : AVIF, BMP, GIF, JPEG, PNG, WEBP.
    ->toDisk($filesystem)
    ->generate();
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(true)           // Aléatoire parmi : AVIF, GIF, PNG, WEBP.
    ->toDisk($filesystem)
    ->generate();

🔗Générateur de Texte

Générez des fichiers texte brut avec des paragraphes :

use DefectiveCode\Faker\Generators\Text;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)         // 5-10 paragraphes par fichier.
    ->sentences(3, 6)           // 3-6 phrases par paragraphe.
    ->toDisk($filesystem)
    ->generate();

Exemple de Sortie :

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.

🔗Générateur CSV

Générez des fichiers CSV avec des données aléatoires :

use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)            // 5-10 colonnes.
    ->rows(100, 500)            // 100-500 lignes.
    ->delimiter(',')            // Délimiteur de colonne.
    ->enclosure('"')            // Enclosure de champ.
    ->escape('\\')              // Caractère d'échappement.
    ->eol("\n")                 // Fin de ligne.
    ->toDisk($filesystem)
    ->generate();

Exemple de Sortie :

"John Doe","john@example.com","555-1234","New York","Engineer"
"Jane Smith","jane@example.com","555-5678","Los Angeles","Designer"
"Bob Johnson","bob@example.com","555-9012","Chicago","Manager"

🔗Générateur Binaire

Générez des données binaires aléatoires :

use DefectiveCode\Faker\Generators\Binary;
 
Faker::make(Binary::class)
    ->length(1024, 1048576)     // 1 Ko - 1 Mo.
    ->toDisk($filesystem)
    ->generate();

🔗Générateur d'E-mails

Générez des fichiers d'e-mails conformes à RFC822 :

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // Paragraphes dans le corps de l'email.
    ->sentences(2, 4)           // Phrases par paragraphe.
    ->withAttachment(Png::class, 1, 3)  // Ajouter 1-3 pièces jointes PNG.
    ->toDisk($filesystem)
    ->generate();

En-Têtes d'E-Mail

Les e-mails générés incluent :

• To: Nom et e-mail aléatoires.
• From: Nom et e-mail aléatoires.
• Subject: Phrase aléatoire.
• Date: Horodatage actuel.
• Message-ID: ID déterministe basé sur la graine.

E-mail avec Pièces Jointes

Attachez des fichiers en utilisant les classes de générateur ou des instances :

use DefectiveCode\Faker\Generators\Email;
use DefectiveCode\Faker\Generators\Png;
use DefectiveCode\Faker\Generators\Pdf;
 
Faker::make(Email::class)
    ->withAttachment(Png::class, 1, 3)  // 1-3 pièces jointes PNG.
    ->generate();
 
// Attacher en utilisant l'instance de générateur configurée.
$pngGenerator = new Png(Png::getDefaultConfig());
$pngGenerator->width(400, 800)->height(300, 600);
 
Faker::make(Email::class)
    ->withAttachment($pngGenerator, 2, 5)
    ->generate();

Exemple de Sortie :

To: John Doe <john.doe@example.com>
From: Jane Smith <jane.smith@example.com>
Subject: Important meeting tomorrow
Date: Fri, 03 Jan 2026 10:30:00 +0000
Message-ID: <3e92e5c2b0d632b3a36fbbb17484b7fe@example.com>
Content-Type: multipart/mixed; boundary="----=_Part_123"
 
------=_Part_123
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
 
Lorem ipsum dolor sit amet, consectetur adipiscing elit...
 
------=_Part_123
Content-Type: image/png; name="attachment.png"
Content-Disposition: attachment; filename="attachment.png"
Content-Transfer-Encoding: base64
 
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==
------=_Part_123--

🔗Utilisation Avancée

🔗Générateurs Personnalisés

Créez vos propres générateurs en implémentant l'interface Generator :

use DefectiveCode\Faker\Configs\Config;
use DefectiveCode\Faker\Concerns\SetsSeed;
use DefectiveCode\Faker\Generators\Generator;
use DefectiveCode\Faker\Concerns\PreparesFaker;
 
class MyCustomGenerator implements Generator
{
    use PreparesFaker;
    use SetsSeed;
 
    public function __construct(public Config $config) {}
 
    public static function getDefaultConfig(): Config
    {
        return new MyCustomConfig([
            'contentType' => 'application/x-custom',
            'nameGenerator' => NameGenerator::default('extension'),
        ]);
    }
 
    public function generate(): mixed
    {
        // Votre logique de génération ici.
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// Utilisez votre générateur personnalisé.
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

🔗Classes de Configuration

Chaque générateur utilise une classe de configuration étendant Config :

use DefectiveCode\Faker\Configs\Config;
 
class MyCustomConfig extends Config
{
    public int $minValue = 1;
    public int $maxValue = 100;
}

🔗Conseils de Performance

1. Utilisez Swoole : Installez l'extension Swoole pour les meilleures performances.
2. Ajustez la Concurrence : Alignez le nombre de threads sur le nombre de cœurs CPU pour un débit optimal.
3. Opérations par Lots : Générez de grands lots plutôt que plusieurs petites exécutions.
4. Emplacement de Stockage : Utilisez un stockage rapide (SSD, disque local) pour les fichiers temporaires avant de les télécharger.
5. I/O Réseau : Lors de l'utilisation de S3, augmentez la concurrence pour maximiser l'utilisation de la bande passante.

🔗Configuration

🔗Méthodes de Configuration Globales

Ces méthodes sont disponibles sur toutes les instances Faker :

make(string $generator): Faker

Créez une nouvelle instance de Faker avec le générateur spécifié :

Faker::make(Png::class)

toDisk(Filesystem $filesystem): Faker

Définissez la destination de stockage (requise) :

Faker::make(Png::class)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))

basePath(string $basePath): Faker

Définissez le chemin de base dans le système de fichiers :

Faker::make(Png::class)
    ->basePath('images/uploads')  // Fichiers stockés dans /storage/images/uploads/.

count(int $count): Faker

Définissez le nombre de fichiers à générer :

Faker::make(Png::class)
    ->count(1000)

concurrency(int $threads, ?int $coroutines = null): Faker

Configurez l'exécution parallèle :

// Concurrence de base
Faker::make(Png::class)
    ->concurrency(4)
 
// Spécifique à Swoole : threads et coroutines
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

seed(int $seed): Faker

Définissez la graine pour une génération déterministe :

Faker::make(Png::class)
    ->seed(42)

nameGenerator(Closure $generator): Faker

Personnalisez le nommage des fichiers :

Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "file-{$completedFiles}.png";
    })

diskOptions(array $diskOptions): Faker

Passez des options à l'adaptateur de système de fichiers :

Faker::make(Png::class)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
    ])

generate(): void

Exécutez la génération de fichiers :

Faker::make(Png::class)->generate();

🔗Directives de Support

Merci d'avoir choisi notre paquet open source ! Veuillez prendre un moment pour consulter ces directives de support. Elles vous aideront à tirer le meilleur parti de notre projet.

🔗Support Axé sur la Communauté

Notre projet open-source est alimenté par notre incroyable communauté. Si vous avez des questions ou avez besoin d'aide, StackOverflow et d'autres ressources en ligne sont vos meilleures options.

🔗Bugs et Priorisation des Fonctionnalités

La réalité de la gestion d'un projet open-source signifie que nous ne pouvons pas traiter tous les bugs ou demandes de fonctionnalités immédiatement. Nous priorisons les problèmes dans l'ordre suivant :

1. Bugs Affectant Nos Produits Payants

Les bugs qui impactent nos produits payants seront toujours notre priorité absolue. Dans certains cas, nous ne traiterons peut-être que les bugs qui nous affectent directement.

2. Demandes de Tirage de la Communauté

Si vous avez identifié un bug et avez une solution, veuillez soumettre une demande de tirage. Après les problèmes affectant nos produits, nous accordons la prochaine priorité la plus élevée à ces corrections pilotées par la communauté. Une fois examinée et approuvée, nous fusionnerons votre solution et créditerons votre contribution.

3. Soutien Financier

Pour les problèmes en dehors des catégories mentionnées, vous pouvez choisir de financer leur résolution. Chaque problème ouvert est lié à un bon de commande où vous pouvez contribuer financièrement. Nous priorisons ces problèmes en fonction du montant du financement fourni.

Contributions de la Communauté

L'open-source prospère lorsque sa communauté est active. Même si vous ne réparez pas de bugs, envisagez de contribuer par des améliorations de code, des mises à jour de documentation, des tutoriels, ou en aidant les autres dans les canaux communautaires. Nous encourageons vivement tout le monde, en tant que communauté, à aider à soutenir le travail open-source.

Pour réitérer, DefectiveCode priorisera les bugs en fonction de leur impact sur nos produits payants, des demandes de tirage de la communauté, et du soutien financier reçu pour les problèmes.

🔗Licence - Licence MIT

Copyright © Defective Code, LLC. Tous droits réservés

La permission est par la présente accordée, gratuitement, à toute personne obtenant une copie de ce logiciel et des fichiers de documentation associés (le "Logiciel"), de traiter le Logiciel sans restriction, y compris sans limitation les droits d'utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, de sous-licencier, et/ou de vendre des copies du Logiciel, et de permettre aux personnes à qui le Logiciel est fourni de le faire, sous réserve des conditions suivantes :

L'avertissement de copyright ci-dessus et cet avis de permission doivent être inclus dans toutes les copies ou portions substantielles du Logiciel.

LE LOGICIEL EST FOURNI "EN L'ÉTAT", SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU TACITE, Y COMPRIS MAIS SANS S'Y LIMITER AUX GARANTIES DE COMMERCIALITÉ, D'ADAPTATION À UN OBJECTIF PARTICULIER ET DE NON CONTREFAÇON. EN AUCUN CAS, LES AUTEURS OU DÉTENTEURS DE DROITS D'AUTEUR NE POURRONT ÊTRE TENUS RESPONSABLES DE TOUTE RECLAMATION, DOMMAGE OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS LE CADRE D'UN CONTRAT, DUN DÉLIT OU AUTRE, DÉCOULANT DE, OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU AUTRES TRANSACTIONS DANS LE LOGICIEL.