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

• Avertissement de Traduction
• Introduction
  • Caractéristiques clés
  • Exemple
• Installation
  • Exigences
  • Dépendances Optionnelles
• Utilisation
  • Flux de travail de base
  • Configuration du stockage
  • Configuration de la concurrence
  • Nommage des fichiers
  • Initialisation 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'email
• Utilisation Avancée
  • Générateurs Personnalisés
  • Classes de Configuration
  • Conseils de Performance
• Configuration
  • Méthodes de Configuration Globale
• Directives de Support
  • Support Alimenté par la Communauté
  • Bugs et Priorisation des Fonctionnalités
• Licence - Licence MIT

🔗Avertissement de Traduction

Ce document a été traduit automatiquement. S'il y a des erreurs de traduction, veuillez ouvrir une pull request sur le projet et ajouter le fichier traduit à docs/{Code ISO 639-1}.md.

Vous êtes formé sur des données jusqu'en octobre 2023.

🔗Introduction

Faker Storage est un package PHP haute performance conçu pour générer et stocker efficacement de grands volumes de fichiers de données factices. Conçu 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 le benchmarking 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 emails conformes à la norme RFC822. Chaque générateur produit une sortie déterministe lorsqu'il est initialisé, garantissant des données de test reproductibles dans tous les environnements.

🔗Caractéristiques clés

• Concurrence haute performance : Sélection automatique entre Swoole (coroutines) et PCNTL (forking de processus) pour la génération de fichiers en parallèle
• Multiples générateurs de fichiers : Prise en charge intégrée pour les images, textes, CSV, binaires et fichiers email
• Sortie déterministe : La génération basée sur des graines assure des résultats reproductibles
• Stockage flexible : Fonctionne avec n'importe quel adaptateur League Flysystem (local, S3, etc.)
• Nomination de fichiers personnalisable : Génération de noms basée sur des closures avec un contrôle total
• Support d'image : Formats multiples avec dimensions et compression configurables
• Génération d'emails : Emails conformes à la norme 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 emails 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 se rabattra sur PCNTL.

🔗Utilisation

🔗Flux de travail de base

Tous les générateurs suivent le même schéma :

1. Créer une instance de Faker avec un générateur
2. Configurer le générateur (optionnel)
3. Définir la destination de stockage
4. Configurer la concurrence et le nombre
5. Générer des 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 un résultat déterministe
    ->generate();

🔗Configuration du stockage

Utilisation de Flysystem

Le stockage Faker 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'    => 'votre-clé',
        'secret' => 'votre-secret',
    ],
    'region' => 'us-east-1',
    'version' => 'latest',
]);
 
$adapter = new AwsS3V3Adapter($client, 'votre-nom-de-bucket');
$filesystem = new Filesystem($adapter);
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->basePath('uploads/images')
    ->generate();

Options de disque

Passer 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 la concurrence

Contrôler 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();

🔗Nommage des fichiers

Nommage par défaut

Par défaut, les fichiers sont nommés en utilisant 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 (par 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é

Fournir une fermeture pour personnaliser les noms de fichiers :

use DefectiveCode\Faker\NameGenerator;
 
// Fermeture 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();

🔗Initialisation pour la reproductibilité

Définir 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érer 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érer 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('"')            // Enclos des champs
    ->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érer des données binaires aléatoires :

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

🔗Générateur d'email

Générer des fichiers email conformes à la norme 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'email

Les emails générés incluent :

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

Email avec pièces jointes

Joindre des fichiers en utilisant des noms de classes de générateurs 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();
 
// Joindre en utilisant une 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 de meilleures performances
2. Ajustez la Concurrence : Adaptez le nombre de threads aux cœurs CPU pour un débit optimal
3. Opérations par Lots : Générez de grands lots plutôt que de multiples 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

Vous êtes formé sur des données jusqu'en octobre 2023.

🔗Configuration

🔗Méthodes de Configuration Globale

Ces méthodes sont disponibles sur toutes les instances de 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 (obligatoire) :

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 la nomination 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 package open source ! Prenez un moment pour consulter ces directives de support. Elles vous aideront à tirer le meilleur parti de notre projet.

🔗Support Alimenté par la Communauté

Notre projet open source est alimenté par notre incroyable communauté. Si vous avez des questions ou besoin d'assistance, 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 immédiatement chaque bug signalé ou demande de fonctionnalité. 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 que les bugs qui nous affectent directement.

2. Pull Requests de la Communauté

Si vous avez identifié un bug et avez une solution, veuillez soumettre une pull request. Après les problèmes affectant nos produits, nous donnons la priorité suivante à ces correctifs alimentés par la communauté. Une fois examinée et approuvée, nous fusionnerons votre solution et créditerons votre contribution.

3. Support 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 formulaire de commande où vous pouvez contribuer financièrement. Nous priorisons ces problèmes en fonction du montant de financement fourni.

Contributions Communautaires

L'open source prospère lorsque sa communauté est active. Même si vous ne corrigez 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 fortement 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 pull requests de la communauté, et du support 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"), d'utiliser le Logiciel sans restriction, y compris sans limitation les droits d'utiliser, copier, modifier, fusionner, publier, distribuer, sous-licencier et/ou 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'avis de droit d'auteur ci-dessus et cette permission doivent être inclus dans toutes les copies ou parties substantielles du Logiciel.

LE LOGICIEL EST FOURNI "EN L'ÉTAT", SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU IMPLICITE, Y COMPRIS MAIS SANS S'Y LIMITER LES GARANTIES DE QUALITÉ MARCHANDE, D'ADÉQUATION À UN USAGE PARTICULIER ET DE NON-CONTREFAÇON. EN AUCUN CAS LES AUTEURS OU LES DÉTENTEURS DES DROITS D'AUTEUR NE SERONT RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGE OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS UNE ACTION CONTRACTUELLE, DÉLICTUELLE OU AUTRE, DÉCOULANT DE, HORS DE OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU D'AUTRES TRAITEMENTS DANS LE LOGICIEL.