Introduktion
- Nyckelfunktioner
- Exempel
Installation
- Krav
- Valfria beroenden
Användning
Generatorer
Avancerad användning
Konfiguration
- Globala konfigurationsmetoder
Stödriktlinjer
- Gemenskapsdriven Stöd
- Buggar och Prioritering av Funktioner
Licens - MIT Licens

Introduktion

Faker Storage är ett högpresterande PHP-paket som är utformat för att effektivt generera och lagra stora volymer av falska datafiler. Byggt med samtidighet i åtanke, utnyttjar det Swoole eller PCNTL för att generera tusentals filer parallellt, vilket gör det idealiskt för belastningstester, utvecklingsmiljöer och lagringssystembenchmarking.

Paketet erbjuder en flytande API för att generera olika filtyper inklusive bilder (PNG, JPG, GIF, BMP, WEBP, AVIF), textfiler, CSV-filer, binära data och RFC822-kompatibla e-postmeddelanden. Varje generator producerar deterministisk utdata när den frös, vilket säkerställer reproducerbara testdata över olika miljöer.

Nyckelfunktioner

Högpresterande samtidighet: Automatisk val mellan Swoole (korutiner) och PCNTL (processfältning) för parallell filgenerering
Flera filgeneratorer: Inbyggt stöd för bilder, text, CSV, binär och e-postfiler
Deterministisk utdata: Fröbaserad generering säkerställer reproducerbara resultat
Flexibel lagring: Fungerar med valfri League Flysystem-adapter (lokal, S3, etc.)
Anpassningsbar filnamngivning: Stängningsbaserad namngivning med full kontroll
Bildstöd: Flera format med konfigurerbara dimensioner och kompression
E-postgenerering: RFC822-kompatibla e-postmeddelanden med bilagor och MIME-stöd

Exempel

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Png;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Generera 1000 PNG-bilder med 10 samtidiga arbetare
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();
 
// Generera CSV-filer
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();
 
// Generera e-postmeddelanden med bilagor
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

Installera paketet via Composer:

composer require defectivecode/faker-storage

Krav

PHP >= 8.4
ext-gd (för bildgenerering)
ext-swoole (valfritt, för bättre prestanda)
ext-pcntl (reserv för samtidighet)

Valfria beroenden

För optimal prestanda, installera Swoole-tillägget:

pecl install swoole

Paketet kommer automatiskt att använda Swoole om det finns tillgängligt, annars faller det tillbaka på PCNTL.

Användning

Grundläggande arbetsflöde

Alla generatorer följer samma mönster:

Skapa en Faker-instans med en generator
Konfigurera generatorn (valfritt)
Ställ in lagringsdestination
Konfigurera samtidighet och antal
Generera filer

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)          // Generator-specifik konfiguration
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // Filer kommer att vara i /storage/documents/
    ->count(100)                 // Generera 100 filer
    ->concurrency(4)             // Använd 4 arbetare
    ->seed(123)                  // För deterministisk utdata
    ->generate();

Lagringskonfiguration

Använda Flysystem

Faker Storage använder League Flysystem för lagringsabstraktion:

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

AWS S3-lagring

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();

Diskalternativ

Skicka ytterligare alternativ till filsystemadapter:

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

Samtidighetskonfiguration

Kontrollera parallell exekvering med metoden concurrency():

// Använd 10 arbetstrådar/processer
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Swoole-specifik: Ställ in både trådar och korutiner per tråd
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 arbetare, 8 korutiner vardera
    ->generate();

Filnamngivning

Standardnamngivning

Som standard namnges filer med UUID v4:

// Genererar: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
Faker::make(Png::class)->generate();

Inbyggda namngeneratorer

use DefectiveCode\Faker\NameGenerator;
 
// UUID-baserad (standard)
NameGenerator::setDefault('uuid'); // Genererar: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
 
// Sekventiell numrering
NameGenerator::setDefault('sequence'); // Genererar: 1.png, 2.png, 3.png, ...

Anpassad namngivning

Tillhandahåll en stängning för att anpassa filnamn:

use DefectiveCode\Faker\NameGenerator;
 
// Anpassad stängning
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "custom-{$completedFiles}-{$seed}.png";
    })
    ->generate();
 
