PHPackages                             tobento/service-seeder - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. tobento/service-seeder

ActiveLibrary[Utility & Helpers](/categories/utility)

tobento/service-seeder
======================

Generating fake data customized for your PHP application needs.

2.0(7mo ago)01474MITPHPPHP >=8.4

Since Nov 27Pushed 7mo ago1 watchersCompare

[ Source](https://github.com/tobento-ch/service-seeder)[ Packagist](https://packagist.org/packages/tobento/service-seeder)[ Docs](https://www.tobento.ch)[ RSS](/packages/tobento-service-seeder/feed)WikiDiscussions 2.x Synced 1mo ago

READMEChangelog (3)Dependencies (5)Versions (5)Used By (4)

Seeder Service
==============

[](#seeder-service)

Generating fake data customized for your PHP application needs.

Table of Contents
-----------------

[](#table-of-contents)

- [Getting started](#getting-started)
    - [Requirements](#requirements)
    - [Highlights](#highlights)
- [Documentation](#documentation)
    - [Create Seed](#create-seed)
    - [Add Seeders](#add-seeders)
    - [Seed](#seed)
    - [Localization](#localization)
    - [Random Seeding](#random-seeding)
    - [Seeders](#seeders)
        - [Resource Seeder](#resource-seeder)
        - [DateTime Seeder](#datetime-seeder)
        - [User Seeder](#user-seeder)
        - [Create Custom Seeder](#create-custom-seeder)
    - [Resources](#resources)
        - [Create Resources](#create-resources)
        - [Add Resources](#add-resources)
        - [Filter Resources](#filter-resources)
        - [File Resource](#file-resource)
        - [Get Resources And Items](#get-resources-and-items)
    - [Files Resources](#files-resources)
        - [Create Files Resources](#create-files-resources)
        - [Directory Structure](#directory-structure)
        - [Supported Files](#supported-files)
        - [Supporting Other Files](#supporting-other-files)
    - [Static Seeders](#static-seeders)
        - [Str Seeder](#str-seeder)
        - [Lorem Seeder](#lorem-seeder)
        - [Num Seeder](#num-seeder)
        - [Json Seeder](#json-seeder)
        - [Arr Seeder](#arr-seeder)
- [Credits](#credits)

---

Getting started
===============

[](#getting-started)

Add the latest version of the Seeder service project running this command.

```
composer require tobento/service-seeder

```

Requirements
------------

[](#requirements)

- PHP 8.4 or greater

Highlights
----------

[](#highlights)

- Framework-agnostic, will work with any project
- Decoupled design
- Flexible managing your resource data to fit your application
- Easily extendable

Documentation
=============

[](#documentation)

Do only use for seeding. It will not generate cryptographically secure string and numbers as it focuses more on speed.

Create Seed
-----------

[](#create-seed)

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\SeedInterface;

$seed = new Seed(
    resources: new Resources(),
    locale: 'en',
    localeFallbacks: ['de' => 'en'],
    localeMapping: ['de' => 'de-CH'],
);

var_dump($seed instanceof SeedInterface);
// bool(true)
```

Add Seeders
-----------

[](#add-seeders)

```
use Tobento\Service\Seeder\UserSeeder;

$seed->addSeeder(
    name: 'user',
    seeder: new UserSeeder($seed)
);
```

**Add callable seeder**

```
use Tobento\Service\Seeder\SeedInterface;
use Tobento\Service\Seeder\Lorem;

$seed->addCallableSeeder(
    method: 'word',
    seeder: function(SeedInterface $seed, null|string|array $locale, array $params): string {
        return Lorem::word(...$params);
    }
);

$words = $seed->word(number: 2);
```

**Add callable seeder using resource items**

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\SeedInterface;
use Tobento\Service\Seeder\Arr;
use Tobento\Service\Seeder\Lorem;

$seed = new Seed(
    new Resources(
        new Resource('colors', 'en', [
            'blue', 'red', 'green', 'yellow', 'pink',
        ]),
        new Resource('colors', 'de', [
            'blau', 'rot', 'grün', 'gelb', 'pink',
        ]),
    ),
);

$seed->addCallableSeeder(
    method: 'color',
    seeder: function(SeedInterface $seed, null|string|array $locale, array $params): string {

        $colors = $seed->getItems('colors', $locale);

        if (!empty($colors)) {
            return Arr::item($colors);
        }

        return ucfirst(Lorem::word(number: 1));
    }
);

// default locale used:
$color = $seed->color();

// specific locale:
$color = $seed->locale('de')->color();

// specific locales:
$color = $seed->locale(['en', 'de'])->color();

// all locales:
$color = $seed->locale([])->color();
```

Seed
----

[](#seed)

**seeding**

The Seed::class dynamically calls a seeder method to seed data. It throws a SeedMethodCallException if no seeder is found supporting the called method.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\ResourceSeeder;
use Tobento\Service\Seeder\SeedMethodCallException;

$seed = new Seed(
    new Resources(
        new Resource('countries', 'en', [
            'Usa', 'Switzerland', 'Germany',
        ]),
    ),
);

$seed->addSeeder('resource', new ResourceSeeder($seed));

try {
    $value = $seed->itemFrom(resource: 'countries');
    var_dump($value);
    // string(11) "Switzerland"
} catch (SeedMethodCallException $e) {
    // handle
}
```

**seeder**

You may use the **seeder** method to return a seeder added.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\ResourceSeeder;
use Tobento\Service\Seeder\SeederInterface;
use Tobento\Service\Seeder\SeederNotFoundException;

$seed = new Seed(new Resources());

$seed->addSeeder('resource', new ResourceSeeder($seed));

try {
    var_dump($seed->seeder('resource') instanceof SeederInterface);
    // bool(true)
} catch (SeederNotFoundException $e) {
    // handle
}
```

**resources**

You may use the **resources** method to return the resources.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\ResourcesInterface;

$seed = new Seed(new Resources());

var_dump($seed->resources() instanceof ResourcesInterface);
// bool(true)
```

**getItems**

You may use the **getItems** method to return items of a specified resource. If multiple locales specified, it merges items.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;

$seed = new Seed(
    new Resources(
        new Resource('countries', 'en', [
            'Usa', 'Switzerland', 'Germany',
        ]),
    ),
);

$items = $seed->getItems(
    name: 'countries',
    locale: 'en', // null|string|array
);

var_dump($items);
// array(3) { [0]=> string(3) "Usa" [1]=> string(11) "Switzerland" [2]=> string(7) "Germany" }

// default locale used:
$items = $seed->getItems('countries');

// specific locale:
$items = $seed->getItems('countries', 'en');

// specific locales:
$items = $seed->getItems('countries', ['en']);

// all locales:
$items = $seed->getItems('countries', []);
```

Localization
------------

[](#localization)

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;

$seed = new Seed(
    resources: new Resources(),
    locale: 'en',
    localeFallbacks: ['de' => 'en'],
    localeMapping: ['de' => 'de-CH'],
);

// set the default locale:
$seed->setLocale('de');

// get the default locale:
var_dump($seed->getLocale());
// string(2) "de"

// set the locale fallbacks:
$seed->setLocaleFallbacks(['de' => 'en']);

// get the locale fallbacks:
var_dump($seed->getLocaleFallbacks());
// array(1) { ["de"]=> string(2) "en" }

// set the locale mapping:
$seed->setLocaleMapping(['de' => 'de-CH']);

// get the locale mapping:
var_dump($seed->getLocaleMapping());
// array(1) { ["de"]=> string(5) "de-CH" }
```

**seeding**

Use the **locale** method before calling a seeder method to seed data from resources in the specific locale(s).

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\ResourceSeeder;

$seed = new Seed(
    new Resources(
        new Resource('countries', 'en', [
            'Usa', 'Switzerland', 'Germany',
        ]),
        new Resource('countries', 'de', [
            'Usa', 'Schweiz', 'Deutschland',
        ]),
    ),
);

$seed->addSeeder('resource', new ResourceSeeder($seed));

// default locale used:
var_dump($seed->itemFrom(resource: 'countries'));
// string(7) "Germany"

// specific locale:
var_dump($seed->locale('de')->itemFrom('countries'));
// string(7) "Schweiz"

// specific locales:
var_dump($seed->locale(['en', 'de'])->itemFrom('countries'));
// string(11) "Deutschland"

// all locales:
var_dump($seed->locale([])->itemFrom('countries'));
// string(3) "Usa"
```

Random Seeding
--------------

[](#random-seeding)

You may use the **random** method before calling a seeder method to seed the specified value randomly by its probability percentage.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\ResourceSeeder;

$seed = new Seed(
    new Resources(
        new Resource('countries', 'en', [
            'Usa', 'Switzerland', 'Germany',
        ]),
    ),
);

$seed->addSeeder('resource', new ResourceSeeder($seed));

$value = $seed->random(
    value: null,
    probability: 50 // between 0 (always get false) and 100 (always get true)
)->itemFrom(resource: 'countries');

var_dump($value);
// NULL
```

Seeders
-------

[](#seeders)

### Resource Seeder

[](#resource-seeder)

The resource seeder provides handy methods to seed data using resource items. If no [Resoucres](#resoucres) for the methods are provided, it fallsback to [Lorem Seeder](#lorem-seeder) word(s) depending on methods.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\ResourceSeeder;

$seed = new Seed(
    new Resources(
        new Resource('countries', 'en', [
            'Usa', 'Switzerland', 'Germany',
        ]),
        new Resource('countries', 'de', [
            'Usa', 'Schweiz', 'Deutschland',
        ]),
    ),
);

$seed->addSeeder('resource', new ResourceSeeder($seed));

// default locale used:
var_dump($seed->itemFrom(resource: 'countries'));
// string(7) "Germany"

// specific locale:
var_dump($seed->locale('de')->itemFrom('countries'));
// string(7) "Schweiz"

// specific locales:
var_dump($seed->locale(['en', 'de'])->itemFrom('countries'));
// string(11) "Deutschland"

// all locales:
var_dump($seed->locale([])->itemFrom('countries'));
// string(3) "Usa"
```

**Available methods**

MethodParametersDescription**itemFrom**resource: 'countries'Returns a randomly selected item from the specified resource items.**itemsFrom**resource: 'countries', number: 3, unique: trueReturns randomly selected items from the specified resource items. If unique is set to true, it might return fewer items number as specified.### DateTime Seeder

[](#datetime-seeder)

The DateTime seeder provides handy methods to seed DateTime data. You may visit [Dater Service](https://github.com/tobento-ch/service-dater#date-formatter) for more detail on the DateFormatter::class.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\DateTimeSeeder;
use Tobento\Service\Dater\DateFormatter;

$seed = new Seed(new Resources());

$df = new DateFormatter(
    locale: $seed->getLocale()
);

$seed->addSeeder('dateTime', new DateTimeSeeder($df));

$dateTime = $seed->dateTime(from: '-30 years', to: 'now');

var_dump($dateTime);
// object(DateTimeImmutable)#8 (3) { ["date"]=> string(26) "2015-11-29 14:55:24.000000" ["timezone_type"]=> int(3) ["timezone"]=> string(13) "Europe/Berlin" }

var_dump($seed->locale('de')->month(3, 6, 'MMM'));
// string(5) "März"

var_dump($seed->locale(['de', 'fr'])->weekday(1, 7, 'EEEE'));
// string(7) "Sonntag"
```

**Available methods**

MethodParametersDescription**dateTime**from: '-30 years', to: 'now'Returns a date time object between the specified from and to date.**month**from: 1, to: 12, pattern: 'MMMM'Returns a month between the specified from and to month formatted by pattern. Pattern: 'M' = '1', 'MM' = '09', 'MMM' = 'Jan', 'MMMM' = 'January'**weekday**from: 1, to: 7, pattern: 'MMMM'Returns a weekday between the specified from and to weekday formatted by pattern. Pattern: E, EE, or EEE = 'Tue', 'EEEE' = 'Tuesday', 'EEEEE' = 'T', 'EEEEEE' = 'Tu'### User Seeder

[](#user-seeder)

The user seeder provides handy methods to seed user data. If no [Resoucres](#resoucres) for the methods are provided, it fallsback to [Lorem Seeder](#lorem-seeder) word(s) depending on methods.

```
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\UserSeeder;

$seed = new Seed(
    new Resources(
        new Resource('countries', 'en', [
            'Usa', 'Switzerland', 'Germany',
        ]),
        new Resource('countries', 'de', [
            'Usa', 'Schweiz', 'Deutschland',
        ]),
    ),
);

$seed->addSeeder('user', new UserSeeder($seed));

// default locale used:
var_dump($seed->country());
// string(7) "Germany"

// specific locale:
var_dump($seed->locale('de')->country());
// string(7) "Schweiz"

// specific locales:
var_dump($seed->locale(['en', 'de'])->country());
// string(11) "Deutschland"

// all locales:
var_dump($seed->locale([])->country());
// string(3) "Usa"
```

**Available methods**

MethodParametersResource(s) UsedDescription**firstnameFemale**firstnamesFemaleReturns a random female firstname.**firstnameMale**firstnamesMaleReturns a random male firstname.**firstname**firstnamesFemale, firstnamesMaleReturns a random firstname.**lastname**lastnamesReturns a random lastname.**fullnameFemale**separator: ' 'firstnamesFemale, lastnamesReturns a random female fullname.**fullnameMale**separator: ' 'firstnamesMale, lastnamesReturns a random male fullname.**fullname**firstnamesFemale, firstnamesMale, lastnamesReturns a random fullname.**firm**firmsReturns a random firm.**street**withNumber: falsestreetsReturns a random street.**postcode**postcodesReturns a random postcode.**city**citiesReturns a random city.**country**countriesReturns a random country.**email**from: nulldomains, firstnamesFemale, firstnamesMale, lastnamesReturns a random email. It will create the email based on the from parameter if specified.**smartphone**smartphonesReturns a random smartphone number.**telephone**telephonesReturns a random telephone number.**password**Returns a random password.### Create Custom Seeder

[](#create-custom-seeder)

You may create a custom seeder for your application.

```
use Tobento\Service\Seeder\Seeder;
use Tobento\Service\Seeder\Seed;
use Tobento\Service\Seeder\SeedInterface;
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Arr;
use Tobento\Service\Seeder\Lorem;

class CustomSeeder extends Seeder
{
    /**
     * Create a new CustomSeeder.
     *
     * @param SeedInterface $seed
     */
    public function __construct(
        protected SeedInterface $seed,
    ) {}

    /**
     * Returns the seed method names the seeder provides.
     *
     * @return array
     */
    public function seeds(): array
    {
        return [
            'paymentMethod',
        ];
    }

    /**
     * Returns a randomly selected item from the specified resource items.
     *
     * @return mixed
     */
    public function paymentMethod(): mixed
    {
        // get items from resource.
        $items = $this->seed->getItems('payment_methods', $this->locale);

        if (empty($items)) {
            // if no payment_methods resource is defined fallback to:
            $items = ['invoice', 'creditcard', 'paypal'];
        }

        return Arr::item($items);
    }
}

$seed = new Seed(new Resources());
$seed->addSeeder('custom', new CustomSeeder($seed));

var_dump($seed->paymentMethod());
// string(6) "paypal"
```

Resources
---------

[](#resources)

### Create Resources

[](#create-resources)

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\ResourcesInterface;
use Tobento\Service\Seeder\Resource;

$resources = new Resources(
    new Resource(
        name: 'colors',
        locale: 'en',
        items: ['blue', 'red']
    ),
);

var_dump($resources instanceof ResourcesInterface);
// bool(true)
```

### Add Resources

[](#add-resources)

You may add resources by using the **add** method:

**add resource**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;

$resources = new Resources();

$resources->add(new Resource('colors', 'en', [
    'red', 'blue',
]));
```

**add resources**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;

$resources = new Resources();

$resources->add(new Resources(
    new Resource('colors', 'en', [
        'red', 'blue',
    ]),
));
```

### Filter Resources

[](#filter-resources)

You may use the filter methods returning a new instance.

**filter**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\ResourceInterface;

$resources = new Resources(
    new Resource(
        name: 'colors',
        locale: 'en',
        items: ['blue', 'red']
    ),
    new Resource(
        name: 'colors',
        locale: 'de',
        items: ['blau', 'rot']
    ),
);

// filter by locale:
$resources = $resources->filter(
    fn(ResourceInterface $r): bool => $r->locale() === 'de'
);
```

**locale**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;

$resources = new Resources(
    new Resource(
        name: 'colors',
        locale: 'en',
        items: ['blue', 'red']
    ),
    new Resource(
        name: 'colors',
        locale: 'de',
        items: ['blau', 'rot']
    ),
);

// filter by locale:
$resources = $resources->locale('en');
```

**locales**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;

$resources = new Resources(
    new Resource(
        name: 'colors',
        locale: 'en',
        items: ['blue', 'red']
    ),
    new Resource(
        name: 'colors',
        locale: 'de',
        items: ['blau', 'rot']
    ),
);

// filter by locales:
$resources = $resources->locales(['en', 'de']);
```

**name**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;

$resources = new Resources(
    new Resource(
        name: 'colors',
        locale: 'en',
        items: ['blue', 'red']
    ),
    new Resource(
        name: 'colors',
        locale: 'de',
        items: ['blau', 'rot']
    ),
);

// filter by name:
$resources = $resources->name('colors');
```

### File Resource

[](#file-resource)

You may use the file resource to load data from json or php files.

```
use Tobento\Service\Seeder\ResourceFile;
use Tobento\Service\Seeder\ResourceInterface;

$resource = new ResourceFile(
    file: __DIR__.'/seeder/countries.json',
    locale: 'en',
    resourceName: 'countries'
);

var_dump($resource instanceof ResourceInterface);
bool(true)
```

#### Supported files are json and php

[](#supported-files-are-json-and-php)

**json**

```
["Switzerland", "Germany"]
```

**php**

```
return ['Switzerland', 'Germany'];
```

### Get Resources And Items

[](#get-resources-and-items)

**all**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;
use Tobento\Service\Seeder\ResourceInterface;

$resources = new Resources(
    new Resource(
        name: 'colors',
        locale: 'en',
        items: ['blue', 'red']
    ),
);

foreach($resources->all() as $resource) {
    var_dump($resource instanceof ResourceInterface);
    // bool(true)

    var_dump($resource->name());
    // string(6) "colors"

    var_dump($resource->locale());
    // string(2) "en"

    var_dump($resource->items());
    // array(2) { [0]=> string(4) "blue" [1]=> string(3) "red" }
}
```

**items**

```
use Tobento\Service\Seeder\Resources;
use Tobento\Service\Seeder\Resource;

$resources = new Resources(
    new Resource(
        name: 'colors',
        locale: 'en',
        items: ['blue', 'red']
    ),
);

$items = $resources->locale('en')->items();

var_dump($items);
// array(2) { [0]=> string(4) "blue" [1]=> string(3) "red" }
```

> ⚠️ **You must call locale() or locales() before all() or items() method if you have added (sub or lazy) resources, otherwise they will not get loaded.**

```
foreach($resources->locale('en')->all() as $resource) {
    var_dump($resource instanceof ResourceInterface);
    // bool(true)
}
```

Files Resources
---------------

[](#files-resources)

You may use the files resources to load resource data from a directory.

### Create Files Resources

[](#create-files-resources)

```
use Tobento\Service\Seeder\FilesResources;
use Tobento\Service\Dir\Dirs;
use Tobento\Service\Seeder\ResourcesInterface;

$resources = new FilesResources(
    new Dirs()->dir(dir: 'private/seeder/')
);

var_dump($resources instanceof ResourcesInterface);
// bool(true)
```

### Directory Structure

[](#directory-structure)

```
private/
    seeder/
        en/
            countries.json
            firstnamesFemale.json
            firstnamesMale.php
        de-CH/
            countries.json
            firstnamesFemale.json
            firstnamesMale.php

```

### Supported Files

[](#supported-files)

Currently supported files are json and php.

**json**

```
["Switzerland", "Germany"]
```

**php**

```
return ['Switzerland', 'Germany'];
```

### Supporting Other Files

[](#supporting-other-files)

You may support others files by providing your own resource factory:

```
use Tobento\Service\Seeder\FilesResources;
use Tobento\Service\Dir\Dirs;
use Tobento\Service\Seeder\ResourceFactory;
use Tobento\Service\Seeder\ResourceInterface;
use Tobento\Service\Filesystem\File;

class CustomResourceFactory extends ResourceFactory
{
    /**
     * Create a new Resource from file.
     *
     * @param string|File $file
     * @param string $locale
     * @return ResourceInterface
     */
    public function createResourceFromFile(
        string|File $file,
        string $locale,
    ): ResourceInterface {

        // Create your custom resource for the specific file extension

        // Otherwise use parent
        return parent::createResourceFromFile($file, $locale);
    }
}

$resources = new FilesResources(
    new Dirs()->dir(dir: 'private/seeder/'),
    new CustomResourceFactory()
);
```

Static Seeders
--------------

[](#static-seeders)

### Str Seeder

[](#str-seeder)

```
use Tobento\Service\Seeder\Str;

$string = Str::string(length: 10);
```

**Available methods**

MethodParametersDescription**string**length: 15, chars: 'abc123'Generates a random string. If char parameter is specified it only uses those for generation.**length**min: 1, max: 8, chars: 'abc123'Generates a random string between the min and max length with the chars specified.**replace**string: 'pattern', with: \[\]Returns the string replaced with the parameters specified.**replace**

```
use Tobento\Service\Seeder\Str;
use Tobento\Service\Seeder\Num;

$string = Str::replace(string: 'foo/bar', with: [
    'foo' => Num::int(1, 9),
    'bar' => Num::int(10, 20)
]);
```

### Lorem Seeder

[](#lorem-seeder)

```
use Tobento\Service\Seeder\Lorem;

$string = Lorem::word(number: 10);
```

**Available methods**

MethodParametersDescription**word**number: 10, separator: ' 'Generates a random lorem word(s) in lowercase.**words**minWords: 1, maxWords: 10, separator: ' 'Generates a random lorem words between the min and max words specified in lowercase.**sentence**number: 10Generates a random sentence(s).**slug**minWords: 1, maxWords: 10Generates a random slug between the min and max words specified.### Num Seeder

[](#num-seeder)

```
use Tobento\Service\Seeder\Num;

$float = Num::float(min: 1.5, max: 55.5);
```

**Available methods**

MethodParametersDescription**bool**Generates a random bool.**int**min: 1, max: 1000Generates a random int between the min and max specified.**float**min: 1.5, max: 55.5Generates a random float between the min and max specified.**price**min: 5, max: 80, precision: 0, step: 0.05Generates a random price between the min and max specified. If the precision parameter is not null, it rounds to the optional number of decimal digits. Use the step parameter for rounding in step.### Json Seeder

[](#json-seeder)

```
use Tobento\Service\Seeder\Json;
use Tobento\Service\Seeder\Num;

$string = Json::encode([
    'tax_id' => Num::int(min: 1, max: 10),
    'price_net' => Num::price(min: 1, max: 10),
]);
```

**Available methods**

MethodParametersDescription**encode**items: \[\]Encodes the specified items to a json string.**decode**string: ''Decodes the specified string to an array.### Arr Seeder

[](#arr-seeder)

```
use Tobento\Service\Seeder\Arr;

$value = Arr::item(['green', 'red', 'blue']);
```

**Available methods**

MethodParametersDescription**item**items: \[\]Randomly selects an item value from the items.**items**items: \[\], number: 3, unique: trueRandomly selects items value from the items. If unique is set to true, it might return fewer items number as specified.Credits
=======

[](#credits)

- [Tobias Strub](https://www.tobento.ch)
- [All Contributors](../../contributors)

###  Health Score

44

—

FairBetter than 91% of packages

Maintenance67

Regular maintenance activity

Popularity13

Limited adoption so far

Community13

Small or concentrated contributor base

Maturity70

Established project with proven stability

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~349 days

Total

5

Last Release

226d ago

Major Versions

1.x-dev → 2.02025-09-25

PHP version history (2 changes)1.0.0PHP >=8.0

2.0PHP >=8.4

### Community

Maintainers

![](https://www.gravatar.com/avatar/055d6a1b5c2384bb179c75ab0b55914231d898fdc4dffeb30770f81200e52206?d=identicon)[TOBENTOch](/maintainers/TOBENTOch)

---

Top Contributors

[![tobento-ch](https://avatars.githubusercontent.com/u/16684832?v=4)](https://github.com/tobento-ch "tobento-ch (9 commits)")

---

Tags

packageseedertobentoFake data

###  Code Quality

TestsPHPUnit

Static AnalysisPsalm

Type Coverage Yes

### Embed Badge

![Health badge](/badges/tobento-service-seeder/health.svg)

```
[![Health](https://phpackages.com/badges/tobento-service-seeder/health.svg)](https://phpackages.com/packages/tobento-service-seeder)
```

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)