// Datumbaserad namngivning
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return date('Y/m/d') . "/image-{$completedFiles}.png";
    })
    ->generate();

Fröning för reproducerbarhet

Ställ in ett frö för att generera samma filer vid flera körningar:

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

Varje fil får ett unikt deterministiskt frö som härleds från grundfröet och filindexet.

Generatorer

Bildgeneratorer

Alla bildgeneratorer stödjer dimension- och kvalitetskonfiguration.

PNG

use DefectiveCode\Faker\Generators\Png;
 
Faker::make(Png::class)
    ->width(800, 1920)          // Slumptal bredd mellan 800-1920px
    ->height(600, 1080)         // Slumptal höjd mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfakanal/transparens
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

JPG

use DefectiveCode\Faker\Generators\Jpg;
 
Faker::make(Jpg::class)
    ->width(800, 1920)          // Slumptal bredd mellan 800-1920px
    ->height(600, 1080)         // Slumptal höjd mellan 600-1080px
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

GIF

use DefectiveCode\Faker\Generators\Gif;
 
Faker::make(Gif::class)
    ->width(800, 1920)          // Slumptal bredd mellan 800-1920px
    ->height(600, 1080)         // Slumptal höjd mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfakanal/transparens
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

BMP

use DefectiveCode\Faker\Generators\Bmp;
 
Faker::make(Bmp::class)
    ->width(800, 1920)          // Slumptal bredd mellan 800-1920px
    ->height(600, 1080)         // Slumptal höjd mellan 600-1080px
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

WEBP

use DefectiveCode\Faker\Generators\Webp;
 
Faker::make(Webp::class)
    ->width(800, 1920)          // Slumptal bredd mellan 800-1920px
    ->height(600, 1080)         // Slumptal höjd mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfakanal/transparens
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

AVIF

use DefectiveCode\Faker\Generators\Avif;
 
Faker::make(Avif::class)
    ->width(800, 1920)          // Slumptal bredd mellan 800-1920px
    ->height(600, 1080)         // Slumptal höjd mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfakanal/transparens
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

Slumputbild

Genererar ett slumpmässigt bildformat:

use DefectiveCode\Faker\Generators\RandomImage;
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(false)          // Slumptal från: AVIF, BMP, GIF, JPEG, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(true)           // Slumptal från: AVIF, GIF, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();

Textgenerator

Generera vanliga textfiler med stycken:

use DefectiveCode\Faker\Generators\Text;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)         // 5-10 stycken per fil
    ->sentences(3, 6)           // 3-6 meningar per stycke
    ->toDisk($filesystem)
    ->generate();

Utdataexempel:

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.

CSV-generator

Generera CSV-filer med slumpmässiga data:

use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)            // 5-10 kolumner
    ->rows(100, 500)            // 100-500 rader
    ->delimiter(',')            // Kolumnseparator
    ->enclosure('"')            // Fältinramning
    ->escape('\\')              // Escape-tecken
    ->eol("\n")                 // Radavslutning
    ->toDisk($filesystem)
    ->generate();

Utdataexempel:

"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"

Binärgenerator

Generera slumpmässiga binära data:

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

E-postgenerator

Generera RFC822-kompatibla e-postfiler:

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // Stycken i e-postmeddelandets kropp
    ->sentences(2, 4)           // Meningar per stycke
    ->withAttachment(Png::class, 1, 3)  // Lägg till 1-3 PNG-bilagor
    ->toDisk($filesystem)
    ->generate();

E-posthuvuden

Genererade e-postmeddelanden inkluderar:

Till: Slumptal namn och e-post
Från: Slumptal namn och e-post
Ämne: Slumptal mening
Datum: Aktuellt tidsstämpel
Meddelande-ID: Deterministiskt ID baserat på fröet

E-post med bilagor

Bifoga filer med generatorklassnamn eller instanser:

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 PNG-bilagor
    ->generate();
 
// Bifoga med konfigurera generatorinstans
$pngGenerator = new Png(Png::getDefaultConfig());
$pngGenerator->width(400, 800)->height(300, 600);
 
Faker::make(Email::class)
    ->withAttachment($pngGenerator, 2, 5)
    ->generate();

Utdataexempel:

Till: John Doe <john.doe@example.com>
Från: Jane Smith <jane.smith@example.com>
Ämne: Viktigt möte imorgon
Datum: Fre, 03 Jan 2026 10:30:00 +0000
Meddelande-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--

Avancerad användning

Anpassade generatorer

Skapa dina egna generatorer genom att implementera Generator-gränssnittet:

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
    {
        // Din generation logik här
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// Använd din anpassade generator
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

Konfigurationsklasser

Varje generator använder en konfigurationsklass som utökar Config:

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

Prestandatips

Använd Swoole: Installera Swoole-tillägget för bästa prestanda
Justera samtidighet: Matcha trådantalet med CPU-kärnorna för optimal genomströmning
Batchoperationer: Generera stora batchar i stället för flera små körningar
Lagringsplats: Använd snabb lagring (SSD, lokal disk) för temporära filer innan uppladdning
Nätverks-I/O: När du använder S3, öka samtidigheten för att maximera bandbreddsanvändningen

Konfiguration

Globala konfigurationsmetoder

Dessa metoder är tillgängliga för alla Faker-instanser:

`make(string $generator): Faker`

Skapa en ny Faker-instans med den angivna generatorn:

Faker::make(Png::class)

`toDisk(Filesystem $filesystem): Faker`

Ställ in lagringsdestination (obligatorisk):

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

`basePath(string $basePath): Faker`

Ställ in grundläggande sökväg inom filsystemet:

Faker::make(Png::class)
    ->basePath('images/uploads')  // Filer lagras i /storage/images/uploads/

`count(int $count): Faker`

Ställ in antalet filer som ska genereras:

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

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

Konfigurera parallell exekvering:

// Grundläggande samtidighet
Faker::make(Png::class)
    ->concurrency(4)
 
// Swoole-specifik: trådar och korutiner
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

`seed(int $seed): Faker`

Ställ in frö för deterministisk generering:

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

`nameGenerator(Closure $generator): Faker`

Anpassa filnamngivning:

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

`diskOptions(array $diskOptions): Faker`

Skicka alternativ till filsystemadapter:

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

`generate(): void`

Utför filgenerering:

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

Stödriktlinjer

Tack för att du valde vårt öppna källkodsprojekt! Vänligen ta ett ögonblick för att titta på dessa stödriktlinjer. De kommer att hjälpa dig att få ut det mesta av vårt projekt.

Gemenskapsdriven Stöd

Vårt öppna källkodsprojekt drivs av vår fantastiska gemenskap. Om du har frågor eller behöver hjälp, är StackOverflow och andra online-resurser dina bästa alternativ.

Buggar och Prioritering av Funktioner

Verkligheten av att hantera ett öppet källkodsprojekt betyder att vi inte kan ta itu med varje rapporterad bugg eller funktionsönskemål omedelbart. Vi prioriterar ärenden i följande ordning:

1. Buggar som Påverkar Våra Betalda Produkter

Buggar som påverkar våra betalda produkter kommer alltid att vara vår högsta prioritet. I vissa fall kan vi endast ta itu med buggar som påverkar oss direkt.

2. Gemenskaps Pull Begärningar

Om du har identifierat en bugg och har en lösning, vänligen skicka in en pull-begäran. Efter ärenden som påverkar våra produkter ger vi näst högsta prioritet till dessa gemenskapsdrivna lösningar. När de har granskats och godkänts, kommer vi att sammanfoga din lösning och kreditera ditt bidrag.

3. Ekonomiskt Stöd

För frågor utanför de nämnda kategorierna kan du välja att finansiera deras lösning. Varje öppen fråga är kopplad till ett beställningsformulär där du kan bidra ekonomiskt. Vi prioriterar dessa frågor baserat på det belopp som anges.

Gemenskapsbidrag

Öppen källkod blomstrar när dess gemenskap är aktiv. Även om du inte åtgärdar buggar, överväg att bidra genom kodförbättringar, dokumentationsuppdateringar, handledningar eller genom att hjälpa andra i gemenskapskanaler. Vi uppmuntrar starkt alla, som en gemenskap, att hjälpa till att stödja arbetet med öppen källkod.

För att upprepa, kommer DefectiveCode att prioritera buggar baserat på hur de påverkar våra betalda produkter, gemenskaps pull-begärningar, och det ekonomiska stöd som erhållits för problem.

Licens - MIT Licens

Härmed beviljas tillstånd, kostnadsfritt, till varje person som erhåller en kopia av denna programvara och tillhörande dokumentationsfiler (”Programvaran”), att hantera Programvaran utan begränsningar, inklusive utan begränsning rätten att använda, kopiera, modifiera, sammanfoga, publicera, distribuera, underlicensiera och/eller sälja kopior av Programvaran, och att tillåta personer som Programvaran tillhandahålls till att göra det, med förbehåll för följande villkor:

Den ovanstående copyrightnotisen och denna tillståndsnotis ska inkluderas i alla kopior eller väsentliga delar av Programvaran.

PROGRAMVARAN TILLHANDAHÅLLS "I BEFINTLIGT SKICK", UTAN NÅGON SOM HELST GARANTI, VARE SIG UTTRYCKLIG ELLER UNDERFÖRSTÅDD, INKLUSIVE MEN INTE BEGRÄNSAT TILL GARANTIER FÖR SÄLJBARHET, LÄMPLIGHET FÖR ETT BESTÄMT ÄNDAMÅL OCH INTE KRÄNKNING. UNDER INGA OMSTÄNIGHETER SKA FÖRFATTARNA ELLER COPYRIGHTINNEHAVARNA ANSVARA FÖR NÅGON FORDRAN, SKADOR ELLER ANNAN ANSVARSSKYLDIGHET, VARE SIG I EN RÄTTSLIG ÅTGÄRD, SKADESTÅND ELLER ANNAT, SOM UPPSTÅR FRÅN, GENOM ELLER I SAMBAND MED PROGRAMVARAN ELLER ANVÄNDNINGEN ELLER ANDRA AFFÄRER I PROGRAMVARAN.

🔗Introduktion

🔗Nyckelfunktioner

🔗Exempel

🔗Installation

🔗Krav

🔗Valfria beroenden

🔗Användning

🔗Grundläggande arbetsflöde

🔗Lagringskonfiguration

Använda Flysystem

AWS S3-lagring

Diskalternativ

🔗Samtidighetskonfiguration

🔗Filnamngivning

Standardnamngivning

Inbyggda namngeneratorer

Anpassad namngivning

🔗Fröning för reproducerbarhet

🔗Generatorer

🔗Bildgeneratorer

PNG

JPG

GIF

BMP

WEBP

AVIF

Slumputbild

🔗Textgenerator

🔗CSV-generator

🔗Binärgenerator

🔗E-postgenerator

E-posthuvuden

E-post med bilagor

🔗Avancerad användning

🔗Anpassade generatorer

🔗Konfigurationsklasser

🔗Prestandatips

🔗Konfiguration

🔗Globala konfigurationsmetoder

make(string $generator): Faker

toDisk(Filesystem $filesystem): Faker

basePath(string $basePath): Faker

count(int $count): Faker

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

seed(int $seed): Faker

nameGenerator(Closure $generator): Faker

diskOptions(array $diskOptions): Faker

generate(): void

🔗Stödriktlinjer

🔗Gemenskapsdriven Stöd

🔗Buggar och Prioritering av Funktioner

1. Buggar som Påverkar Våra Betalda Produkter

2. Gemenskaps Pull Begärningar

3. Ekonomiskt Stöd

Gemenskapsbidrag

🔗Licens - MIT Licens

Introduktion

Nyckelfunktioner

Exempel

Installation

Krav

Valfria beroenden

Användning

Grundläggande arbetsflöde

Lagringskonfiguration

Samtidighetskonfiguration

Filnamngivning

Fröning för reproducerbarhet

Generatorer

Bildgeneratorer

Textgenerator

CSV-generator

Binärgenerator

E-postgenerator

Avancerad användning

Anpassade generatorer

Konfigurationsklasser

Prestandatips

Konfiguration

Globala konfigurationsmetoder

`make(string $generator): Faker`

`toDisk(Filesystem $filesystem): Faker`

`basePath(string $basePath): Faker`

`count(int $count): Faker`

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

`seed(int $seed): Faker`

`nameGenerator(Closure $generator): Faker`

`diskOptions(array $diskOptions): Faker`

`generate(): void`

Stödriktlinjer

Gemenskapsdriven Stöd

Buggar och Prioritering av Funktioner

Licens - MIT Licens